-
Notifications
You must be signed in to change notification settings - Fork 1
Delegates
// Declaring a delegate type.
public delegate string MyDelegate(bool b, int n);
// Declaring and initializing a delegate variable.
MyDelegate mdel = new MyDelegate(SomeMethod);
// Alternatively, you can just supply the method name.
// This is called "method group conversion syntax".
MyDelegate mdel = SomeMethod;
// Delegates can be combined to call multiple methods.
mdel += AnotherMethod;
mdel += OrAnotherDelegate;
// Invoking the delegate.
mdel();
public delegate void GenericDel<T>(T arg);
public void MyFunc(string a) { }
GenericDel<string> strTarget = MyFunc;
These two are out-of-the-box, generic delegate types for simplifying the definition of a delegate.
- Takes up to 16 arguments.
- Can only point to functions with a
void
return type.
static void DisplayMessage(string msg, ConsoleColor col) { }
Action<string, ConsoleColor> target = DisplayMessage;
target("hello", ConsoleColor.Blue);
As you can see in the example, the types in the generic parameter list define the types of the parameters the delegate methods take in.
- Takes up to 16 arguments.
- The last generic parameter is the return type.
static string IntToString(int a) { }
Func<int, string> target = IntToString;
string s = target(5);
Defined in the System as such:
public delegate bool Predicate<T>(T obj);
This is used in places like List.FindAll()
.
Events are a special kind of multicast delegate that can only be invoked from within the class or struct where they are declared (the publisher class).
public delegate string MyDelegate(int a);
public event MyDelegate MyEvent;
Microsoft's recommended pattern for how to publish data with a delegate.
public delegate void MyDelegate(object sender, MyEventArgs e);
public event MyDelegate MyEvent;
public class MyEventArgs
{
public MyEventArgs(string s) { Text = s; }
public string Text { get; private set; } // readonly
}
// Variation
public class MyEventArgs
{
public MyEventArgs(string s) { text = s; }
public readonly string text;
}
// Now when you raise an event to listeners. (In the publisher class...)
MyEvent(this, new MyEventArgs("Hey, this is some event data."));
Given the recommended (object sender, EventArgs e) pattern, there is a generic event type Microsoft provides to streamline this.
public event EventHandler<MyEventArgs> MyEvent;
You don't need to define the delegate in this case.
The compiler generates a class for a delegate type.
sealed class MyDelegate : System.MulticastDelegate
{
// Basic synchronous invocation.
public string Invoke(bool b, int n);
// The other two are for asynchronous use.
public IAsyncResult BeginInvoke(bool b, int b, AsyncCallback cb, object state);
public string EndInvoke(IAsyncResult result);
}
The MulticastDelegate
class is defined as such:
public abstract class MulticastDelegate : Delegate
{
// Returns the list of methods "pointed to"
public sealed override Delegate[] GetInvocationList();
// Overloaded operators.
public static bool operator ==(MulticastDelegate d1, MulticastDelegate d2);
public static bool operator !=(MulticastDelegate d1, MulticastDelegate d2);
// Used internally to manage the list of methods maintained by the delegate.
private IntPtr _invocationCount;
private object _invocationList;
}
The Delegate
class is defined as such:
public abstract class Delegate : ICloneable, ISerializable
{
// Methods to interact with the list of functions.
public static Delegate Combine(params Delegate[] delegates);
public static Delegate Combine(Delegate a, Delegate b);
public static Delegate Remove(Delegate source, Delegate value);
public static Delegate RemoveAll(Delegate source, Delegate value);
// Overloaded operators.
public static bool operator ==(Delegate d1, Delegate d2);
public static bool operator !=(Delegate d1, Delegate d2);
// Properties that expose the delegate target.
public MethodInfo Method { get; }
public object Target { get; }
}
- The '+=' operator is syntax sugar for the Combine() method.
- The '-=' operator is syntax sugar for the Remove() method.
- 'Method' gets target method details.
- 'Target' gets object details if the target method belongs to an instance.
- Abstract Classes
- Access Modifiers
- Anonymous Methods
- Anonymous Types
- Arrays
- Attributes
- Console I/O
- Constructors
- Const Fields
- Delegates
- Enums
- Exceptions
- Extension Methods
- File IO
- Generics
- Interfaces
- Iterators
- LINQ
- Main
- Null Operators
- Parameters
- Polymorphism
- Virtual Functions
- Reflection
- Serialization
- Strings
- Value Types
- "Base" Keyword
- "Is" and "As"
- "Sealed" Keyword
- nameof expression