Overview
.NET provides one nice characteristic that is delegate. Delegate is an object or instance which can hold reference of any function OR which can bind function. Referenced function may be static or any class object’s function. This can hold more than one function references. This also provides callback method. Developer’s perspective Delegate is two type single cast and multicast.
Every delegate base class is System.MulticastDelegate. System.MulticastDelegate class is inheriting from delegate class. Both classes are abstract class.
.NET provide standard constructor as follows:
Constructor for MultiCastDelegate : protected MulticastDelegate(object target, string method);
Constructor for Delegate : protected Delegate(object target, string method);
Declare Delegate
Declaring of the delegation is quite tricky, because when we declare delegation. We inform the compiler which kind of function signature’s reference could be hold by this delegate. Let’s explain by following: Fig-1.0
Look at FIG-1.0:
public is Access modifier .delegate is keyword which indicates this is delegate type.- Return type of function signature.
- Delegate class name. (Explain below).
- Parameter of function signature.
- Parameter of function signature
3,5,6 are optional. Because these are depending on function signature, which function type we want bind or wrap with delegate.
Lets one more example: protected delegate string DelegateReverse (string StrText) ;
It means this delegate class object can bind a function which function return type should be string with one string parameter. DelegateReverse is delegate class name.
Question: Look at Fig-1 DelegateFunction what is this? Is this is an object or name of the delegate.
Answer: This is sealed class. Look following example then we describe
Collapse
using System;
using System.Collections.Generic;
using System.Text;
namespace DelegateCode
{
class DelExample
{
public delegate string StringOperation(string myString);
static void Main(string[] args)
{
DelExample objEx = new DelExample();
StringOperation Objdelegate = new StringOperation(objEx.MyOperationReverseString);
string result = Objdelegate("ABC DEF GHI");
Type Tp = Objdelegate.GetType();
Console.WriteLine("Is this Class : " + Tp.IsClass.ToString()+ "\n");
Console.WriteLine("Inherit from : " + Tp.BaseType.ToString() + "\n");
Console.WriteLine("Is Abstract : " + Tp.IsAbstract.ToString() + "\n");
Console.WriteLine("Is ByRef : " + Tp.IsByRef.ToString() + "\n");
Console.WriteLine("Is Sealed : " + Tp.IsSealed.ToString() + "\n");
Console.WriteLine("Output of Delegate : " + result+"\n");
Console.WriteLine("Output by Invoke : " + Objdelegate.Invoke("ABC DEF GHI"));
Console.Read();
}
public string MyOperationReverseString(string test)
{
char[] Spl = test.ToCharArray();
test = string.Empty;
for (int icnt = 0; icnt < Spl.Length; icnt++)
{
test = Spl[icnt] + test;
}
return test;
}
}
} 
Output of this program Fig – 2.0
Consider Fig – 2.0 output. In the above code the following line
Collapse public delegate string StringOperation(string myString);
StringOperation is sealed Class. This inherited by System.MultiCastDelegate and not is abstract.
Look last two lines of output. We can call delegate by invoke method or by passing parameter without invoke method.
How C# Compiler Understands
Whenever compiler encountered delegate declaration like:
Collapse public delegate string StringOperation(string myString);
Then compiler generate following code:
Collapse public sealed class StringOperation: System.MulticastDelegate
{
public StringOperation (object target, int method);
public virtual void Invoke(string myString);
public virtual IAsyncResult BeginInvoke(string myString,
AsyncCallback callback, object obj);
public virtual void EndInvoke(IAsyncResult result);
}Look Program-1 IL-DASM view (Fig-3.0)
You can see .ctor: void (Object ,native int) ( This is similar constructor asSystem.MulticastDelege constructor.)
Invoke method should have same signature of the referenced function
History Delegate Cannot Declare and Use as Field
Collapse namespace DelegateExample
{
public delegate string MyDelegate(string myString);
interface MyCallable
{
int GetInfo();
delegate int CalcArea(int x, int y); MyDelegate ObjDelegae; }
}
public void DispachCall(int tStr)
{
public delegate string MyDelegate(string myString);
}History Difference b/w Single and Multicast Delegate
Developer’s perspective Delegate is two type single cast and multicast. Although ".NET" has provides two classes for the delegate.
Singlecast delegate vs Multicast delegate have not any declaration and implementation differences. This is only perspective.
Even I read more articles related delegate, they told Multicast delegate cannot wrap / bind a function which returns value. But I never seem like this.
- Delegate class ( Abstract class).
- MulticastDelegate (Abstract class inherited by Delegate class).
Every delegate in the .NET is Multicast delegate. Then…
Question : So what is Singlecast Delegate ?
Answer: If delegate object have only one function’s reference then its call single cast delegate. If delegate object references more than one functions this called MulticastDelegate
When delegate object refer or bind multiple functions references then all functions reference store as linked list. All functions will call in sequence as they assigned.
Example : let’s we have delegate object ObjDel.
ObjDel bind or wrap three functions in sequence respectively Add , Mul , Divide. All three functions return integer type.
Let’s calling delegate:
Int result = ObjDel.invoke(15,5); It will return 3.
If function wrap in sequence Add, Divide, Mul.
Result = ObjDel.invoke(15,5). It will return 75.
It always returns the value of last function. So what about the other function return values ?
Keypoint:
If any delegate object bind or wrap 5 return type functions. Then only 5th functions will return value but rest 4 functions could not return value. So always end of calling function return value. Rest 4 functions return value will ignored.
Delegate Asynchronously
Note : Simple overview for delegate as asynchronous call. More explain in next article
Recall Fig-3.0 there is IL-DASM view. StringOperation delegate have Invoke and BeginInvoke function. These two functions created by compiler at run time.
In C# we can achieve asynchronous function call using delegate.
By default every function in the C# is the synchronous. But we can call synchronous function as asynchronous.
The Invoke method calls the target method on the current thread. But BeginInvoke method is called with different thread, the common language runtime (CLR) queues the request and returns immediately to the caller.
BeginInvoke can call by only single cast delegate otherwise its get run time exception (ArgumentException) is “The delegate must have only one target”.
About BeginInvoke
.NET implements BeginInvoke function for each Delegate class. So whenever compiler encountered delegate declaration its implement three method for each delegate class.
Invoke, BeginInvoke and EndInvoke. Each BeginInvoke have corresponding EndInvoke.
Key Point
Always call EndInvoke to complete your asynchronous call does not matter technique of the calling.
BeginInvoke have three parameters. BeginInvoke return IAsyncresult
| S.No |
| Description |
| 1. | parameters of the function which calling |
|
| 2. | AsynchCallback | . delegate void AsyncCallback( IAsyncResult ar ); |
3. | System.Object |
|
Collapse AsyncCallback (IAsyncResult Ar).
Key Point
IAsyncresult is using for monitoring and state or progress of the asynchronous function call. This is return by BeginInvoke and it is also parameter for AsyncCallback function. Its declaration is.
Collapse public interface IAsyncResult
{
object AsyncState{ get; }
WaitHandle AsyncWaitHandle { get; }
bool CompletedSynchronously { get; }
bool IsCompleted { get; }
}Key Point
Call delegate using Invoke method. Then it’s run at same thread.
Look at following simple code. I called same delegate using Invoke and BeginInvoke method. And write thread ID for both call.
Code Sample – 4.0
Collapse using System;
using System.Threading;
namespace TestMultipuleDelegate
{
class MultiCastTest : TestMultipuleDelegate.IMultiCastTest
{
delegate int Calc(int x, int y,out int id);
static void Main(string[] args)
{
int thid = 0;
MultiCastTest ClObj = new MultiCastTest();
Calc objCalc = new Calc(ClObj.Add);
thid = AppDomain.GetCurrentThreadId();
Console.WriteLine(" ");
Console.WriteLine(" Main Application Thread ID : " + thid.ToString()); Console.WriteLine();
int Result = objCalc.Invoke(8, 8, out thid);
Console.WriteLine("Invoke method completed "); Console.WriteLine();
IAsyncResult rs = objCalc.BeginInvoke(234, 6, out thid, null,null);
Console.WriteLine("Begin Invoke has been start."); Console.WriteLine();
Console.WriteLine( "Resule Mul " + ClObj.Mul(10, 8).ToString());
while (rs.IsCompleted == false)
{
Console.WriteLine("On processing..."); Console.WriteLine();
Thread.Sleep(1000);
}
Result = objCalc.EndInvoke(out thid,rs);
Console.WriteLine("Result : " + Result.ToString()); Console.WriteLine();
Console.WriteLine("Process completed"); Console.WriteLine();
Console.ReadKey();
}
public int Add(int x, int y,out int thid)
{
Console.WriteLine("In side Calling function Add : "); Console.WriteLine();
thid = AppDomain.GetCurrentThreadId();
Console.WriteLine(" Calling function Thread ID : " + thid.ToString());
Console.WriteLine();
Thread.Sleep(1000);
return x + y;
}
public int Mul(int a, int b)
{
Console.WriteLine("Inside Multipule function thred ID. "+ AppDomain.GetCurrentThreadId().ToString()); Console.WriteLine();
return a*b;
}
}
}
using System;
namespace TestMultipuleDelegate
{
interface IMultiCastTest
{
int Add(int x, int y, out int thid);
int Mul(int a, int b);
}
} 
Fig – 4.0 ( Code Sample – 4.0 outputs)
We can see at Fig-4.0: (Code Sample – 4.0 outputs)
Main thread id = Invoke method function call thread id = simple function call immediate after BeginInvoke function call. But BeginInvoke function call thread id is 2992 different.
Some fact about the Delegate
- Delegate is object and by default private type access modifier.
- Delegate class generated by C# compiler according its declaration.
- Delegate class object can hold reference of static or any class object’s function.
- Delegate class is sealed class which generated by the C# compiler during run time.
- Delegate is keyword so any function cannot return delegate type.
- Delegate cannot use as field of the class.
- Delegate provides asynchronous and synchronous call.
Facebook is treading carefully with its facial-recognition "tag suggestion" feature and now is making it easier for users to opt out of the feature according to Connecticut Attorney General George Jepsen, via 
Yeah, I know, Mac fanboys have been dreaming of that since the mid-1990s. But based on some chatter coming out of Microsoft’s Worldwide Partner Conference this week, it could happen, but Apple wouldn’t necessarily be the cause.