This document discusses delegates in C#, which are similar to function pointers in C/C++. Delegates allow methods to be passed as arguments and stored for later invocation. The document explains that delegates store references to methods, can reference static or instance methods, and are type-safe. It also covers declaring delegates, instantiating delegates by storing method references, and using single-cast versus multi-cast delegates which can store references to multiple methods and invoke them in sequence.

1. C# Tutorial
Part 30 :Delegation
www.siri-kt.blogspot.com

2. • In C#, delegate is a reference to the method. It works
like function pointer in C and C++. But it is objected-
oriented, secured and type-safe than function pointer.
• For static method, delegate encapsulates method only. But
for instance method, it encapsulates method and instance
both.
• delegates stores the address of one or many functions
delegates hides the actual information.
• The best use of delegate is to use as event.
• Internally a delegate declaration defines a class which is the
derived class of System.Delegate.
• note:
• What is Delegates in C # Delegate is the special type use
to hold the reference of function ,Delegate concept match
the function pointer concept of c language

3. • C# delegates are similar to pointers to functions, in C or C++.
A delegate is a reference type variable that holds the
reference to a method. The reference can be changed at
runtime.
• Delegates are especially used for implementing events and
the call-back methods. All delegates are implicitly derived
from the System.Delegate class.
• Declaring Delegates
• Delegate declaration determines the methods that can be
referenced by the delegate. A delegate can refer to a
method, which has the same signature as that of the
delegate.
• For example, consider a delegate:
• public delegate int MyDelegate (string s);The preceding
delegate can be used to reference any method that has a
singlestring parameter and returns an int type variable.

4. • Syntax for delegate declaration is:
• Delegate <return type> <delegate-name> <parameter
list>Instantiating Delegates
• Once a delegate type is declared, a delegate object must be
created with thenew keyword and be associated with a
particular method.
• When creating a delegate, the argument passed to
the new expression is written similar to a method call, but
without the arguments to the method. For example:
• public delegate void printString(string s); ... printString ps1 =
new printString(WriteToScreen); printString ps2 = new
printString(WriteToFile);
• Following example demonstrates declaration, instantiation,
and use of a delegate that can be used to reference methods
that take an integer parameter and returns an integer value.

5. • Delegates are classified into 2 types
• 1.single cast delegate
• 2.multi cast delegate
• Here we can follow 4 steps to create a delegate
• 1.write a class with methods
• 2.create a delegate
• syntax: public delegate void dname();
• 3.stores the address of method
• dname d=new dname(stores fn address);
• 4.call the delegate variable
• d();

6. • 1.single cast delegate:
• The single cast delegate holds only one function address. depending on the function
prototype we have to declare delegate. in each delegate instance variable we can
stores one function address.
• example on single cast delegate example:
• using System;
• namespace ConsoleApplication21
• { class test//class
• { public void print()//method
• { Console.WriteLine("helloworld");
• Console.ReadLine(); }
• public delegate void dname();//declare delegate
• static void Main(string[] args)
• { test obj = new test();//object
• // obj.print();
• dname d = new dname(obj.print);//stores the fn address
• d();//call the delegate varibale
• } } }

7. • Multi cast delegate :
It holds the address of more than one function also. multi cast delegate supports
arithmatic + and – operations + operator is used to add a function into the sequence.
• - operator is used to Remove a function from the sequence.
• example on multi cast delegate:
• using System;
• using System.Collections.Generic;
• using System.Linq;
• using System.Text;
• using System.Threading.Tasks;
• namespace multicastdelegateexample
• { class emp//class name
• { public void esal()//method1
• { Console.WriteLine("from esal");
• Console.ReadLine(); }
• public void tsal()//method1
• { Console.WriteLine("from tsal");
• Console.ReadLine(); }

8. • Multicasting of a Delegate
• Delegate objects can be composed using the "+"
operator. A composed delegate calls the two
delegates it was composed from. Only delegates of
the same type can be composed.
• The "-" operator can be used to remove a
component delegate from a composed delegate.
• Using this property of delegates you can create an
invocation list of methods that will be called when a
delegate is invoked. This is called multicasting of a
delegate.

9. • public delegate void dname();//declare delagate
• static void Main(string[] args)
• { emp obj = new emp();//object
• dname d1 = new dname(obj.esal);//stores fn1 address
• // d1();
• dname d2 = new dname(obj.tsal);//stores fn2
address
• // d2();
• dname d3;
• // d3 = d1 - d2;
• d3 = d1 + d2;//multi cast delegate
• d3();//call the delegate variable
• } } }

10. For more visit our website www.siri-kt.blogspot.com
Thanks for
Watching
More Angular JS TutorialsMore C sharp (c#) tutorials