{"id":164,"date":"2018-02-19T19:46:00","date_gmt":"2018-02-19T18:46:00","guid":{"rendered":"https:\/\/kindsonthegenius.com\/blog\/2018\/02\/19\/what-are-delegates-in-c\/"},"modified":"2020-08-22T09:15:40","modified_gmt":"2020-08-22T07:15:40","slug":"what-are-delegates-in-c","status":"publish","type":"post","link":"https:\/\/kindsonthegenius.com\/blog\/what-are-delegates-in-c\/","title":{"rendered":"What are Delegates in C#"},"content":{"rendered":"
\n
A delegate in C# can be conpared to a function pointer in C and C++. It allows programmers to specify what the funtion to be called will look like without having to specify the particular function.<\/p>\n
<\/a><\/div>\n

A delegate is a reference type variable that hods th reference to a function, which can change at runtime.
Delegates are very useful when programing UI controles where events have to be implemented for callbacks.<\/p>\n

Normal Function Call Without Delegate<\/b>
In normal function call, we specify the function to be called directly. So if a funciton is defined an a class named SomeClass and has a function called Do(), then the function can be called using the syntax:
SomeFunction.Do()<\/p>\n

\n
namespace<\/span> DelegateDemo
{
    public<\/span> class<\/span> SomeClass
    {
        public<\/span> void<\/span> Process()
        {
            Console.WriteLine(\"Process() begin\"<\/span>);
            Console.WriteLine(\"Process() end\"<\/span>);
        }
    }

    public<\/span> class<\/span> Test
    {
        static<\/span> void<\/span> Main(string<\/span>[] args)
        {
            SomeClass myClass = new<\/span> SomeClass();
            myClass.Process();
        }
    }
}<\/code><\/pre>\n
\n
The above code works perfectly in most situaition. However, there may be sometimes when we dont’ want to call  a function directly. We need to pass it to some ohter method to call it. This would be neccessary  in an event driven system sucha s a graphical user interface applicaiton. In this case we would like some code to be executed when a user clicks on a button, or when I want to log some informaiton but cannot at the moment specify how it would be logged.<\/p>\n
Three Steps to Using a Delegate<\/b>
Step 1: Declaration
Step 2: Instantiation
Step 3: Invocation <\/p>\n
Declaring Delegates in C#<\/b>
Declaration of delegates determines that methods that can be referenced by the delegate. For a delegate to refer to a function, the function must have the signature of that delegate.<\/p>\n
Consider the example:<\/i>
public delegate int SomeDelegate (string );<\/p>\n
The delegate declare above can be used to reference any function that has a single string parameter and returns an int type variable.
The syntax for delegate declaration is :<\/p>\n
delegate return-type identifier ([parameters]);<\/p>\n
where:
return-type: <\/b>The return type  which has to be the same as the return type of the function
identifier: <\/b>Name of the delegate
parameters<\/b>: The parameters to the function<\/p>\n
Instatiating Delegates<\/b>
After a delegate have been declared, a delegate object msut be created with the new keyword and be associated with the a particular method. When creating a delegate, the argument passed to the new expression is written similar to a function call, but without arguments to the function.
For example:<\/p>\n
public delegate void writeString(string s);<\/p>\n
writeString d1 = new writeString(ToScreen);
writeString d2 = new writeString(ToFile);<\/p>\n
In the above example, a delegate called writeString() is delared that takes a single string.
The we instantiate two delegates d1 and d2 using  <\/p>\n
The function below illustrates how to delare, instantiate and use delegates to reference functions that take int values and returns int values.<\/p>\n
\n
    class<\/span> Program
    {
        static<\/span> int<\/span> num = 10;
        delegate<\/span> int<\/span> NumDelegate(int<\/span> n); <\/code>\/\/DECLARE A DELEGATE NumDelegage<\/span><\/code>
        public<\/span> static<\/span> int<\/span> Add(int<\/span> val1)
        {
            num = num + val1;
            return<\/span> num;
        }
        public<\/span> static<\/span> int<\/span> Mult(int<\/span> val2)
        {
            num = num + val2;
            return<\/span> num;
        }
        public<\/span> static<\/span> int<\/span> getNum()
        {
            return<\/span> num;
        }
        static<\/span> void<\/span> Main(string<\/span>[] args)
        {
            \/\/CREATE THREE NEW DELEGATE INSTANCES<\/span>
            NumDelegate nd;
            NumDelegate nd1 = new<\/span> NumDelegate(Add);
            NumDelegate nd2 = new<\/span> NumDelegate(Mult);<\/code><\/pre>\n
 <\/code><\/pre>\n
            nd = nd1;  <\/code>\/\/nd1 PERFORMES Add(5) GIVING 15<\/span><\/code>
            nd = nd + nd2; \/\/nd2 PERFORMS Mult(10) GIVIN 50

            \/\/MULTICASTING (EXPLAINED BELOW)<\/span>
            nd(5);
            Console.WriteLine(\"Value of Num: {0}\"<\/span>, getNum());
            Console.ReadKey();
        }
    }<\/code><\/pre>\n
\n
In the above code, a delegate is created called NumDelegate that would point to a method that takes an integer parameter.
In the main program, three delegates are instantiated nd, nd1 and nd2.
At the end of the program the output would be 65.
Part 2: Multicast<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
A delegate in C# can be conpared to a function pointer in C and C++. It allows programmers to specify what the funtion to be … <\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_mi_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0},"categories":[363,414],"tags":[],"_links":{"self":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/164"}],"collection":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/comments?post=164"}],"version-history":[{"count":1,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/164\/revisions"}],"predecessor-version":[{"id":1436,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/posts\/164\/revisions\/1436"}],"wp:attachment":[{"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/media?parent=164"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/categories?post=164"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/kindsonthegenius.com\/blog\/wp-json\/wp\/v2\/tags?post=164"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}