using System;In our example, we have two classes. The Duck class and the Person class. Both have the quack() method.
public class Duck
{
public void quack()
{
Console.WriteLine("Quaaaack");
}
}
public class Person
{
public void quack()
{
Console.WriteLine("Person imitates a duck");
}
}
public class CSharpApp
{
static void Main()
{
Duck donald = new Duck();
Person josh = new Person();
InTheForest(donald);
InTheForest(josh);
}
public static void InTheForest(dynamic duck)
{
duck.quack();
}
}
public static void InTheForest(dynamic duck)The InTheForest() method has a dynamic parameter. The type of the object is not important; we are concerned about capabilities of the objects. If objects passed to the InTheForest() method can invoke the quack() method, than we are fine.
{
duck.quack();
}
$ dmcs ducktyping.csWe compile and run the program. We use the Mono dmcs compiler, that is shipped with the Mono 2.8 and supports the C# 4.0 profile.
$ /usr/local/bin/mono ducktyping.exe
Quaaaack
Person imitates a duck
using System;A simple example with named arguments.
public class CSharpApp
{
static void Main()
{
ShowMessage(name: "Jane", age: 17);
}
public static void ShowMessage(int age, string name)
{
Console.WriteLine("{0} is {1} years old", name, age);
}
}
ShowMessage(name: "Jane", age: 17);The parameter name is followed by the colon (:) character and the value. The parameters may not be specified in order of the method signature.
$ /usr/local/bin/mono named.exeOutput.
Jane is 17 years old
using System;An example for an optional argument. We have a Power() method. The method takes two parameters; the base and the exponent. If we do not specify the exponent, than the default 2 is used.
public class CSharpApp
{
static void Main()
{
Power(4, 4);
Power(5);
}
public static void Power(int x, int y=2)
{
int z = 1;
for (int i=0; i<y; i++)
{
z *= x;
}
Console.WriteLine(z);
}
}
public static void Power(int x, int y=2)In the method definition, we have a required x parameter and the optional y parameter. The optional y has a default value.
Power(4, 4);When we call the Power() method, we can specify one or two parameters.
Power(5);
$ /usr/local/bin/mono optional.exeOutput of the example.
256
25
using System;Arrays are covariant from the beginning.
public class CSharpApp
{
static void Main()
{
string[] langs = {"C#", "Python", "PHP", "Java"};
object[] objs = langs;
object o1 = objs[1];
Console.WriteLine(o1);
}
}
string[] langs = {"C#", "Python", "PHP", "Java"};
We have an array of string. object[] objs = langs;We assign a wider array of strings to a narrower object type.
object o1 = objs[1];We get an item and print it to the console.
Console.WriteLine(o1);
$ ./covariance.exeOutput of the array covariance example.
Python
using System;We have a generic list of strings. We call then the PrintAll() method, which prints all the elements of the list. Note that the method parameter has a less derived type parameter that our generic list.
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
IEnumerable<string> strings = new List<string>() {"1", "3", "2", "5"};
PrintAll(strings);
}
static void PrintAll(IEnumerable<object> objects)
{
foreach (object o in objects)
{
System.Console.WriteLine(o);
}
}
}
$ /usr/local/bin/mono covariance2.exeOutput.
1
3
2
5
using System;We assign a method which has a narrower parameter type to a delegate, which has a wider parameter type.
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
Action<string> del = ShowMessage;
del("Proximity alert");
}
static void ShowMessage(object message)
{
Console.WriteLine(message);
}
}
$ /usr/local/bin/mono contravariance.exeOutput.
Proximity alert
var keyword. It is an implicit data type. In some cases, we do not have to specify the type for a variable. This does not mean, that C# is partially a dynamic language. C# remains a statically and strongly typed programming language. Sometimes, when the usage of the var keyword is allowed, the compiler will find and use the type for us. var keyword is not allowed. It can be used only on a local variable. It cannot be applied on a field in a class scope. It must be declared and initialized in one statement. The variable cannot be initialized to null. using System;We have a small example, where we use the
public class CSharpApp
{
static void Main()
{
int x = 34;
var y = 32.3f;
var name = "Jane";
Console.WriteLine(x);
Console.WriteLine(y.GetType());
Console.WriteLine(name.GetType());
}
}
var type. int x = 34;The first variable is explicitly typed, the second variable is implicitly typed. The compiler will look at the right side of the assignment and infer the type of the variable.
var y = 32.3f;
Console.WriteLine(y.GetType());These two lines will check the type of the two variables.
Console.WriteLine(name.GetType());
$ ./itlv.exeAs we can see, the two variables use the familiar, built-in data types.
34
System.Single
System.String
using System;An example demonstrating the implicitly typed arrays.
public class CSharpApp
{
static void Main()
{
var items = new[] { "C#", "F#", "Python", "C" };
foreach (var item in items)
{
Console.WriteLine(item);
}
}
}
var items = new[] { "C#", "F#", "Python", "C" };
We again use the var keyword. The square brackets on the left side are omitted. foreach (var item in items)The foreach loop is used to traverse the array. Note the use of the local implicitly typed item variable.
{
Console.WriteLine(item);
}
$ ./ita.exeOutput.
C#
F#
Python
C
using System;In the above example, we have a Person class with two properties. We create two instances of this class. We use the old way and we also use the object initializer expression.
public class Person
{
private string _name;
private int _age;
public string Name
{
get { return _name; }
set { _name = value;}
}
public int Age
{
get { return _age; }
set { _age = value;}
}
public override string ToString()
{
return String.Format("{0} is {1} years old", _name, _age);
}
}
public class CSharpApp
{
static void Main()
{
Person p1 = new Person();
p1.Name = "Jane";
p1.Age = 17;
Person p2 = new Person { Name="Becky", Age=18 };
Console.WriteLine(p1);
Console.WriteLine(p2);
}
}
public string NameThis is a Name property, with set a get accessors.
{
get { return _name; }
set { _name = value;}
}
Person p1 = new Person();This is the old way of creating an object and initiating it with values using the field notation.
p1.Name = "Jane";
p1.Age = 17;
Person p2 = new Person { Name="Becky", Age=18 };
This is the object initializer. Inside curly brackets, the two members are initiated. List <string> planets = new List<string>();This is the classic way of initiating a collection. In the following example, we will use a collection initializer for the same generic list.
planets.Add("Mercury");
planets.Add("Venus");
planets.Add("Earth");
planets.Add("Mars");
planets.Add("Jupiter");
planets.Add("Saturn");
planets.Add("Uranus");
planets.Add("Neptune");
using System;We create a generic list of planets.
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
List <string> planets = new List <string>
{"Mercury", "Venus", "Earth", "Mars", "Jupiter",
"Saturn", "Uranus", "Neptune"};
foreach (string planet in planets)
{
Console.WriteLine(planet);
}
}
}
List <string> planets = new List <string>This is the collection initializer expression. The planet names are specified between the curly brackets. We save a some typing. We do not need to call the
{"Mercury", "Venus", "Earth", "Mars", "Jupiter",
"Saturn", "Uranus", "Neptune"};
Add() method for each item of the collection. $ ./collectioninitializers.exeOutput.
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune
using System;This code is much shorter. We have a person class in which we have two properties.
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
public class CSharpApp
{
static void Main()
{
Person p = new Person();
p.Name = "Jane";
p.Age = 17;
Console.WriteLine("{0} is {1} years old",
p.Name, p.Age);
}
}
public string Name { get; set; }
public int Age { get; set; }
Here we have two automatic properties. There is no implementation of the accessors. And there are no member fields. The compiler will do the rest for us. Person p = new Person();We normally use the properties as usual.
p.Name = "Jane";
p.Age = 17;
Console.WriteLine("{0} is {1} years old",
p.Name, p.Age);
$ ./automatic.exeOutput of the example.
Jane is 17 years old
using System;An anonymous type example.
public class CSharpApp
{
static void Main()
{
var p = new {Name="Jane", Age=17};
Console.WriteLine("{0} is {1} years old", p.Name, p.Age);
}
}
var p = new {Name="Jane", Age=17};
An anonymous object initializer declares an anonymous type and returns an instance of that type. We use the var keyword, because we do not know the type. Console.WriteLine("{0} is {1} years old", p.Name, p.Age);
We access the properties created using the field access notation. $ ./anonymoustype.exeOutput.
Jane is 17 years old
using System;In our case, we would like to add a new method for a String class. The String class is a built-in class and it is sealed. No inheritance is possible. This is why we need an extension method.
public static class Util
{
public static string Reverse(this string input)
{
char[] chars = input.ToCharArray();
Array.Reverse(chars);
return new String(chars);
}
}
public class CSharpApp
{
static void Main()
{
string str1 = "Jane";
string str2 = str1.Reverse();
Console.WriteLine(str2);
}
}
public static class UtilWe have a
{
public static string Reverse(this string input)
{
char[] chars = input.ToCharArray();
Array.Reverse(chars);
return new String(chars);
}
}
Reverse() extension method. This method reverses characters of a string variable. The method and its class must be static. The static Reverse() method becomes an extension method, when we put the this modifier as the first parameter of the method. string str1 = "Jane";We define and initialize a string variable. We call the
string str2 = str1.Reverse();
Reverse() method on this variable. Even though the method is static, we use the instance method call syntax. $ ./extentionmethods.exeOutput.
enaJ
MemoryStream is a stream which works with data in a computer memory. using System;We write six numbers to a memory with a
using System.IO;
public class CSharpApp
{
static void Main() {
try
{
Stream ms = new MemoryStream(6);
ms.WriteByte(9);
ms.WriteByte(11);
ms.WriteByte(6);
ms.WriteByte(8);
ms.WriteByte(3);
ms.WriteByte(7);
ms.Position = 0;
int rs;
rs = ms.ReadByte();
do
{
Console.WriteLine(rs);
rs = ms.ReadByte();
} while (rs != -1);
ms.Close();
} catch (IOException e)
{
Console.WriteLine(e.Message);
}
}
}
MemoryStream. Then we read those numbers and print them to the console. Stream ms = new MemoryStream(6);The line creates and initializes a
MemoryStream object with a capacity of six bytes. ms.Position = 0;We set the position of the cursor in the stream to the beginning using the
Position property. ms.WriteByte(9);The
ms.WriteByte(11);
ms.WriteByte(6);
...
WriteByte() method writes a byte to the current stream at the current position. doHere we read all bytes from the stream and print them to the console.
{
Console.WriteLine(rs);
rs = ms.ReadByte();
} while (rs != -1);
ms.Close();Finally, we close the stream.
$ ./memory.exeOutput of the example.
9
11
6
8
3
7
using System;We have a file called languages. We read characters from that file and print them to the console.
using System.IO;
public class CSharpApp
{
static void Main() {
try
{
StreamReader stream = new StreamReader("languages");
Console.WriteLine(stream.ReadToEnd());
stream.Close();
} catch (IOException e)
{
Console.WriteLine("Cannot read file.");
Console.WriteLine(e.Message);
}
}
}
StreamReader stream = new StreamReader("languages");
The StreamReader takes a file name as a parameter. Console.WriteLine(stream.ReadToEnd());The
ReadToEnd() method reads all characters to the end of the stream. $ cat languagesWe have a languages file in the current directory. We print all lines of the file to the console.
Python
Visual Basic
PERL
Java
C
C#
$ ./readfile.exe
Python
Visual Basic
PERL
Java
C
C#
using System;Counting lines in a file.
using System.IO;
public class CSharpApp
{
static void Main() {
int count = 0;
try
{
StreamReader stream = new StreamReader("languages");
while(stream.ReadLine() != null)
{
count++;
}
Console.WriteLine("There are {0} lines", count);
stream.Close();
} catch (IOException e)
{
Console.WriteLine("Cannot read file.");
Console.WriteLine(e.Message);
}
}
}
while(stream.ReadLine() != null)In the while loop, we read a line from the stream with the
{
count++;
}
ReadLine() method. It returns a line from the stream or null if the end of the input stream is reached. StreamWriter follows. It is a class used for character output. using System;In the preceding example, we write characters to the memory.
using System.IO;
public class CSharpApp
{
static void Main() {
try
{
MemoryStream ms = new MemoryStream();
StreamWriter swriter = new StreamWriter(ms);
swriter.Write("ZetCode, tutorials for programmers.");
swriter.Flush();
ms.Position = 0;
StreamReader sreader = new StreamReader(ms);
Console.WriteLine(sreader.ReadToEnd());
swriter.Close();
sreader.Close();
} catch (IOException e)
{
Console.WriteLine(e.Message);
}
}
}
MemoryStream ms = new MemoryStream();A
MemoryStream is created. It is a stream whose backing store is memory. StreamWriter swriter = new StreamWriter(ms);A
StreamWriter class takes a memory stream as a parameter. This way, we are going to write characters to memory stream. swriter.Write("ZetCode, tutorials for programmers.");
swriter.Flush();
We write some text to the writer. The Flush()clears all buffers for the current writer and causes any buffered data to be written to the underlying stream. ms.Position = 0;We set the current position within the stream to the beginning.
StreamReader sreader = new StreamReader(ms);Now we create an instance of the stream reader and read everything we have previously written.
Console.WriteLine(sreader.ReadToEnd());
FileStream class uses a stream on a file on the filesystem. This class can be used to read from files, write to files, open them and close them. using System;We write some text in Russian azbuka to the file called author in the current working directory.
using System.IO;
using System.Text;
public class CSharpApp
{
static void Main() {
try
{
FileStream fstream = new FileStream("author", FileMode.Append);
byte[] bytes = new UTF8Encoding().GetBytes("Фёдор Михайлович Достоевский");
fstream.Write(bytes, 0, bytes.Length);
fstream.Close();
} catch (IOException e)
{
Console.WriteLine(e.Message);
}
}
}
using System.Text;We need the
System.Text namespace for the UTF8Encodingclass. FileStream fstream = new FileStream("author", FileMode.Append);
A FileStream object is created. The second parameter is a mode, in which the file is opened. The append mode opens the file if it exists and seeks to the end of the file, or creates a new file. byte[] bytes = new UTF8Encoding().GetBytes("Фёдор Михайлович Достоевский");
We create an array of bytes from text in russian azbuka. fstream.Write(bytes, 0, bytes.Length);We write the bytes to the file stream.
$ cat authorWe show the contents of the author file.
Фёдор Михайлович Достоевский
XmlTextReader is the class to read xml files in C#. The class is forward-only and read-only. <?xml version="1.0" encoding="utf-8" ?>
<languages>
<language>Python</language>
<language>Ruby</language>
<language>Javascript</language>
<language>C#</language>
</languages>
using System;This C# program reads data from the previously specified xml file and prints it to the terminal.
using System.IO;
using System.Xml;
public class CSharpApp
{
static void Main() {
string file = "languages.xml";
try
{
XmlTextReader xreader = new XmlTextReader(file);
xreader.MoveToContent();
while (xreader.Read())
{
switch (xreader.NodeType)
{
case XmlNodeType.Element:
Console.Write(xreader.Name + ": ");
break;
case XmlNodeType.Text:
Console.WriteLine(xreader.Value);
break;
}
}
xreader.Close();
} catch (IOException e)
{
Console.WriteLine("Cannot read file.");
Console.WriteLine(e.Message);
} catch (XmlException e)
{
Console.WriteLine("XML parse error");
Console.WriteLine(e.Message);
}
}
}
using System.Xml;We import the
System.Xml namespace, which contains classes related to Xml reading and writing. XmlTextReader xreader = new XmlTextReader(file);An
XmlTextReader object is created. It is a reader that provides fast, non-cached, forward-only access to XML data. It takes the file name as a parameter. xreader.MoveToContent();The
MoveToContent() method moves to the actual content of the xml file. while (xreader.Read())This line reads the next node from the stream. The
Read() method returns false, if there are no more nodes left. case XmlNodeType.Element:Here we print the element name and element text.
Console.Write(xreader.Name + ": ");
break;
case XmlNodeType.Text:
Console.WriteLine(xreader.Value);
break;
} catch (XmlException e)We check for xml parse error.
{
Console.WriteLine("XML parse error");
Console.WriteLine(e.Message);
}
$ ./readxml.exeOutput of example.
language: Python
language: Ruby
language: Javascript
language: C#
File class is a higher level class that has static methods for file creation, deletion, copying, moving and opening. These methods make the job easier. using System;In the example, we create a cars file and write some car names into it.
using System.IO;
public class CSharpApp
{
static void Main() {
try
{
StreamWriter sw = File.CreateText("cars");
sw.WriteLine("Hummer");
sw.WriteLine("Skoda");
sw.WriteLine("BMW");
sw.WriteLine("Volkswagen");
sw.WriteLine("Volvo");
sw.Close();
} catch (IOException e)
{
Console.WriteLine("IO error");
Console.WriteLine(e.Message);
}
}
}
StreamWriter sw = File.CreateText("cars");
The CreateText() method creates or opens a file for writing UTF-8 encoded text. It returns a StreamWriter object. sw.WriteLine("Hummer");
sw.WriteLine("Skoda");
...
We write two lines to the stream. $ cat carsWe have successfully written five car names to a cars file.
Hummer
Skoda
BMW
Volkswagen
Volvo
using System;In the second example, we show other five static methods of the File class.
using System.IO;
public class CSharpApp
{
static void Main() {
try
{
if (File.Exists("cars"))
{
Console.WriteLine(File.GetCreationTime("cars"));
Console.WriteLine(File.GetLastWriteTime("cars"));
Console.WriteLine(File.GetLastAccessTime("cars"));
}
File.Copy("cars", "newcars");
} catch (IOException e)
{
Console.WriteLine("IO error");
Console.WriteLine(e.Message);
}
}
}
if (File.Exists("cars"))
The Exists() method determines whether the specified file exists. Console.WriteLine(File.GetCreationTime("cars"));
Console.WriteLine(File.GetLastWriteTime("cars"));
Console.WriteLine(File.GetLastAccessTime("cars"));
We get creation time, last write time and last access time of the specified file. File.Copy("cars", "newcars");
The Copy() method copies the file. $ ./copyfile.exeOutput of the example on my system.
10/16/2010 11:48:54 PM
10/16/2010 11:48:54 PM
10/16/2010 11:48:57 PM
System.IO.Directory is a class, which has static methods for creating, moving, and enumerating through directories and subdirectories. using System;We will use two methods from the above mentioned object. We create two directories and rename one of the created ones.
using System.IO;
public class CSharpApp
{
static void Main() {
try
{
Directory.CreateDirectory("temp");
Directory.CreateDirectory("newdir");
Directory.Move("temp", "temporary");
} catch (IOException e)
{
Console.WriteLine("Cannot create directories");
Console.WriteLine(e.Message);
}
}
}
Directory.CreateDirectory("temp");
The CreateDirectory() method creates a new directory. Directory.Move("temp", "temporary");
The Move() method gives a specified directory a new name. DirectoryInfo and Directory have methods for creating, moving, and enumerating through directories and subdirectories. using System;We use the
using System.IO;
public class CSharpApp
{
static void Main() {
try
{
DirectoryInfo dir = new DirectoryInfo("../io");
string[] files = Directory.GetFiles("../io");
DirectoryInfo[] dirs = dir.GetDirectories();
foreach(DirectoryInfo subDir in dirs)
{
Console.WriteLine(subDir.Name);
}
foreach(string fileName in files)
{
Console.WriteLine(fileName);
}
} catch (IOException e)
{
Console.WriteLine(e.Message);
}
}
}
DirectoryInfo class to traverse a specific directory and print its contents. DirectoryInfo dir = new DirectoryInfo("../io");
We will show the contents of this directory (io). string[] files = Directory.GetFiles("../io");
We get all files of the io directory using the static GetFiles() method. DirectoryInfo[] dirs = dir.GetDirectories();We get all directories.
foreach(DirectoryInfo subDir in dirs)Here we loop through directories and print their names to the console.
{
Console.WriteLine(subDir.Name);
}
foreach(string fileName in files)Here we loop through the array of files and print their names to the console.
{
Console.WriteLine(fileName);
}
$ ./showcontents.exeOutput of the example.
newdir
temporary
../io/author
../io/cars
../io/cars.cs
../io/cars.cs~
../io/cars.exe
...
using System;In the above example, we have created an
using System.Collections;
public class CSharpApp
{
class Empty
{}
static void Main()
{
ArrayList da = new ArrayList();
da.Add("Visual Basic");
da.Add(344);
da.Add(55);
da.Add(new Empty());
da.Remove(55);
foreach(object el in da)
{
Console.WriteLine(el);
}
}
}
ArrayList collection. We have added some elements to it. They are of various data type, string, int and a class object. using System.Collections;In order to work with
ArrayList collection, we need to import System.Collections namespace. ArrayList da = new ArrayList();An
ArrayList collection is created. da.Add("Visual Basic");
da.Add(344);
da.Add(55);
da.Add(new Empty());
da.Remove(55);
We add five elements to the array with the Add() method. da.Remove(55);We remove one element.
foreach(object el in da)We iterate through the array and print its elements to the console.
{
Console.WriteLine(el);
}
$ ./arraylist.exeOutput.
Visual Basic
344
CSharpApp+Empty
List is a strongly typed list of objects that can be accessed by index. It can be found under System.Collections.Generic namespace. using System;In the preceding example, we work with the
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
List<string> langs = new List<string>();
langs.Add("Java");
langs.Add("C#");
langs.Add("C");
langs.Add("C++");
langs.Add("Ruby");
langs.Add("Javascript");
Console.WriteLine(langs.Contains("C#"));
Console.WriteLine(langs[1]);
Console.WriteLine(langs[2]);
langs.Remove("C#");
langs.Remove("C");
Console.WriteLine(langs.Contains("C#"));
langs.Insert(4, "Haskell");
langs.Sort();
foreach(string lang in langs)
{
Console.WriteLine(lang);
}
}
}
List collection. using System.Collections.Generic;In order to work with the
List collection, we need to import the System.Collections.Genericnamespace. List<string> langs = new List<string>();A generic dynamic array is created. We specify that we will work with strings with the type specified inside <> characters.
langs.Add("Java");
langs.Add("C#");
langs.Add("C");
...
We add elements to the List using the Add() method. Console.WriteLine(langs.Contains("C#"));
We check if the List contains a specific string using the Contains() method. Console.WriteLine(langs[1]);We access the second and the third element of the List using the index notation.
Console.WriteLine(langs[2]);
langs.Remove("C#");
langs.Remove("C");
We remove two strings from the List. langs.Insert(4, "Haskell");We insert a string at a specific location.
langs.Sort();We sort the elements using the
Sort()method. $ ./list.exeOutcome of the example.
True
C#
C
False
C++
Haskell
Java
Javascript
Ruby
LinkedList is a generic doubly linked list in C#. LinkedList only allows sequential access. LinkedList allows for constant-time insertions or removals, but only sequential access of elements. Because linked lists need extra storage for references, they are impractical for lists of small data items such as characters. Unlike dynamic arrays, arbitrary number of items can be added to the linked list (limited by the memory of course) without the need to realocate, which is an expensive operation. using System;This is a
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
LinkedList<int> nums = new LinkedList<int>();
nums.AddLast(23);
nums.AddLast(34);
nums.AddLast(33);
nums.AddLast(11);
nums.AddLast(6);
nums.AddFirst(9);
nums.AddFirst(7);
LinkedListNode<int> node = nums.Find(6);
nums.AddBefore(node, 5);
foreach(int num in nums)
{
Console.WriteLine(num);
}
}
}
LinkedList example with some of its methods. LinkedList<int> nums = new LinkedList<int>();This is an integer
LinkedList. nums.AddLast(23);We populate the linked list using the
...
nums.AddFirst(7);
AddLast()and AddFirst() methods. LinkedListNode<int> node = nums.Find(6);A
nums.AddBefore(node, 5);
LinkedList consists of nodes. We find a specific node and add an element before it. foreach(int num in nums)Printing all elements to the console.
{
Console.WriteLine(num);
}
using System;We have a dictionary, where we map domain names to their country names.
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
Dictionary<string, string> domains = new Dictionary<string, string>();
domains.Add("de", "Germany");
domains.Add("sk", "Slovakia");
domains.Add("us", "United States");
domains.Add("ru", "Russia");
domains.Add("hu", "Hungary");
domains.Add("pl", "Poland");
Console.WriteLine(domains["sk"]);
Console.WriteLine(domains["de"]);
Console.WriteLine("Dictionary has {0} items",
domains.Count);
Console.WriteLine("Keys of the dictionary:");
List<string> keys = new List<string>(domains.Keys);
foreach(string key in keys)
{
Console.WriteLine("{0}", key);
}
Console.WriteLine("Values of the dictionary:");
List<string> vals = new List<string>(domains.Values);
foreach(string val in vals)
{
Console.WriteLine("{0}", val);
}
Console.WriteLine("Keys and values of the dictionary:");
foreach(KeyValuePair<string, string> kvp in domains)
{
Console.WriteLine("Key = {0}, Value = {1}",
kvp.Key, kvp.Value);
}
}
}
Dictionary<string, string> domains = new Dictionary<string, string>();We create a dictionary with string keys and values.
domains.Add("de", "Germany");
domains.Add("sk", "Slovakia");
domains.Add("us", "United States");
...
We add some data to the dictionary. The first string is the key. The second is the value. Console.WriteLine(domains["sk"]);Here we retrieve two values by their keys.
Console.WriteLine(domains["de"]);
Console.WriteLine("Dictionary has {0} items",
domains.Count);
We print the number of items by referring to the Count property. List<string> keys = new List<string>(domains.Keys);These lines retrieve all keys from the dictionary.
foreach(string key in keys)
{
Console.WriteLine("{0}", key);
}
List<string> vals = new List<string>(domains.Values);These lines retrieve all values from the dictionary.
foreach(string val in vals)
{
Console.WriteLine("{0}", val);
}
foreach(KeyValuePair<string, string> kvp in domains)Finally, we print both keys and values of the dictionary.
{
Console.WriteLine("Key = {0}, Value = {1}",
kvp.Key, kvp.Value);
}
$ ./dictionary.exeThis is the output of the example.
Slovakia
Germany
Dictionary has 6 items
Keys of the dictionary:
de
sk
us
ru
hu
pl
Values of the dictionary:
Germany
Slovakia
United States
Russia
Hungary
Poland
Keys and values of the dictionary:
Key = de, Value = Germany
Key = sk, Value = Slovakia
Key = us, Value = United States
Key = ru, Value = Russia
Key = hu, Value = Hungary
Key = pl, Value = Poland
queue is a First-In-First-Out (FIFO) data structure. The first element added to the queue will be the first one to be removed. Queues may be used to process messages as they appear or serve customers as they come. The first customer which comes should be served first. using System;In our example, we have a queue with messages.
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
Queue<string> msgs = new Queue<string>();
msgs.Enqueue("Message 1");
msgs.Enqueue("Message 2");
msgs.Enqueue("Message 3");
msgs.Enqueue("Message 4");
msgs.Enqueue("Message 5");
Console.WriteLine(msgs.Dequeue());
Console.WriteLine(msgs.Peek());
Console.WriteLine(msgs.Peek());
Console.WriteLine();
foreach(string msg in msgs)
{
Console.WriteLine(msg);
}
}
}
Queue<string> msgs = new Queue<string>();A queue of strings is created.
msgs.Enqueue("Message 1");
msgs.Enqueue("Message 2");
...
The Enqueue() adds a message to the end of the queue. Console.WriteLine(msgs.Dequeue());The
Dequeue() method removes and returns the item at the beginning of the queue. Console.WriteLine(msgs.Peek());The
Peek() method returns the next item from the queue, but does not remove it from the collection. $ ./queue.exeThe
Message 1
Message 2
Message 2
Message 2
Message 3
Message 4
Message 5
Dequeue() method removes the "Message 1" from the collection. The Peek() method does not. The "Message 2" remains in the collection. using System;We have a simple stack example above.
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
Stack<int> stc = new Stack<int>();
stc.Push(1);
stc.Push(4);
stc.Push(3);
stc.Push(6);
stc.Push(4);
Console.WriteLine(stc.Pop());
Console.WriteLine(stc.Peek());
Console.WriteLine(stc.Peek());
Console.WriteLine();
foreach(int item in stc)
{
Console.WriteLine(item);
}
}
}
Stack<int> stc = new Stack<int>();A
Stack data structure is created. stc.Push(1);The
stc.Push(4);
...
Push() method adds an item at the top of the stack. Console.WriteLine(stc.Pop());The
Pop() method removes and returns the item from the top of the stack. Console.WriteLine(stc.Peek());The
Peek() method returns the item from the top of the stack. It does not remove it. $ ./stack.exeOutput.
4
6
6
6
3
4
1
public class CSharpAppThe built-in libraries are organized within namespaces. Take the Console class. It is available within the System namespace. To call the static WriteLine() method of the Console class, we use its fully qualified name. Fully qualified names are object references that are prefixed with the name of the namespace where the object is defined.
{
static void Main()
{
System.Console.WriteLine("Simple namespace example");
}
}
using System;We have a ZetCode namespace. In the namespace, we have a class Example.
// namespace2.cs
namespace ZetCode
{
public class Example
{
public int x = 0;
public void Raise()
{
x += 100;
Console.WriteLine(x);
}
}
}
namespace ZetCodeWe declare a namespace called ZetCode. The code goes inside the curly brackets of the ZetCode namespace.
{
...
}
// namespace1.csIn the second file, we work with the Example class from the previous file. We invoke its Raise() method
namespace ZetCode
{
public class CSharpApp
{
static void Main()
{
Example ex = new Example();
ex.Raise();
ex.Raise();
}
}
}
namespace ZetCodeWe work in the same namespace.
Example ex = new Example();We create the instance of the Example class. We call its Raise() method twice. Because we work with objects of the same namespace, we do not need to specify its name.
ex.Raise();
ex.Raise();
$ gmcs namespace1.cs namespace2.csOutput.
$ ./namespace1.exe
100
200
using keyword to import elements from a different namespace. // distinctnamespace2.csWe have a skeleton of a Math class in a MyMath namespace. In the Basic class, we define a PI constant and a GetPi() method.
namespace MyMath
{
public class Basic
{
public static double PI = 3.141592653589;
public static double GetPi()
{
return PI;
}
}
}
// distinctnamespace1.csIn this file, we use the elements from the MyMath namespace.
using MyMath;
using System;
namespace ZetCode
{
public class CSharpApp
{
static void Main()
{
Console.WriteLine(Basic.PI);
Console.WriteLine(Basic.GetPi());
}
}
}
using MyMath;We import the elements from the MyMath namespace into our namespace.
Console.WriteLine(Basic.PI)Now we can use those elements. In our case it is the Basic class.
Console.WriteLine(Basic.GetPI())
$ gmcs distinctnamespace1.cs distinctnamespace2.csWe compile the two files and run the program.
$ ./distinctnamespace1.exe
3.141592653589
3.141592653589
using System;We declare a delegate, create an instance of the delegate and invoke it.
delegate void Mdelegate();
public class CSharpApp
{
static void Main()
{
Mdelegate del = new Mdelegate(Callback);
del();
}
static void Callback()
{
Console.WriteLine("Calling callback");
}
}
delegate void Mdelegate();This is our delegate declaration. It returns no value and takes no parameters.
Mdelegate del = new Mdelegate(Callback);We create an instance of the delegate. When called, the delegate will invoke the static Callback() method.
del();We call the delegate.
$ ./simple.exeOutput.
Calling callback
using System;We can save some typing when creating an instance of a delegate. It was introduces in C# 2.0.
delegate void Mdelegate();
public class CSharpApp
{
static void Main()
{
Mdelegate del = Callback;
del();
}
static void Callback()
{
Console.WriteLine("Calling callback");
}
}
Mdelegate del = Callback;This is another way of creating a delegate. We save some typing.
using System;We can omit a method declaration when using an anonymous method with a delegate. The method has no name and can be invoked only via the delegate.
delegate void Mdelegate();
public class CSharpApp
{
static void Main()
{
Mdelegate del = delegate {
Console.WriteLine("Anonymous method");
};
del();
}
}
Mdelegate del = delegate {
Console.WriteLine("Anonymous method");
};
Here we create a delegate, that points to an anonymous method. The anonymous method has a body enclosed by { } characters, but it has no name. using System;In the example we have one delegate. This delegate is used to point to two methods of the Person class. The methods are called with the delegate.
public delegate void NameDelegate(string msg);
public class Person
{
public string firstName;
public string secondName;
public Person(string firstName, string secondName)
{
this.firstName = firstName;
this.secondName = secondName;
}
public void ShowFirstName(string msg)
{
Console.WriteLine(msg + this.firstName);
}
public void ShowSecondName(string msg)
{
Console.WriteLine(msg + this.secondName);
}
}
public class CSharpApp
{
public static void Main()
{
Person per = new Person("Fabius", "Maximus");
NameDelegate nDelegate = new NameDelegate(per.ShowFirstName);
nDelegate("Call 1: ");
nDelegate = new NameDelegate(per.ShowSecondName);
nDelegate("Call 2: ");
}
}
public delegate void NameDelegate(string msg);The delegate is created with a
delegate keyword. The delegate signature must match the signature of the method being called with the delegate. NameDelegate nDelegate = new NameDelegate(per.ShowFirstName);We create an instance of a new delegate, that points to the
nDelegate("Call 1: ");
ShowFirstName() method. Later we call the method via the delegate. $ ./simpledelegate.exeBoth names are printed via the delegate.
Call 1: Fabius
Call 2: Maximus
using System;This is an example of a multicast delegate.
delegate void Mdelegate(int x, int y);
public class Oper
{
public static void Add(int x, int y)
{
Console.WriteLine("{0} + {1} = {2}", x, y, x + y);
}
public static void Sub(int x, int y)
{
Console.WriteLine("{0} - {1} = {2}", x, y, x - y);
}
}
public class CSharpApp
{
static void Main()
{
Mdelegate del = new Mdelegate(Oper.Add);
del += new Mdelegate(Oper.Sub);
del(6, 4);
del -= new Mdelegate(Oper.Sub);
del(2, 8);
}
}
delegate void Mdelegate(int x, int y);Our delegate will take two parameters. We have an Oper class, which has two static methods. One adds two values the other one subtracts two values.
Mdelegate del = new Mdelegate(Oper.Add);We create an instance of our delegate. The delegate points to the static Add() method of the Oper class.
del += new Mdelegate(Oper.Sub);We plug another method to the existing delegate instance. The first call of the delegate invokes two methods.
del(6, 4);
del -= new Mdelegate(Oper.Sub);We remove one method from the delegate. The second call of the delegate invokes only one method.
del(2, 8);
$ ./multicast.exeOutput.
6 + 4 = 10
6 - 4 = 2
2 + 8 = 10
using System;We have a DoOperation() method, which takes a delegate as a parameter.
delegate int Arithm(int x, int y);
public class CSharpApp
{
static void Main()
{
DoOperation(10, 2, Multiply);
DoOperation(10, 2, Divide);
}
static void DoOperation(int x, int y, Arithm del)
{
int z = del(x, y);
Console.WriteLine(z);
}
static int Multiply(int x, int y)
{
return x * y;
}
static int Divide(int x, int y)
{
return x / y;
}
}
delegate int Arithm(int x, int y);This is a delegate declaration.
static void DoOperation(int x, int y, Arithm del)This is DoOperation() method implementation. The third parameter is a delegate. The DoOperation() method calls a method, which is passed to it as a third parameter.
{
int z = del(x, y);
Console.WriteLine(z);
}
DoOperation(10, 2, Multiply);We call the DoOperation() method. We pass two values and a method to it. What we do with the two values, depends on the method that we pass. This is the flexibility that come with using delegates.
DoOperation(10, 2, Divide);
using System;We have a simple example in which we create and launch an event. An random number is generated. If the number equals to 5 a FiveEvent event is generated.
public delegate void OnFiveHandler(object sender, EventArgs e);
class FEvent {
public event OnFiveHandler FiveEvent;
public void OnFiveEvent()
{
if(FiveEvent != null)
FiveEvent(this, EventArgs.Empty);
}
}
public class CSharpApp
{
static void Main()
{
FEvent fe = new FEvent();
fe.FiveEvent += new OnFiveHandler(Callback);
Random random = new Random();
for (int i = 0; i<10; i++)
{
int rn = random.Next(6);
Console.WriteLine(rn);
if (rn == 5)
{
fe.OnFiveEvent();
}
}
}
public static void Callback(object sender, EventArgs e)
{
Console.WriteLine("Five Event occured");
}
}
public event OnFiveHandler FiveEvent;An event is declared with a
event keyword. fe.FiveEvent += new OnFiveHandler(Callback);Here we plug the event called FiveEvent to the Callback method. In other words, if the ValueFive event is triggered, the Callback() method is executed.
public void OnFiveEvent()When the random number equals to 5, we invoke the OnFiveEvent() method. In this method, we raise the FiveEvent event. This event carries no arguments.
{
if(FiveEvent != null)
FiveEvent(this, EventArgs.Empty);
}
$ ./simpleevent.exeOutcome of the program might look like this.
3
0
5
Five Event occured
0
5
Five Event occured
2
3
4
4
0
using System;We have four classes. FiveEventArgs carries some data with the event object. The FEvent class encapsulates the event object. RandomEventGenerator class is responsible for random number generation. It is the event sender. Finally the CSharpApp class, which is the main application object and has the Main() method.
public delegate void OnFiveHandler(object sender, FiveEventArgs e);
public class FiveEventArgs : EventArgs
{
public int count;
public DateTime time;
public FiveEventArgs(int count, DateTime time)
{
this.count = count;
this.time = time;
}
}
public class FEvent
{
public event OnFiveHandler FiveEvent;
public void OnFiveEvent(FiveEventArgs e)
{
FiveEvent(this, e);
}
}
public class RandomEventGenerator
{
public void Generate()
{
int count = 0;
FiveEventArgs args;
FEvent fe = new FEvent();
fe.FiveEvent += new OnFiveHandler(Callback);
Random random = new Random();
for (int i = 0; i<10; i++)
{
int rn = random.Next(6);
Console.WriteLine(rn);
if (rn == 5)
{
count++;
args = new FiveEventArgs(count, DateTime.Now);
fe.OnFiveEvent(args);
}
}
}
public void Callback(object sender, FiveEventArgs e)
{
Console.WriteLine("Five event {0} occured at {1}",
e.count, e.time);
}
}
public class CSharpApp
{
static void Main()
{
RandomEventGenerator reg = new RandomEventGenerator();
reg.Generate();
}
}
public class FiveEventArgs : EventArgsThe FiveEventArgs carries data inside the event object. It inherits from the
{
public int count;
public DateTime time;
...
EventArgs base class. The count and time members are data that will be initialized and carried with the event. if (rn == 5)If the generated random number equals to 5, we instantiate the FiveEventArgs class with the current count and DateTime values. The count variable counts the number of times this event was generated. The DateTime value holds the time, when the event was generated.
{
count++;
args = new FiveEventArgs(count, DateTime.Now);
fe.OnFiveEvent(args);
}
$ ./complexevent.exeThis is the ouput I got on my computer.
2
2
3
5
Five event 1 occured at 11/7/2010 12:13:59 AM
5
Five event 2 occured at 11/7/2010 12:13:59 AM
1
1
0
5
Five event 3 occured at 11/7/2010 12:13:59 AM
5
Five event 4 occured at 11/7/2010 12:13:59 AM
using System;Using predefined delegates further simplifies programming. We do not need to declare a delegate type.
public class CSharpApp
{
static void Main()
{
Action act = ShowMessage;
act();
}
static void ShowMessage()
{
Console.WriteLine("C# language");
}
}
Action act = ShowMessage;We instantiate an action delegate. The delegate points to the ShowMessage() method. When the delegate is invoked, the ShowMessage() method is executed.
act();
using System;We modify the previous example to use the action delegate, that takes one parameter.
public class CSharpApp
{
static void Main()
{
Action<string> act = ShowMessage;
act("C# language");
}
static void ShowMessage(string message)
{
Console.WriteLine(message);
}
}
Action<string> act = ShowMessage;We create an instance of the Action<T> delegate and call it with one parameter.
act("C# language");
using System;We have a list of integer values. We want to filter all numbers, that are bigger than three. For this, we use the predicate delegate.
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
List<int> list = new List<int> { 4, 2, 3, 0, 6, 7, 1, 9 };
Predicate<int> predicate = greaterThanThree;
List<int> list2 = list.FindAll(predicate);
foreach ( int i in list2)
{
Console.WriteLine(i);
}
}
static bool greaterThanThree(int x)
{
return x > 3;
}
}
List<int> list = new List<int> { 4, 2, 3, 0, 6, 7, 1, 9 };
This is a generic list of integer values. Predicate<int> predicate = greaterThanThree;We create an instance of a predicate delegate. The delegate points to a predicate, a special method that returns true or false.
List<int> list2 = list.FindAll(predicate);The FindAll() method retrieves all the elements that match the conditions defined by the specified predicate.
static bool greaterThanThree(int x)The predicate returns true for all values, that are greater than three.
{
return x > 3;
}
