DenkzeitWiki

Main /

Delegates

CSharp
Functor

Closures
LambdaExpressions Something like function-pointers in C++. But type-safe.

• http://www.onjava.com/pub/a/onjava/2003/05/21/delegates.html --A Java Programmer Looks at C# Delegates

Think of a delegate as an interface declaring exactly one method. An instantiation of a delegate is similar to an anonymous inner class that implements the interface through a one-line call to a single method (static or instance) with a compatible signature.

 public class Class {
    public void display(String s) { Console.WriteLine(s); }
 }

 public delegate void doShow(String s);

 doShow item = new doShow(new Class().display);

Note that the display-method is given as an object (not an actual call) to the delegate doShow!
Note also that the signature of the delegate and the wrapped method are identical: (String) in the example.

Delegates can be simulated in Java by means of reflection: Give Object and name of function to some administring object (delegator).

Delegates handle problems which would be solved with function pointers in C++, and interfaces in Java. [1]

---

• http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csref/html/vcwlkdelegatestutorial.asp --Delegates Tutorial
  
  
• since c# 2.0, delegates can be anonymous, enabling Closures.
  • http://joe.truemesh.com/blog/000390.html --The power of closures in C# 2.0
  • http://pensieve.thinkingms.com/CommentView,guid,81e20e21-6ec6-4fed-9c89-a5b77d21aec6.aspx -- Closure implementation enhancement in CLR 2.0 using the new delegate mechanism
• http://rotor.di.unipi.it/cisterni/Lists/My%20Blog/DispForm.aspx?ID=8 --Closures in CLR 2.0
  
• http://www.devsource.ziffdavis.com/article2/0,1759,1617062,00.asp --Delegates vs. Interfaces

You can create a delegate to any (reference or value type) object which has a method of the right signature.

• Interfaces are faster. Should be used when possible to put them into the class-hierarchy.
• Delegates allow adaption of methods with different name but same signature. Feels a bit like DuckTyping for methods...

• If You Want to Understand C#, Then Don't Waste Time Studying C#: Delegates vs Interfaces in a Nonfunctional World

Events With Delegates

The 'event' keyword hides all the delegate's methods apart from += and -= to classes other than the class it is declared in. [2]

• http://blog.sun.com/roller/comments/dreamwords/Weblog/events_handling_in_java_and --Events Handling in Java and C#
  
• http://www.c-sharpcorner.com/Code/2002/Mar/EventHandlingInNetUsingCSDD001.asp --Event Handling in .NET using C#

C# allows you to create a multicast delegate instance by using the 'event' keyword [3]

• http://codebetter.com/blogs/peter.van.ooijen/archive/2005/08/31/131485.aspx --The C# event keyword is an access modifier for delegate members
  • One can use Delegates in the same way one can use events. Declaring a delegate as event narrows the delegate's interface.
• http://blog.monstuff.com/archives/000040.html --C# events vs. delegates
  • event is a modifier for delegates.
    • First, an event can be included in an interface declaration, whereas a field cannot.
    • Then, invoking an event can only be done from within the class that declared the event, whereas a delegate field can be invoked by whoever has access to it.

Discussion

• http://java.sun.com/docs/white/delegates.html --About Microsoft's "Delegates"
• http://msdn.microsoft.com/vjsharp/productinfo/visualj/visualj6/technical/articles/general/truth/default.aspx --The Truth About Delegates

Q&A

What's the difference between delegates and methods as objects?

I can delegate a method-invokation (of a method that is bound to an instance) in Python:

  >>> class test(object):
 ...     def method(self, o):
 ...             self.o = o
 ...
 >>> test.method
 <unbound method test.method>
 >>> test().method
 <bound method test.method of <__main__.test object at 0x008D1870>>
 >>> t = test()
 >>> t.method
 <bound method test.method of <__main__.test object at 0x008D1B70>>
 >>> t.method(3)
 >>> t.o
 3
 >>> delegate = t.method
 >>> delegate(6)
 >>> t.o
 6

• Is, therefore, the type-safety of delegates crucial?
• Is the first-classness of methods in C# much different to the on in Python?