{"id":588,"date":"2022-05-02T16:00:36","date_gmt":"2022-05-02T09:00:36","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=588"},"modified":"2022-12-30T09:28:34","modified_gmt":"2022-12-30T02:28:34","slug":"csharp-delegate","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-delegate\/","title":{"rendered":"C# Delegates"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# delegates and how to use them effectively.<\/p>\n\n\n\n

Introduction to the C# delegates<\/h2>\n\n\n\n

In C#, delegates are types that represent references to methods with a particular parameter list and return type.<\/p>\n\n\n\n

To define a delegate, you use the delegate<\/code> keyword and specify the method signature. For example:<\/p>\n\n\n

delegate<\/span> void<\/span> Greeting<\/span>(string<\/span> message<\/span>)<\/span>;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we define the Greeting<\/code> delegate type that can reference any method which accepts a string argument and returns void<\/code>. <\/p>\n\n\n\n
Since the Greeting<\/code> is a delegate type, you can declare it outside a class like other classes.<\/p>\n\n\n\n
The following defines the SayHi()<\/code> method for the Program<\/code> class, which has the same signature as the Greeting<\/code> delegate:<\/p>\n\n\n
class<\/span> Program<\/span>\n{\n    static<\/span> void<\/span> SayHi<\/span>(string<\/span> name<\/span>)<\/span>\n    {\n        Console.WriteLine($\"Hi {name}<\/span>\"<\/span>);\n    }\n    \/\/ ...<\/span>\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
To call the SayHi()<\/code> method via the Greeting<\/code> delegate, you create an instance of the Greeting<\/code> delegate with the SayHi<\/code> method as an argument and call the Invoke()<\/code> method of the delegate instance like this:<\/p>\n\n\n
Greeting greeting = new<\/span> Greeting(SayHi);\ngreeting.Invoke(\"John\"<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this syntax, the greeting<\/code> is an instance of the Greeting<\/code> delegate type. The greeting<\/code> delegate holds a reference to the SayHi()<\/code> method. Internally, the greeting<\/code> delegate maintains an invocation list that has a reference to the SayHi()<\/code> method.<\/p>\n\n\n\n
When you call the Invoke()<\/code> method of the greeting<\/code> delegate, C# will call the SayHi()<\/code> method with the same argument. Therefore, the following statements are functionally equivalent:<\/p>\n\n\n
greeting.Invoke(\"John\"<\/span>);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
And:<\/p>\n\n\n
SayHi(\"John\"<\/span>);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
C# provides you with a shorter way to create a new instance of the Greeting<\/code> delegate by assigning the SayHi<\/code> method to a delegate variable and calling the referenced method via the delegate:<\/p>\n\n\n
Greeting greeting = SayHi;\ngreeting(\"John\"<\/span>);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Note that you assign the method name SayHi<\/code> without parentheses ()<\/code> to the delegate variable.<\/p>\n\n\n\n
Put it all together.<\/p>\n\n\n
delegate<\/span> void<\/span> Greeting<\/span>(string<\/span> message<\/span>)<\/span>;\n\nclass<\/span> Program<\/span>\n{\n    static<\/span> void<\/span> SayHi<\/span>(string<\/span> name<\/span>)<\/span>\n    {\n        Console.WriteLine($\"Hi {name}<\/span>\"<\/span>);\n    }\n\n    static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        Greeting greeting = SayHi;\n        greeting(\"John\"<\/span>);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi John<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
If you have C++ background, the fastest way for you to understand delegates is to think of them as function pointers. However, a delegate is fully object-oriented in C#. And unlike C++ function pointers,  delegates encapsulate both an object instance and a method.<\/p>\n\n\n\n
Why delegates<\/h2>\n\n\n\n
Since you can directly call the SayHi()<\/code> method, you don’t need to call it via the delegate. The question is why do you need a delegate?<\/p>\n\n\n\n
Because delegates hold references to methods, you can pass methods as arguments to other methods via the delegates. Therefore, delegates are ideal for defining callback methods<\/strong>.<\/p>\n\n\n\n
Suppose you want to define a method that filters a list of integers based on the result of another method. To do that, you can use a delegate.<\/p>\n\n\n\n
First, define a delegate type that accepts an integer and returns a boolean value:<\/p>\n\n\n
delegate<\/span> bool<\/span> Callback<\/span>(int<\/span> x<\/span>)<\/span>;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, define the Filter()<\/code> method that accepts a list of integers and an instance of the Callback<\/code>. If an integer causes the callback to return true<\/code>, the result of the Filter()<\/code> method will include that integer:<\/p>\n\n\n
static<\/span> List<int<\/span>> Filter<\/span>(List<int<\/span>> numbers, Callback callback<\/span>)<\/span>\n{\n    var<\/span> results = new<\/span> List<int<\/span>>();\n\n    foreach<\/span> (var<\/span> number in<\/span> numbers)\n    {\n        if<\/span> (callback(number))\n        {\n            results.Add(number);\n        }\n    }\n\n    return<\/span> results;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Third, define the isOdd()<\/code> method that returns true<\/code> if a number is odd and the isEven()<\/code> method that returns true<\/code> if a number is even:<\/p>\n\n\n
static<\/span> bool<\/span> IsOdd<\/span>(int<\/span> x<\/span>)<\/span> => x % 2<\/span> != 0<\/span>;\nstatic<\/span> bool<\/span> IsEven<\/span>(int<\/span> x<\/span>)<\/span> => x % 2<\/span> == 0<\/span>;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Fourth, call the Filter()<\/code> method and pass an instance of the Callback<\/code> delegate that references the IsEven()<\/code> method. The Filter()<\/code> method returns a list of even integer numbers:<\/p>\n\n\n
var<\/span> numbers = new<\/span> List<int<\/span>> { 1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span> };\n\nvar<\/span> evenNumbers = Filter(numbers, IsEven);\n\nConsole.WriteLine(\"Even numbers:\"<\/span>);\nforeach<\/span> (var<\/span> number in<\/span> evenNumbers)\n{\n    Console.WriteLine($\"{number}<\/span>\"<\/span>);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Even numbers:\n2<\/span>\n4<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Fifth, call the Filter()<\/code> method and pass an instance of the Callback<\/code> delegate that references the isOdd()<\/code> method. The Filter()<\/code> method returns a list of odd integer numbers:<\/p>\n\n\n
var<\/span> numbers = new<\/span> List<int<\/span>> { 1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span> };\n\nvar<\/span> oddNumbers = Filter(numbers, IsOdd);\n\nConsole.WriteLine(\"Odd numbers:\"<\/span>);\nforeach<\/span> (var<\/span> number in<\/span> oddNumbers)\n{\n    Console.WriteLine($\"{number}<\/span>\"<\/span>);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Odd numbers:\n1<\/span>\n3<\/span>\n5<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Put it all together:<\/p>\n\n\n
class<\/span> Program<\/span>\n{\n    delegate<\/span> bool<\/span> Callback<\/span>(int<\/span> x<\/span>)<\/span>;\n\n    static<\/span> List<int<\/span>> Filter<\/span>(List<int<\/span>> numbers, Callback callback<\/span>)<\/span>\n    {\n        var<\/span> results = new<\/span> List<int<\/span>>();\n\n        foreach<\/span> (var<\/span> number in<\/span> numbers)\n        {\n            if<\/span> (callback(number))\n            {\n                results.Add(number);\n            }\n        }\n\n        return<\/span> results;\n    }\n\n    static<\/span> bool<\/span> IsOdd<\/span>(int<\/span> x<\/span>)<\/span> => x % 2<\/span> != 0<\/span>;\n    static<\/span> bool<\/span> IsEven<\/span>(int<\/span> x<\/span>)<\/span> => x % 2<\/span> == 0<\/span>;\n\n    static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        var<\/span> numbers = new<\/span> List<int<\/span>> { 1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span> };\n\n        var<\/span> evenNumbers = Filter(numbers, IsEven);\n        Console.WriteLine(\"Even numbers:\"<\/span>);\n        foreach<\/span> (var<\/span> number in<\/span> evenNumbers)\n        {\n            Console.WriteLine($\"{number}<\/span>\"<\/span>);\n        }\n\n\n        var<\/span> oddNumbers = Filter(numbers, IsOdd);\n        Console.WriteLine(\"Odd numbers:\"<\/span>);\n        foreach<\/span> (var<\/span> number in<\/span> oddNumbers)\n        {\n            Console.WriteLine($\"{number}<\/span>\"<\/span>);\n        }\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
By using a delegate as a callback, you can pass a method as an argument to another method. In this example, the Filter()<\/code> method is very dynamic that can accept any method for filtering the integer list.<\/p>\n\n\n\n
Adding methods to a delegate<\/h2>\n\n\n\n
A delegate can hold references to multiple methods. In this case, the delegate is called a multicast delegate<\/strong>.<\/p>\n\n\n\n
To add a method to a delegate, you use the +=<\/code> operator. For example:<\/p>\n\n\n
delegate void<\/span> Greeting(string message);\n\nclass<\/span> Program<\/span>\n<\/span>{\n    static<\/span> void<\/span> SayHi(string name) => Console.WriteLine($\"Hi {name}\"<\/span>);\n\n    static<\/span> void<\/span> SayBye(string name) => Console.WriteLine($\"Bye {name}\"<\/span>);\n   \n    static<\/span> void<\/span> Main(string[] args)\n    {\n        Greeting greeting = SayHi;\n        greeting += SayBye;\n        greeting(\"John\"<\/span>);\n    }\n}<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi John\nBye John<\/code><\/span><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define the Greeting<\/code> delegate type:<\/p>\n\n\n
delegate void<\/span> Greeting(string message);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Next, define two static methods SayHi()<\/code> and SayBye()<\/code> in the Program<\/code> class:<\/p>\n\n\n
static<\/span> void<\/span> SayHi(string name) => Console.WriteLine($\"Hi {name}\"<\/span>);\nstatic<\/span> void<\/span> SayBye(string name) => Console.WriteLine($\"Bye {name}\"<\/span>);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Then, create a new instance of the Greeting<\/code> delegate type and assign the SayHi<\/code> method to greeting variable:<\/p>\n\n\n
Greeting greeting = SayHi;<\/code><\/span><\/pre>\n\n\n
After that, add a new method to the invocation list of the greeting<\/code> delegate:<\/p>\n\n\n
greeting += SayBye;<\/code><\/span><\/pre>\n\n\n
Finally, call the methods in the invocation list of the greeting delegate:<\/p>\n\n\n
greeting(\"John\"<\/span>);<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
This statement invokes the SayHi()<\/code> and SayBye()<\/code> method in the invocation list of the greeting method. It’s important to note that the delegate may call the methods in its invocation list in any order. Therefore, you should not rely on the order of the methods.<\/p>\n\n\n\n
Delegates are immutable. It means that a delegate cannot be changed once it is created. Therefore, the following creates a new delegate and assigns it to the greeting variable:<\/p>\n\n\n
greeting += SayBye;<\/code><\/span><\/pre>\n\n\n
Removing a method from a delegate<\/h2>\n\n\n\n
To remove a method from a delegate, you use the -=<\/code> operator. Note that C# will issue an error if you attempt to call a delegate with an empty invocation list.<\/p>\n\n\n\n
The following example illustrates how to remove a method from the invocation list of a delegate:<\/p>\n\n\n
delegate<\/span> void<\/span> Greeting<\/span>(string<\/span> message<\/span>)<\/span>;\n\nclass<\/span> Program<\/span>\n{\n    static<\/span> void<\/span> SayHi<\/span>(string<\/span> name<\/span>)<\/span> => Console.WriteLine($\"Hi {name}<\/span>\"<\/span>);\n\n    static<\/span> void<\/span> SayBye<\/span>(string<\/span> name<\/span>)<\/span> => Console.WriteLine($\"Bye {name}<\/span>\"<\/span>);\n\n    static<\/span> void<\/span> Say<\/span>(string<\/span> message<\/span>)<\/span> => Console.WriteLine(message);\n\n    static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        Greeting greeting = SayHi;\n        greeting += Say;\n        greeting += SayBye;\n\n        greeting -= SayHi;\n\n        greeting(\"John\"<\/span>);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
John\nBye John<\/code><\/span><\/pre>\n\n\n
In this example, before calling the methods, we remove the SayHi<\/code> method from the invocation list of the greeting delegate:<\/p>\n\n\n
greeting -= SayHi;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
If you remove all the methods from the invocation list of a delegate, the delegate will be null. To invoke the delegate with a null check, you can use a null conditional operator like this:<\/p>\n\n\n
greeting?.Invoke(\"John\"<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary<\/h2>\n\n\n\n
    \n
  • A delegate is a type that references methods with a particular parameter list and return type.<\/li>\n\n\n\n
  • Use a delegate as a callback to pass a method as an argument to another method.<\/li>\n\n\n\n
  • Delegates are immutable.<\/li>\n\n\n\n
  • Use +=<\/code> operator to add a method to the invocation list of a delegate.<\/li>\n\n\n\n
  • Use -=<\/code> operator to remove a method from the invocation list of a delegate.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t\n\t\t\t