Delegates

Delegates

Delegates enable scenarios that some other languages have addressed with function pointers. However, unlike function pointers, delegates are object-oriented, type-safe, and secure.

A delegate declaration defines a class that is derived from the class System.Delegate. A delegate instance encapsulates one or more methods, each of which is referred to as a callable entity. For instance methods, a callable entity consists of an instance and a method on that instance. For static methods, a callable entity consists of just a method. Given a delegate instance and an appropriate set of arguments, one can invoke all of that delegate instance's methods with that set of arguments.

An interesting and useful property of a delegate instance is that it does not know or care about the classes of the methods it encapsulates; all that matters is that those methods be compatible (‎15.1) with the delegate's type. This makes delegates perfectly suited for "anonymous" invocation. This is a powerful capability.

There are three steps in defining and using delegates: declaration, instantiation, and invocation. Delegates are declared using delegate declaration syntax. The example

delegate void SimpleDelegate();

declares a delegate named SimpleDelegate that takes no arguments and returns void.

The example

class Test

static void Main()
}

creates a SimpleDelegate instance and then immediately calls it.

There is not much point in instantiating a delegate for a method and then immediately calling it via the delegate, as it would be simpler to call the method directly. Delegates really show their usefulness when their anonymity is used. The example

void MultiCall(SimpleDelegate d, int count)
}

shows a MultiCall method that repeatedly calls a SimpleDelegate. The MultiCall method doesn't know or care about the type of target method for the SimpleDelegate, what accessibility the method has, or whether or not the method is static. All that matters is that the target method is compatible (‎15.1) with SimpleDelegate.