C# Tutorial

1. Basics and Individual Topics

1.1. Generating Schema, Class and DataSet from XML Using xsd.exe

To generate a schema definition file (xsd) from XML file orders.xml:

xsd orders.xml

A file called orders.xsd will be generated.

To generate a class definition from the schema definition:

xsd orders.xsd /classes /language:cs

A file called orders.cs containing a class definition in c# will be generated.

To generate a class definition of a strongly typed DataSet from the schema definition:

xsd orders.xsd /dataset /language:cs

1.2. Asynchronous Programming with Delegates

Delegate is a .NET version of function pointer, which can be used for callback purpose. Moreover, compiler generates some methods and properties for the delegate, including methods BeginInvoke and EndInvoke, so that we can call the wrapped method asynchronously.

Now suppose there is the following time-consuming method that needs to be called asynchronously:

private int Calc(int input1, int input2, ref string strResult)

{

System.Threading.Thread.Sleep(new System.TimeSpan(0, 0, 0, 5, 0));

strResult = input1 + " + " + input2 + " = " + (input1 + input2);

return input1 + input2;

}

The application UI is as follows:

When we press the “Calculate” button, the two integers in the first two textboxes are used to call method Calc, the returned integer result is put in the third textbox, and a string representation is passed back through Calc’s ref parameter, and is put in the message textbox.

The bottom textbox and button has nothing to do with the delegate process and is only used to check that the UI is not locked before the method returns.

An asynchronous method invoking process would be:

1. Define a delegate type with the same signature as the method to call;

private delegate int CalcDelegate(int input1, int input2, ref string strResult);

2. Define a callback method which will be called when the dispatched thread finishes the time-consuming method call and returns. The content of the callback method will be discussed later.

private void CalcCallback(IAsyncResult ar)

{

...

}

3. To initiate an asynchronous call, create an instance of the delegate type to wrap the time-consuming method, and call the delegate’s BeginInvoke method with all parameters needed by the time-consuming method:

CalcDelegate mDeleg;

private void btnCalc_Click(object sender, System.EventArgs e)

{

mDeleg = new CalcDelegate(Calc);

AsyncCallback callback = new AsyncCallback(CalcCallback);

int input1 = Convert.ToInt16(tbInput1.Text);

int input2 = Convert.ToInt16(tbInput2.Text);

string strResult = null; // dummy parameter

deleg.BeginInvoke(input1, input2, ref strResult, callback, 123456789);

}

When BeginInvoke is called, a separate thread is dispatched to call the time-consuming method. The last parameter of BeginInvoke is of type object and can be any object that the caller method wants to pass to the callback method. It is simply passed to the thread and passed back to the callback method as the IAsyncResult.AsyncState property.

4. When the wrapped method returns, the thread will call the callback method with an IAsyncResult parameter. In the callback method, we are supposed to acquire a handle to the delegate contained in the IAsyncResult, and call its EndInvoke to get back the result.

private void CalcCallback(IAsyncResult ar)

{

// Following line is used when this callback method can not acquire a handle of the delegate, mDeleg, for

// example, when it is in another class. The AsyncDelegate property was generated by the compiler together

// with the BeginInvoke and EndInvoke methods.

// CalcDelegate mDeleg = (CalcDelegate)(ar.AsyncDelegate);

string strResult = null;

int iResult = mDeleg.EndInvoke(ref strResult, ar);

tbResult.Text = Convert.ToString(iResult); // the third textbox

tbMsg.Text = strResult; // the message textbox

int i = (int)ar.AsyncState;

MessageBox.Show("The ar.AsyncState is " + i); // will show 123456789

}

The IAsyncResult object that is passed to the callback method does not contain the result of the time-consuming method. Instead it contains the identity of the calling method and a handle to the delegate. This asynchronous process is like a dry cleaning store with a procedure a bit different from common ones. You call in first, leave a job to be done, and your address – the callback method. When the job is done, the store contacts you through the address you left, and provides a job number. You go back to the store with the job number to pick up the job done. The IAsyncResult object contains this job number. You have to call the time-consuming method again with this job number to get back the real result.

To do the invoke in one thread:

CalcDelegate deleg = new CalcDelegate(Calc);

//AsyncCallback callback = new AsyncCallback(CalcCallback);

int input1 = Convert.ToInt16(tbInput1.Text);

int input2 = Convert.ToInt16(tbInput2.Text);

string strResult = null; // dummy parameter

IAsyncResult ar = deleg.BeginInvoke(input1, input2, ref strResult, null, new object());

//deleg.BeginInvoke(input1, input2, ref strResult, callback, new object());

ar.AsyncWaitHandle.WaitOne();

strResult = null;

int iResult = deleg.EndInvoke(ref strResult, ar);

tbResult.Text = Convert.ToString(iResult);

tbMsg.Text = strResult;

Note the following difference:

1. No need to pass a callback to BeginInvoke;

2. UI will freeze while waiting;

3. The same delegate handle is used to call both BeginInvoke and EndInvoke.

1.1. Event

The event architecture offers a mechanism for an event generator to notify an event consumer that something happened. The event generator does not need to know anything about the consumer. Instead it publishes a method definition in the form of a delegate, plus an event handle. When the event happens, the generator will call the unknown event handling method of the consumer through the event handle. A third party which knows both the generator and the consumer is responsible to connect the consumer’s event handling method with the published event handle of the generator.

Example:

// The event and the event args are defined by the event generator.

public class MyEventArgs : EventArgs

{

private string mstrName;

public MyEventArgs(string strName)

{

mstrName = strName;

}

public string Name

{

get { return mstrName; }

set { mstrName = value; }

}

}

public delegate void MyEvent(object sender, MyEventArgs e);

public class EventGenerator

{

public event MyEvent MyEventExposed;

public void GenerateEvent()

{

if (MyEventExposed != null)

{

MyEventArgs args = new MyEventArgs("MyEvent");

MyEventExposed(this, args);

}

else

Console.WriteLine("Event not connected to event consumer!");

}

}

public class EventConsumer

{

public void HandleEvent(object sender, MyEventArgs e)

{

Console.WriteLine("Event name: \"" + e.Name + "\"");

}

}

public class EventConnector

{

public static void Main (string[] args)

{

EventConsumer consumer = new EventConsumer();

EventGenerator generator = new EventGenerator();

generator.MyEventExposed += new MyEvent(consumer.HandleEvent);

generator.GenerateEvent();

Console.ReadLine();

}

}

1.2. Convert Between Objects & byte Array with BinaryFormatter

In the following example, we create a object of a simple class Car, convert it into a byte array, and convert it back.

using System;

using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

namespace For_Testing_Simple_Code

{

[Serializable]

class Car

{

private string mstrMake;

private string mstrModel;

private int miYear;

private string mstrReg;

public Car(string strMake, string strModel, int iYear, string strReg)

{

mstrMake = strMake;

mstrModel = strModel;

miYear = iYear;

mstrReg = strReg;

}

override public string ToString()

{

return mstrMake + ", " + mstrModel + ", " + miYear + ", " + mstrReg;

}

}

class Class1

{

[STAThread]

static void Main(string[] args)

{

Car car1 = new Car("Toyota", "Camry", 2001, "ABC123");

MemoryStream memStream1 = new MemoryStream();

BinaryFormatter formatter = new BinaryFormatter();

formatter.Serialize(memStream1, car1);

byte [] bytes = memStream1.GetBuffer();

memStream1.Close();

MemoryStream memStream2 = new MemoryStream(bytes);

Car car2 = (Car)formatter.Deserialize(memStream2);

Console.WriteLine(car2.ToString());

Console.ReadLine();

}

}

}

The output is:

Toyota, Camry, 2001, ABC123

1.3. Encrypting and Decrypting with DES Crypto Service Provider

using System;

using System.IO;

using System.Security.Cryptography;

namespace For_Simple_Test

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

// Both desKey and desIV could be any 8-byte array.

byte [] desKey = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};

byte [] desIV = {0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78};

//**** Encryption Process ****

FileStream fsOriginal = new FileStream("Original.txt", FileMode.Open, FileAccess.Read);

FileStream fsEncrypted = new FileStream("Encrypted.txt", FileMode.OpenOrCreate, FileAccess.Write);

byte[] buffer = new byte[5000];

DESCryptoServiceProvider des = new DESCryptoServiceProvider();

CryptoStream encryptStream = new CryptoStream(

fsEncrypted,

des.CreateEncryptor(desKey, desIV),

CryptoStreamMode.Write);

//Read from the input file, then encrypt and write to the output file.

int iLenth = fsOriginal.Read(buffer, 0, 5000);

encryptStream.Write(buffer, 0, iLenth);

encryptStream.Close();

fsOriginal.Close();

fsEncrypted.Close();

//**** Decryption Process ****

fsEncrypted = new FileStream("Encrypted.txt", FileMode.Open, FileAccess.Read);

FileStream fsDecrypted = new FileStream("Decrypted.txt", FileMode.OpenOrCreate, FileAccess.Write);

CryptoStream decryptStream = new CryptoStream(

fsDecrypted,

des.CreateDecryptor(desKey, desIV),

CryptoStreamMode.Write);

iLenth = fsEncrypted.Read(buffer, 0, 5000);

decryptStream.Write(buffer, 0, iLenth);

decryptStream.Close();

fsEncrypted.Close();

fsDecrypted.Close();

}

}

}