Delegates

Delegates

class Program     {         public delegate void SomeMethodPtr();         static void Main(string[] args)         {             SomeMethodPtr obj = new SomeMethodPtr(SomeMethod);             obj();  //or obj.Invoke();             Console.ReadLine();         }         static void SomeMethod()         {             Console.WriteLine("Some method called");         }     }

When we can call a method directly, what is the use of calling a method indirectly? Basically, a delegate is a representative to communicate between 2 parties.

The actual use of delegates is callback

public class MyClass  {   public delegate void MyDelegate(int input);   public void LongRunningMethod(MyDelegate _delegate)     {       for (int i = 0; i < 2000; i++)        {         _delegate(i);         }     }  }

static void XyzMethod(int i) {            Console.WriteLine(i); } static void Main(string[] args) {  MyClass obj = new MyClass();          obj.LongRunningMethod(XyzMethod);  Console.ReadLine(); }

In this example, we can pass data between the caller and the program with the help of delegates.

Delegates are used by framework writes so that custom logic can be injected at the time of code.

Delegate,  Anonymous Method, Action, Func, Predicate

class Program     {         static double fn_Prodvalues(int val1, int val2)         {             return val1 * val2;         }         static void Main(string[] args)         {             Delegate_Prod dpObj; double result=0;             dpObj = new Delegate_Prod(fn_Prodvalues);    // Delegate             result = dpObj(5, 6);             dpObj = delegate(int x, int y) { return x * y; };    // Anonymous Method  --introduced in c# 2.0             result = dpObj(9, 6);             dpObj = (x, y) => x * y;  // Lambda Expression -- Introduced in c# 3.0             result = dpObj(7, 8);             //Action<T>  no return type             Action<int,int> action=delegate(int x, int y){Console.WriteLine(x*y);};             Action<int, int> action2 = (x, y) => Console.WriteLine(x*y); ;             action2(4, 4);             //Func<T,out TResult> has a return type             Func<int, int, int> func = (x, y) => x * y;             result = func(5, 6);             //Predicate<T> T is the input type, and it returns back only boolean             Predicate<int> predicate = delegate(int x) { return x > 10; };             Predicate<int> predicate2 = x => x > 10;             Console.WriteLine(predicate(9));                Console.WriteLine(result);             Console.ReadKey();         }     }

Another example

static void Main(string[] args)         {             List<int> lst = new List<int>() { 2, 3, 4, 5, 6, 7, 4, 3, 45, 6 };             //IEnumerable<int>result= lst.Where(x=>x>5);             IEnumerable<int> result = lst.Where(fc); // Both Methods work         }         static Func<int, bool> fc = delegate(int c) { return c > 5; };

Extension Methods

An extension method is a static method of a static class, where the "this" modifier is applied to the first parameter

using System; namespace ExtensionMethodsExample {    public static class Extension     {        public static int WordCount(this string str)        {            string[] userString = str.Split(new char[] { ' ', '.', '?' },                                        StringSplitOptions.RemoveEmptyEntries);            int wordCount = userString.Length;            return wordCount;        }     } }

An extension method having the same name and signature like as an instance method will never be called since it has low priority than instance method.

An extension method couldn't override the existing instance methods.

An extension method cannot be used with fields, properties or events.

The compiler doesn't cause an error if two extension methods with same name and signature are defined in two different namespaces and these namespaces are included in same class file using directives. Compiler will cause an error if you will try to call one of them extension method.