Coffee, Code and Chocolate » Delegates http://blog.ganeshzone.net/blog throw new Exception("#fail"); Mon, 26 Jul 2010 19:45:49 +0000 http://wordpress.org/?v=2.9 en hourly 1 Differences between Events and delegates http://blog.ganeshzone.net/blog/index.php/2009/12/differences-between-events-and-delegates/ http://blog.ganeshzone.net/blog/index.php/2009/12/differences-between-events-and-delegates/#comments Sat, 26 Dec 2009 21:33:15 +0000 Ganesh Ranganathan http://blog.ganeshzone.net/blog/?p=710 Events and Delegates are quite tied together in .NET, but there are differences in terms of usage. Events are implemented through delegates, but they are not quite interchangeable. The event keyword is an access modifier on the delegate which restricts its usage outside the class which it belongs to.

First the similarities. [...]]]> Events and Delegates are quite tied together in .NET, but there are differences in terms of usage. Events are implemented through delegates, but they are not quite interchangeable. The event keyword is an access modifier on the delegate which restricts its usage outside the class which it belongs to.

First the similarities. See the below code, which declares a delegate and creates objects for it with and without the event modifier. Then uses both of them, without any difference whatsoever.

    class Test
    {
        public delegate void MyDelegate(string _someRandomMessage);
 
        //One is a delegate while other is an event.
        public MyDelegate _mydelObj;
        public event MyDelegate _myeventObj;
 
        public Test(){
            _mydelObj = s => Console.WriteLine("Delegate Invoked: " + s);
            _myeventObj = s => Console.WriteLine("Event Invoked: " + s);
        }
 
        public void TestDelegates(){
            _mydelObj.Invoke("I am a delegate");
            _myeventObj.Invoke("I am an event");
        }
    }

The main difference starts when you access events outside of the class they were declared in. I created one more class SomeOtherClass (very unimaginative!!) and invoked the public delegate objects from this. When its a plain delegate object, there is no restriction on resetting the invocation list, adding to it, removing from it and also invoking the delegate itself. But try doing that to the event object, and you the compiler will throw the The event ‘EventsAndDelegates.Test._myeventObj’ can only appear on the left hand side of += or -= (except when used from within the type ‘EventsAndDelegates.Test’)

    class SomeOtherClass{
        Test _testObj = new Test();
        public SomeOtherClass()
        {
            _testObj._mydelObj += s => Console.WriteLine("Calling from Outside class: "+s);
            _testObj._myeventObj += s => Console.WriteLine("Calling Event from Outside class " + s);
            //The below code wont work. An event's invocation list cannot be accessed
            //from outside. It can be added to or removed from.
            _testObj._myeventObj = s => Console.WriteLine("Trying to reset the invocation list");
        }
 
        public void InvokeBaseDelegate(){
            _testObj._mydelObj("Delegate Invoked");
            //This will throw an error. An event cannot be triggered from anyother type
            //other than the one which it belongs to
            _testObj._myeventObj("Event Triggered");
        }
    }

This key difference is due to the way events and delegates are exposed outside the class which they are declared in. There is an extra IL declaration for an event object which declares two accessors add and remove for the event. Only these are accessible outside the class.

.event EventsAndDelegates.Test/MyDelegate _myeventObj
{
  .addon instance void EventsAndDelegates.Test::add__myeventObj(class EventsAndDelegates.Test/MyDelegate)
  .removeon instance void EventsAndDelegates.Test::remove__myeventObj(class EventsAndDelegates.Test/MyDelegate)
} // end of event Test::_myeventObj

When this is accessed in SomeOtherClass, the Delegate.Combine method used to add to the delegate object’s invocation list is not available for the event and the only alternatives are the add and remove accessors. Similarly the Invoke method is not available outside the class because of which the events cant be triggered.

.method public hidebysig specialname rtspecialname
        instance void  .ctor() cil managed
{
//Removed for Brevity
  IL_0035:  ldsfld     class EventsAndDelegates.Test/MyDelegate EventsAndDelegates.SomeOtherClass::'CS$<>9__CachedAnonymousMethodDelegate2'
  IL_003a:  call       class [mscorlib]System.Delegate [mscorlib]System.Delegate::Combine(class [mscorlib]System.Delegate,
                                                                                          class [mscorlib]System.Delegate)
  IL_003f:  castclass  EventsAndDelegates.Test/MyDelegate
//Removed for brevity
  IL_0067:  ldsfld     class EventsAndDelegates.Test/MyDelegate EventsAndDelegates.SomeOtherClass::'CS$<>9__CachedAnonymousMethodDelegate3'
//Notice the add_ accessor being called instead of the Delegate.Combine method
  IL_006c:  callvirt   instance void EventsAndDelegates.Test::add__myeventObj(class EventsAndDelegates.Test/MyDelegate)
  IL_0071:  ret
} // end of method SomeOtherClass::.ctor

It makes sense to restrict an event’s invocation list from an outside class. For example, if your application makes use of a public API which polls for the weather at a location and raises an event when there is going to be heavy snow. Someone in your team might have subsribed to the event to send out notifications to employees take caution while travelling. However, your need to subscribe to the event could be totally different. In that case if you use the = sign instead of the += while assigning a handler, the previous code for sending out notifications would not work. Needless to say, there would be a lot of pi**ed off employees baying for your blood the next day.

Apart from this, there is one more difference between delegates and events while declaring them in an interface. An interface cannot contain delegate objects, however they can contain events. If you try to do so, you would get an error Interfaces cannot contain fields.

]]> http://blog.ganeshzone.net/blog/index.php/2009/12/differences-between-events-and-delegates/feed/ 0 Anonymous methods and captured variables in C# 2.0 http://blog.ganeshzone.net/blog/index.php/2009/12/anonymous-methods-and-captured-variables-in-c-2-0/ http://blog.ganeshzone.net/blog/index.php/2009/12/anonymous-methods-and-captured-variables-in-c-2-0/#comments Wed, 23 Dec 2009 20:54:19 +0000 Ganesh Ranganathan http://blog.ganeshzone.net/blog/?p=679 Anonymous methods are a convenient way of using delegates in .NET 2.0 and above. For e.g. if we use a delegate for a simple 2-3 line functionality, declaring a separate method and then passing the target to the delegate seems like overkill. Anonymous methods provide an easy way out, just declare the body [...]]]> Anonymous methods are a convenient way of using delegates in .NET 2.0 and above. For e.g. if we use a delegate for a simple 2-3 line functionality, declaring a separate method and then passing the target to the delegate seems like overkill. Anonymous methods provide an easy way out, just declare the body of the method after the delegates declaration and you have no need to write a seperate method.

Anonymous methods are a compiler feature. Hence, from the CLR’s point of view there is nothing anonymous about it. The C# compiler generates a method with your delegate declaration and adds it to the invocation list for the delegate. Here is some sample code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

 class TestClass
    {
        delegate void writeToScreen(string _inpar);
 
        public static void TestDelegates()
        {
            //1.1 way of doing things. Notice the seperate method.
            writeToScreen _delObj = new writeToScreen(new TestClass().NamedMethod);
 
            //2.0 way of calling it
            _delObj += delegate(string _inpar)
            {
                Console.WriteLine("Anonymous method says: "+_inpar);
            };
 
            //Lets invoke the delegate
            _delObj.Invoke("Hello World");
        }
 
        public void NamedMethod(string _inpar)
        {
            Console.WriteLine("Named method says: " + _inpar);
        }
    }

In the above code, the 1.1 way would have you scrambling to find the definition of the NamedMethod, but in second delegate its simpler and far more easier to understand. In the IL, the compiler generates a method for the anonymous block of code that you write.

1
2
3
4
5
6
7

.method private hidebysig static void  'b__0'(string _inpar) cil managed
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 )
//removed for brevity
  IL_0010:  ret
}
// end of method TestClass::'b__0'

So far so good, but anonymous methods bring more questions to the table. How are variables in the outer scope treated? Can they be accessed? Yes they can and they have a fancy name as well – Captured variables. Here is some code for it.

1
2
3
4
5
6
7
8
9
10
11
12
13

            int _localVar = 0;
            _delObj += delegate(string _inpar)
            {
                _localVar++;
                Console.WriteLine("Anonymous method says: "+_inpar);
            };
 
            //Before invoking the delegate the value is 0
            Console.WriteLine("Local Variable : " + _localVar);
            //Lets invoke the delegate
            _delObj.Invoke("Hello World");
            //After invoking, the value becomes 1
            Console.WriteLine("Local Variable : " + _localVar);

Behind the screens the compilers does a lot of work to get captured variables work. In the MSIL, there is no sign of the local variable, instead a reference variable is created which has the local integer as a member and all modifications are done to it.

The IL shows the int declaration has disappeared in the TestDelegates method. Instead an instance of the class c_Displayclass1 is created and used. The local variable is a member of this instance class and this is the variable that is incremented both in the TestDelegates method as well as the invocation giving the illusion of usage of the local variable in the anonymous method body scope. For short declarations and one or two variables this feature would be quite useful, but a large number of captured variables would make the code difficult to understand, hence compromising the biggest advantage of anonymous methods

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

.method public hidebysig static void  TestDelegates() cil managed
{
   .locals init ([0] class AnonyMeth.TestClass/writeToScreen _delObj,
           [1] class AnonyMeth.TestClass/'<>c__DisplayClass1' 'CS$<>8__locals2')
  IL_0000:  newobj     instance void AnonyMeth.TestClass/'<>c__DisplayClass1'::.ctor()
  IL_0005:  stloc.1
 //removed for brevity
  IL_0019:  stfld      int32 AnonyMeth.TestClass/'<>c__DisplayClass1'::_localVar
  IL_001e:  ldloc.0
  IL_001f:  ldloc.1
  IL_0020:  ldftn      instance void AnonyMeth.TestClass/'<>c__DisplayClass1'::'b__0'(string)
  IL_0026:  newobj     instance void AnonyMeth.TestClass/writeToScreen::.ctor(object,
                                                                              native int)
  IL_002b:  call       class [mscorlib]System.Delegate [mscorlib]System.Delegate::Combine(class [mscorlib]System.Delegate,
                                                                                          class [mscorlib]System.Delegate)
  IL_0030:  castclass  AnonyMeth.TestClass/writeToScreen
  IL_0035:  stloc.0
  IL_0036:  ldstr      "Local Variable : "
  IL_003b:  ldloc.1
  IL_003c:  ldfld      int32 AnonyMeth.TestClass/'<>c__DisplayClass1'::_localVar
  //The instance variable of c__displayclass1 is displayed here
  //removed for brevity
  IL_0075:  ret
} // end of method TestClass::TestDelegates
]]> http://blog.ganeshzone.net/blog/index.php/2009/12/anonymous-methods-and-captured-variables-in-c-2-0/feed/ 0