Bike Pics

BMW Bike

Working with Delegates in C#

REF:http://www.devsource.com/article2/0,1759,,00.asp
With delegates, you can reference methods and build algorithms that work, regardless of what those methods are.
If you're familiar with C++, you might recognize this as being the same as function pointers. However, the difference with C# is that delegates are object-oriented and type safe.

Delegate Signatures

A delegate type is specified by a distinct signature, which includes a unique identifier, parameter list, and return type. The following code shows how to declare a delegate:

public delegate double UnitConversion(double from);

1. Just like any other namespace element, delegates are declared as either public or internal, with a default of internal accessibility if the modifier is not specified.
   
2. Delegates may also be declared as nested types, with accessibility modifiers allowable for their containing class or struct.
3. Delegates do not have implementation. Instead, they are a skeleton defining the proper signature of delegate handler methods to which they may refer. The handler methods contain implementation that is executed when its referring delegate is invoked.

Dynamic Delegate Invocation
Sometimes you don't know what method you want to execute until runtime. One option is to use a delegate, which allows you to separate implementation of method logic from the controlling application logic.

using System;

// 1. Define delegate.
public delegate double UnitConversion(double from);

class DynamicDelegates
{
//
// 2. Define handler methods.
//
public double FeetToInches(double feet)
{
return feet * 12;
}

public double YardsToInches(double yards)
{
return yards * 36;
}

// Factory method for returning delegate
public UnitConversion GetConversionMethod(string conversionType)
{
UnitConversion conversion;

switch (conversionType)
{
case "1":
conversion = new UnitConversion(FeetToInches);
break;
case "2":
conversion = new UnitConversion(YardsToInches);
break;
default:
throw new ArgumentException("Unrecognized conversion type: " + conversionType, conversionType);
}

return conversion;
}

// show menu and return units to convert and type of conversion
public void GetUserInput(out double units, out string conversionType)
{
Console.WriteLine("Units Converter");
Console.WriteLine("------------------------\n");

Console.WriteLine("1 - Feet to Inches");
Console.WriteLine("2 - Yards to Inches");

Console.Write("\nPlease select conversion option (1 or 2): ");
conversionType = Console.ReadLine();

Console.Write("\n\nPlease enter units: ");

units = Double.Parse(Console.ReadLine());
}

static void Main()
{
DynamicDelegates dels = new DynamicDelegates();

double units;
string conversionType;

dels.GetUserInput(out units, out conversionType);

// 3. get delegate instance via factory method.
UnitConversion doConversion = dels.GetConversionMethod(conversionType);

// 4. Use delegate just like a method.
double inches = doConversion(units);

Console.WriteLine("\n{0} Units = {1} Inches.\n", units, inches);
Console.ReadLine();
}
}

Invoking Multiple Delegates
Among the things you can do with delegates is invoke several of them, all at the same time. Delegates have internal storage, called an invocation list, that holds multiple other delegates.

Most of the time, when invoking multiple delegates, the handler methods will be defined to return type void. This is because when they are invoked, only the last delegate in the list will return the value, which has few benefits, if any. If you need to capture results from each handler method, it's best to set up a collection or some other state object where the results could be recorded and retrieved after the delegate invocation completes.

using System;
using System.Collections.Generic;

// 1. Define delegate.
public delegate double UnitConversion(double from);

class MultipleDelegatesViaDelegates
{
//
// 2. Define handler methods.
//
public double FeetToInches(double feet)
{
Console.WriteLine("FeetToInches:{0}", feet * 12);
return feet * 12;
}

public double YardsToInches(double yards)
{
Console.WriteLine("YardsToInches:{0}", yards * 36);
return yards * 36;
}

// Factory method for returning delegate
public UnitConversion GetConversionMethod(string conversionType)
{
UnitConversion conversion;

switch (conversionType)
{
case "1":
conversion = new UnitConversion(FeetToInches);
break;
case "2":
conversion = new UnitConversion(YardsToInches);
break;
default:
throw new ArgumentException("Unrecognized conversion type: " + conversionType, conversionType);
}

return conversion;
}

// show menu and return units to convert and type of conversion
public void GetUserInput(out double units, out int[] conversionTypes)
{
Console.WriteLine("Units Converter");
Console.WriteLine("------------------------\n");

Console.WriteLine("1 - Feet to Inches");
Console.WriteLine("2 - Yards to Inches");

Console.Write("\nPlease select conversion option (1 or 2) and use blank as plitter: ");
string[] types = Console.ReadLine().Split(' ');
List<int> conversions = new List<int>();
foreach (string convertsiontype in types)
{
if (convertsiontype.Trim() != string.Empty )
conversions.Add( int.Parse(convertsiontype));
}
conversionTypes = conversions.ToArray();

Console.Write("\n\nPlease enter units: ");
units = Double.Parse(Console.ReadLine());

}


// displays a report by invoking all selected delegates
public void DoReport(double units, UnitConversion conversions)
{
Console.WriteLine("\nCONVERSION REPORT\n");

// 4. invoke all delegates synchronously and in order
conversions(units);

Console.WriteLine();
}

static void Main()
{
MultipleDelegatesViaDelegates dels = new MultipleDelegatesViaDelegates();

double units;
int[] conversionTypes;

dels.GetUserInput(out units, out conversionTypes);

UnitConversion conversions = null;

foreach (int conversionType in conversionTypes)
{
// 3. get delegate instances via factory method.
conversions += dels.GetConversionMethod(conversionType.ToString());
}

dels.DoReport(units, conversions);

Console.ReadLine();
}
}

Adding and Removing Delegates

1. You can also remove delegates with the -= operator.
2. Notice you can use the += syntax when adding delegates to the conversions delegate's invocation list.

3. You can add multiple delegates with the + operator. The following code shows another way to do this (assuming 3 conversion options were chosen by the user):

           conversions =
              dels.GetConversionMethod(conversionTypes[0]) +
              dels.GetConversionMethod(conversionTypes[1]) +
              dels.GetConversionMethod(conversionTypes[2]);

4. Additionally, you could use the original delegate instance to remove it from the invocation list. However, it would be wasteful to have extra delegates taking up space in your code just for this purpose. Notice, in the code above, that the new UnitConversion instantiation will remove a delegate from the conversions delegate list. If there happened to be two of the same delegate added to a delegate, then the last delegate of the type added would be the first to be removed.
5. When a delegate is invoked, all of its constituent delegates are invoked synchronously in the same order that they were added.
6. Another tip is to protect against the case where no constituent delegates have been added to a delegates invocation list. Before a delegate is instantiated or a delegate is assigned, its value is null. Invoking a null delegate causes a NullReferenceException exception to be thrown.
7. 
   

Delegates and Events
pending...

Summary

1. Delegates allow you to refer to methods to dynamically invoke code and call multiple methods together. When executed, each member of a delegate's invocation list is executed synchronously, in the order they were added. A delegate's invocation list can be manipulated by adding and removing delegates.
2. One of the primary uses of delegates in .NET is to implement callback methods for events. Events are safer than delegates for callbacks because they protect against accidental assignment and provide protection against direct invocation from outside code. Delegates allow you to refer to methods, invoke multiple methods simultaneously, and are the underlying mechanism for implementing C# events.

.NET Framework Class Library Reference

REF: http://msdn2.microsoft.com/en-us/library/d11h6832(vs.80).aspx

This page is specific toMicrosoft Visual Studio 2005/.NET Framework 2.0

.NET Framework Class Library

REF:http://msdn2.microsoft.com/en-us/library/d11h6832(vs.71).aspx

Programming the Thread Pool in the .NET Framework

REF:Programming the Thread Pool in the .NET Framework

Give Your .NET-based Application a Fast and Responsive UI with Multiple Threads

REF:http://msdn.microsoft.com/msdnmag/issues/03/02/Multithreading/default.aspx

Comparing the Timer Classes in the .NET Framework Class Library

REF:http://msdn.microsoft.com/msdnmag/issues/04/02/TimersinNET/default.aspx

The Meaning of Control.CheckForIllegalCrossThreadCalls

From MSDN:
Gets or sets a value indicating whether to catch calls on the wrong thread that access a control's Handle property.

Namespace: System.Windows.Forms
Assembly: System.Windows.Forms (in system.windows.forms.dll)

When a thread other than the creating thread of a control tries to access one of that control's methods or properties, it often leads to unpredictable results. A common invalid thread activity is a call on the wrong thread that accesses the control's Handle property. Set CheckForIllegalCrossThreadCalls to true to find and diagnose this thread activity more easily.

Here is some testing code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace TryControl.CheckForIllegalCrossThreadCalls
{
public partial class Form1 : Form
{
System.Timers.Timer timer = new System.Timers.Timer();
public Form1()
{
InitializeComponent();
timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
timer.Enabled = true;
//Control.CheckForIllegalCrossThreadCalls = true;
}

void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
this.richTextBoxTimer.Text = e.SignalTime.ToLongTimeString();
}

}
}

Because the richtextbox is not thread safety, when you run with debugger you will get an exception:
"Cross-thread operation not valid: Control 'richTextBoxTimer' accessed from a thread other than the thread it was created on."

However, if you run without debugger, the application will run ok.
See:

When I set the Control.CheckForIllegalCrossThreadCalls as "true" and run the it without debugger, the appliation will show as:

Conclusion:
1.When you run with debugger, the incorrect cross thread calling exception will be thrown. To set the Control.CheckForIllegalCrossThreadCalls as true the exception message will be more understandable.

2.When set Control.CheckForIllegalCrossThreadCalls as true and run without debugger, the incorrect calling will be skipped.

REF:http://blogs.msdn.com/jfoscoding/archive/2005/05/12/416910.aspx

The mechanism of property in C#

I will show you what's the mechanism of the property feature in C#.

Summary:
1.Write a demo class
2.Compile the demo as library
3.Explorer the library by ILDASM : See the detail implementation of property in IL


1.Write demo class
Here write a demo class: Student.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace PropertyTesting
{
public class Student
{
private string name = string.Empty;
public string Name
{
get { return name; }
set { name = value; }
}
}
}

Save the Student.cs.
2.Compile the demo as library
Open "Visual Studio 2005 Command Prompt" and compile the Student class as Student.dll with the following command:

csc /target:library Student.cs

3.Explorer the library by ILDASM : See the detail implementation of property in IL

Open the Student.dll by ILDASM.
You will see:
All detail:
There other two methods: ( get_Name,set_Name) has been added.

Property Name Detail:
The Name property is actually calling the two methods: get_Name and set_Name
set_Name detail:
There the value is used as a temporary variable with type as string.

get_Name detail:

Conclusion:
1.The property is actually two methods: get_PropertyName and set_PropertyName.
2.The keyword "value" used in set is a temporary variable with the same type as property.