Delegates
This part of the C# tutorial is dedicated to delegates.Delegate A delegate is a form of type-safe function pointer used by the .NET Framework. Delegates are often used to implement callbacks and event listeners. A delegate does not need to know anything about classes of methods it works with.
A delegate is a reference type. But instead of referring to an object, a delegate refers to a method.
Delegates are used in the following cases:
- Event handlers
- Callbacks
- LINQ
- Implementation of design patterns
Using delegates
Simple delegates We will have some simple examples showing, how to use delegates.using System;We declare a delegate, create an instance of the delegate and invoke it.
delegate void Mdelegate();
public class CSharpApp
{
static void Main()
{
Mdelegate del = new Mdelegate(Callback);
del();
}
static void Callback()
{
Console.WriteLine("Calling callback");
}
}
delegate void Mdelegate();This is our delegate declaration. It returns no value and takes no parameters.
Mdelegate del = new Mdelegate(Callback);We create an instance of the delegate. When called, the delegate will invoke the static Callback() method.
del();We call the delegate.
$ ./simple.exeOutput.
Calling callback
Simplified syntax We can use a different syntax for creating and using a delegate.
using System;We can save some typing when creating an instance of a delegate. It was introduces in C# 2.0.
delegate void Mdelegate();
public class CSharpApp
{
static void Main()
{
Mdelegate del = Callback;
del();
}
static void Callback()
{
Console.WriteLine("Calling callback");
}
}
Mdelegate del = Callback;This is another way of creating a delegate. We save some typing.
Anonymous methods It is possible to use anonymous methods with delegates.
using System;We can omit a method declaration when using an anonymous method with a delegate. The method has no name and can be invoked only via the delegate.
delegate void Mdelegate();
public class CSharpApp
{
static void Main()
{
Mdelegate del = delegate {
Console.WriteLine("Anonymous method");
};
del();
}
}
Mdelegate del = delegate {
Console.WriteLine("Anonymous method");
};
Here we create a delegate, that points to an anonymous method. The anonymous method has a body enclosed by { } characters, but it has no name. A delegate can point to different methods over time.
using System;In the example we have one delegate. This delegate is used to point to two methods of the Person class. The methods are called with the delegate.
public delegate void NameDelegate(string msg);
public class Person
{
public string firstName;
public string secondName;
public Person(string firstName, string secondName)
{
this.firstName = firstName;
this.secondName = secondName;
}
public void ShowFirstName(string msg)
{
Console.WriteLine(msg + this.firstName);
}
public void ShowSecondName(string msg)
{
Console.WriteLine(msg + this.secondName);
}
}
public class CSharpApp
{
public static void Main()
{
Person per = new Person("Fabius", "Maximus");
NameDelegate nDelegate = new NameDelegate(per.ShowFirstName);
nDelegate("Call 1: ");
nDelegate = new NameDelegate(per.ShowSecondName);
nDelegate("Call 2: ");
}
}
public delegate void NameDelegate(string msg);The delegate is created with a
delegate keyword. The delegate signature must match the signature of the method being called with the delegate. NameDelegate nDelegate = new NameDelegate(per.ShowFirstName);We create an instance of a new delegate, that points to the
nDelegate("Call 1: ");
ShowFirstName() method. Later we call the method via the delegate. $ ./simpledelegate.exeBoth names are printed via the delegate.
Call 1: Fabius
Call 2: Maximus
Multicast delegate Multicast delegate is a delegate which holds a reference to more than one method. Multicast delegates must contain only methods that return void, else there is a run-time exception.
using System;This is an example of a multicast delegate.
delegate void Mdelegate(int x, int y);
public class Oper
{
public static void Add(int x, int y)
{
Console.WriteLine("{0} + {1} = {2}", x, y, x + y);
}
public static void Sub(int x, int y)
{
Console.WriteLine("{0} - {1} = {2}", x, y, x - y);
}
}
public class CSharpApp
{
static void Main()
{
Mdelegate del = new Mdelegate(Oper.Add);
del += new Mdelegate(Oper.Sub);
del(6, 4);
del -= new Mdelegate(Oper.Sub);
del(2, 8);
}
}
delegate void Mdelegate(int x, int y);Our delegate will take two parameters. We have an Oper class, which has two static methods. One adds two values the other one subtracts two values.
Mdelegate del = new Mdelegate(Oper.Add);We create an instance of our delegate. The delegate points to the static Add() method of the Oper class.
del += new Mdelegate(Oper.Sub);We plug another method to the existing delegate instance. The first call of the delegate invokes two methods.
del(6, 4);
del -= new Mdelegate(Oper.Sub);We remove one method from the delegate. The second call of the delegate invokes only one method.
del(2, 8);
$ ./multicast.exeOutput.
6 + 4 = 10
6 - 4 = 2
2 + 8 = 10
Delegates as method parameters
Delegates can be used as method parameters.using System;We have a DoOperation() method, which takes a delegate as a parameter.
delegate int Arithm(int x, int y);
public class CSharpApp
{
static void Main()
{
DoOperation(10, 2, Multiply);
DoOperation(10, 2, Divide);
}
static void DoOperation(int x, int y, Arithm del)
{
int z = del(x, y);
Console.WriteLine(z);
}
static int Multiply(int x, int y)
{
return x * y;
}
static int Divide(int x, int y)
{
return x / y;
}
}
delegate int Arithm(int x, int y);This is a delegate declaration.
static void DoOperation(int x, int y, Arithm del)This is DoOperation() method implementation. The third parameter is a delegate. The DoOperation() method calls a method, which is passed to it as a third parameter.
{
int z = del(x, y);
Console.WriteLine(z);
}
DoOperation(10, 2, Multiply);We call the DoOperation() method. We pass two values and a method to it. What we do with the two values, depends on the method that we pass. This is the flexibility that come with using delegates.
DoOperation(10, 2, Divide);
Events
Events are messages triggered by some action. Click on the button or tick of a clock are such actions. The object that triggers an event is called a sender and the object that receives the event is called a receiver.By convention, event delegates in the .NET Framework have two parameters, the source that raised the event and the data for the event.
using System;We have a simple example in which we create and launch an event. An random number is generated. If the number equals to 5 a FiveEvent event is generated.
public delegate void OnFiveHandler(object sender, EventArgs e);
class FEvent {
public event OnFiveHandler FiveEvent;
public void OnFiveEvent()
{
if(FiveEvent != null)
FiveEvent(this, EventArgs.Empty);
}
}
public class CSharpApp
{
static void Main()
{
FEvent fe = new FEvent();
fe.FiveEvent += new OnFiveHandler(Callback);
Random random = new Random();
for (int i = 0; i<10; i++)
{
int rn = random.Next(6);
Console.WriteLine(rn);
if (rn == 5)
{
fe.OnFiveEvent();
}
}
}
public static void Callback(object sender, EventArgs e)
{
Console.WriteLine("Five Event occured");
}
}
public event OnFiveHandler FiveEvent;An event is declared with a
event keyword. fe.FiveEvent += new OnFiveHandler(Callback);Here we plug the event called FiveEvent to the Callback method. In other words, if the ValueFive event is triggered, the Callback() method is executed.
public void OnFiveEvent()When the random number equals to 5, we invoke the OnFiveEvent() method. In this method, we raise the FiveEvent event. This event carries no arguments.
{
if(FiveEvent != null)
FiveEvent(this, EventArgs.Empty);
}
$ ./simpleevent.exeOutcome of the program might look like this.
3
0
5
Five Event occured
0
5
Five Event occured
2
3
4
4
0
Complex event example Next we have a more complex example. This time we will send some data with the generated event.
using System;We have four classes. FiveEventArgs carries some data with the event object. The FEvent class encapsulates the event object. RandomEventGenerator class is responsible for random number generation. It is the event sender. Finally the CSharpApp class, which is the main application object and has the Main() method.
public delegate void OnFiveHandler(object sender, FiveEventArgs e);
public class FiveEventArgs : EventArgs
{
public int count;
public DateTime time;
public FiveEventArgs(int count, DateTime time)
{
this.count = count;
this.time = time;
}
}
public class FEvent
{
public event OnFiveHandler FiveEvent;
public void OnFiveEvent(FiveEventArgs e)
{
FiveEvent(this, e);
}
}
public class RandomEventGenerator
{
public void Generate()
{
int count = 0;
FiveEventArgs args;
FEvent fe = new FEvent();
fe.FiveEvent += new OnFiveHandler(Callback);
Random random = new Random();
for (int i = 0; i<10; i++)
{
int rn = random.Next(6);
Console.WriteLine(rn);
if (rn == 5)
{
count++;
args = new FiveEventArgs(count, DateTime.Now);
fe.OnFiveEvent(args);
}
}
}
public void Callback(object sender, FiveEventArgs e)
{
Console.WriteLine("Five event {0} occured at {1}",
e.count, e.time);
}
}
public class CSharpApp
{
static void Main()
{
RandomEventGenerator reg = new RandomEventGenerator();
reg.Generate();
}
}
public class FiveEventArgs : EventArgsThe FiveEventArgs carries data inside the event object. It inherits from the
{
public int count;
public DateTime time;
...
EventArgs base class. The count and time members are data that will be initialized and carried with the event. if (rn == 5)If the generated random number equals to 5, we instantiate the FiveEventArgs class with the current count and DateTime values. The count variable counts the number of times this event was generated. The DateTime value holds the time, when the event was generated.
{
count++;
args = new FiveEventArgs(count, DateTime.Now);
fe.OnFiveEvent(args);
}
$ ./complexevent.exeThis is the ouput I got on my computer.
2
2
3
5
Five event 1 occured at 11/7/2010 12:13:59 AM
5
Five event 2 occured at 11/7/2010 12:13:59 AM
1
1
0
5
Five event 3 occured at 11/7/2010 12:13:59 AM
5
Five event 4 occured at 11/7/2010 12:13:59 AM
Predefined delegates
The .NET framework has several built-in delegates that a reduce the typing needed and make the programming easier for developers.Action delegate An action delegate encapsulates a method that has no parameters and does not return a value.
using System;Using predefined delegates further simplifies programming. We do not need to declare a delegate type.
public class CSharpApp
{
static void Main()
{
Action act = ShowMessage;
act();
}
static void ShowMessage()
{
Console.WriteLine("C# language");
}
}
Action act = ShowMessage;We instantiate an action delegate. The delegate points to the ShowMessage() method. When the delegate is invoked, the ShowMessage() method is executed.
act();
Action<T> delegate There are multiple types of action delegates. For example, the Action<T> delegate encapsulates a method that takes a single parameter and does not return a value.
using System;We modify the previous example to use the action delegate, that takes one parameter.
public class CSharpApp
{
static void Main()
{
Action<string> act = ShowMessage;
act("C# language");
}
static void ShowMessage(string message)
{
Console.WriteLine(message);
}
}
Action<string> act = ShowMessage;We create an instance of the Action<T> delegate and call it with one parameter.
act("C# language");
Predicate delegate A predicate is a method that returns true or false. A predicate delegate is a reference to a predicate. Predicates are very useful for filtering a list of values.
using System;We have a list of integer values. We want to filter all numbers, that are bigger than three. For this, we use the predicate delegate.
using System.Collections.Generic;
public class CSharpApp
{
static void Main()
{
List<int> list = new List<int> { 4, 2, 3, 0, 6, 7, 1, 9 };
Predicate<int> predicate = greaterThanThree;
List<int> list2 = list.FindAll(predicate);
foreach ( int i in list2)
{
Console.WriteLine(i);
}
}
static bool greaterThanThree(int x)
{
return x > 3;
}
}
List<int> list = new List<int> { 4, 2, 3, 0, 6, 7, 1, 9 };
This is a generic list of integer values. Predicate<int> predicate = greaterThanThree;We create an instance of a predicate delegate. The delegate points to a predicate, a special method that returns true or false.
List<int> list2 = list.FindAll(predicate);The FindAll() method retrieves all the elements that match the conditions defined by the specified predicate.
static bool greaterThanThree(int x)The predicate returns true for all values, that are greater than three.
{
return x > 3;
}
This part of the C# tutorial was dedicated to the delegates.
Do you like this Tutorial? Please link back to this article by copying one of the codes below.
URL: HTML link code: BB (forum) link code:
No comments: