Delegates – LearnC#WithDarko

TagDelegates

Events

Events allow us two things:

If something important has occurred object notifies its subscribers about that occurrence.
Objects that listen to another object are notified about changes of that object.

To declare event, you use event keyword followed by the type of delegate for the event, meaning we have to declare delegate before we can use event.

Typically, to raise an event, you would use protected void method. Name of that method by convention goes should be like this: OnEventName. Method should raise event and provide two parameters object and EventArgs. Delegate upon whose type event uses should have two parameters: Object parameter is usually named sender and EventArgs parameter is named args. sender parameter is the source of the event. You should use EventArgs if you do not intend to send any parameters to subscriber, if on the other hand you wish to supply parameters create an class that inherits from from EventArgs and use that class as an parameter.

Example:

Lets create an application that is used to insert an employee to database. Upon inserting and after inserting few people should be notified, meaning we will have two events.

First, when we start inserting employee in database, we will notify our System Administrator that process of inserting has started. Also we will provide Sys Admin with DateTime value which will represent time when insert operation has started.
Second, after employee has been inserted in database, CEO, Website and System Admin will be notified.

using System;
using System.Threading;

namespace Events
{
    #region Delegates
    public delegate void NewEmployeeInsertedEventHandler(object source, EventArgs args);
    public delegate void NewEmployeeInsertingEventHandler(object source, EmployeeEventArgs args);
    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            HRDepartment hr = new HRDepartment();
            SystemAdmin sysAdmin = new SystemAdmin();
            Ceo ceo = new Ceo();
            WebSite webSite = new WebSite();
            Employee newEmployee = new Employee() {Id = 1000, Name = "John Doe", Age = 25, Salary = 1000, YearsEmployed = 0};

            // Subscribing SysAdmin to NewEmployeeInserting event
            hr.NewEmployeeInserting += sysAdmin.OnNewEmployeeInserting;

            // Subscribing subscribers to NewEmployeeInserted event
            hr.NewEmployeeInserted += sysAdmin.OnNewEmployeeInserted;
            hr.NewEmployeeInserted += ceo.OnNewEmployeeInserted;
            hr.NewEmployeeInserted += webSite.OnNewEmployeeInserted;

            // By calling InsertNewEmployee, few thing will happen:
            // 1. Process of inserting employee will start
            // 2. SysAdmin will be notiffied that process of inserting has started
            // 1. Employees information will be inserted in database
            // 1. All subscribers will be notified that employee has been inserted
            hr.InsertNewEmployee(newEmployee);

            Console.ReadKey();
        }
    }

    public class HRDepartment
    {
        // Events
        public event NewEmployeeInsertedEventHandler NewEmployeeInserted;
        public event NewEmployeeInsertingEventHandler NewEmployeeInserting;

        public void InsertNewEmployee(Employee employee)
        {
            Console.WriteLine("Inserting new employee in database...");
            // Firing NewEmployeeInserting event
            OnEmployeeInserting();

            // TODO insert new employee in database
            // Because there is no logic to insert our employee
            // into database we are simulating wait time
            Thread.Sleep(3500);

            Console.WriteLine("New employee has been successfully inserted.");

            // Firing NewEmployeeInserted event
            OnNewEmployeeInserted();
        }

        protected virtual void OnNewEmployeeInserted()
        {
            // Checking if there are any subscribers to our event
            if (NewEmployeeInserted != null)
            {
                // as parameters whe are sending 
                // this instance of a class
                // and no EventArgs
                NewEmployeeInserted(this, EventArgs.Empty);
            }
        }

        protected virtual void OnEmployeeInserting()
        {
            if (NewEmployeeInserting != null)
            {
                // as parameters we are sending 
                // this instance of a class
                // and EmployeeEventArgs instance with DateTime value
                NewEmployeeInserting(this, new EmployeeEventArgs() {TimeOfInserting = DateTime.Now});
            }
        }
    }

    public class Employee
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public int YearsEmployed { get; set; }
        public double Salary { get; set; }
    }

    public class EmployeeEventArgs : EventArgs
    {
        // DateTime value that will be shown while
        // inserting new employee
        public DateTime TimeOfInserting { get; set; }
    }

    public class Ceo
    {
        // Method signature must match delegate NewEmployeeInsertedEventHandler
        public void OnNewEmployeeInserted(object source, EventArgs args)
        {
            Console.WriteLine("Ceo notified about new employee.");
        }
    }

    public class WebSite
    {
        // Method signature must match delegate NewEmployeeInsertedEventHandler
        public void OnNewEmployeeInserted(object source, EventArgs args)
        {
            Console.WriteLine("WebSite notified about new employee.");
        }
    }

    // Because SysAdmin is subscribed to two events that consume two diferent delegates
    // we need two different methods for subscription
    public class SystemAdmin
    {
        // Method signature must match delegate NewEmployeeInsertingEventHandler
        public void OnNewEmployeeInserting(object source, EmployeeEventArgs args)
        {
            Console.WriteLine("Notification to SysAdmin: A new employee is beeing created {0}", args.TimeOfInserting);
        }

        // Method signature must match delegate NewEmployeeInsertedEventHandler
        public void OnNewEmployeeInserted(object source, EventArgs args)
        {
            Console.WriteLine("SysAdmin notified about new employee.");
        }
    }

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

using System;

using System.Threading;

namespace Events

{

#region Delegates

public delegate void NewEmployeeInsertedEventHandler(object source, EventArgs args);

public delegate void NewEmployeeInsertingEventHandler(object source, EmployeeEventArgs args);

#endregion

class Program

{

static void Main(string[] args)

{

HRDepartment hr = new HRDepartment();

SystemAdmin sysAdmin = new SystemAdmin();

Ceo ceo = new Ceo();

WebSite webSite = new WebSite();

Employee newEmployee = new Employee() {Id = 1000, Name = "John Doe", Age = 25, Salary = 1000, YearsEmployed = 0};

// Subscribing SysAdmin to NewEmployeeInserting event

hr.NewEmployeeInserting += sysAdmin.OnNewEmployeeInserting;

// Subscribing subscribers to NewEmployeeInserted event

hr.NewEmployeeInserted += sysAdmin.OnNewEmployeeInserted;

hr.NewEmployeeInserted += ceo.OnNewEmployeeInserted;

hr.NewEmployeeInserted += webSite.OnNewEmployeeInserted;

// By calling InsertNewEmployee, few thing will happen:

// 1. Process of inserting employee will start

// 2. SysAdmin will be notiffied that process of inserting has started

// 1. Employees information will be inserted in database

// 1. All subscribers will be notified that employee has been inserted

hr.InsertNewEmployee(newEmployee);

Console.ReadKey();

}

public class HRDepartment

{

// Events

public event NewEmployeeInsertedEventHandler NewEmployeeInserted;

public event NewEmployeeInsertingEventHandler NewEmployeeInserting;

public void InsertNewEmployee(Employee employee)

{

Console.WriteLine("Inserting new employee in database...");

// Firing NewEmployeeInserting event

OnEmployeeInserting();

// TODO insert new employee in database

// Because there is no logic to insert our employee

// into database we are simulating wait time

Thread.Sleep(3500);

Console.WriteLine("New employee has been successfully inserted.");

// Firing NewEmployeeInserted event

OnNewEmployeeInserted();

}

protected virtual void OnNewEmployeeInserted()

{

// Checking if there are any subscribers to our event

if (NewEmployeeInserted != null)

{

// as parameters whe are sending

// this instance of a class

// and no EventArgs

NewEmployeeInserted(this, EventArgs.Empty);

}

protected virtual void OnEmployeeInserting()

{

if (NewEmployeeInserting != null)

{

// as parameters we are sending

// this instance of a class

// and EmployeeEventArgs instance with DateTime value

NewEmployeeInserting(this, new EmployeeEventArgs() {TimeOfInserting = DateTime.Now});

}

public class Employee

{

public int Id { get; set; }

public string Name { get; set; }

public int Age { get; set; }

public int YearsEmployed { get; set; }

public double Salary { get; set; }

}

public class EmployeeEventArgs : EventArgs

{

// DateTime value that will be shown while

// inserting new employee

public DateTime TimeOfInserting { get; set; }

}

public class Ceo

{

// Method signature must match delegate NewEmployeeInsertedEventHandler

public void OnNewEmployeeInserted(object source, EventArgs args)

{

Console.WriteLine("Ceo notified about new employee.");

}

public class WebSite

{

// Method signature must match delegate NewEmployeeInsertedEventHandler

public void OnNewEmployeeInserted(object source, EventArgs args)

{

Console.WriteLine("WebSite notified about new employee.");

}

// Because SysAdmin is subscribed to two events that consume two diferent delegates

// we need two different methods for subscription

public class SystemAdmin

{

// Method signature must match delegate NewEmployeeInsertingEventHandler

public void OnNewEmployeeInserting(object source, EmployeeEventArgs args)

{

Console.WriteLine("Notification to SysAdmin: A new employee is beeing created {0}", args.TimeOfInserting);

}

// Method signature must match delegate NewEmployeeInsertedEventHandler

public void OnNewEmployeeInserted(object source, EventArgs args)

{

Console.WriteLine("SysAdmin notified about new employee.");

}

You can also download entire solution for easier readability.

If you prefer using Action delegate instead of declaring delegates you can easily doe that. Just replace following code in HRDepartment class:

// Events
// comment following two lines
//public event NewEmployeeInsertedEventHandler NewEmployeeInserted;
//public event NewEmployeeInsertingEventHandler NewEmployeeInserting;

// and insert these two lines
public event Action<object, EventArgs> NewEmployeeInserted;
public event Action<object, EmployeeEventArgs> NewEmployeeInserting;

// Events

// comment following two lines

//public event NewEmployeeInsertedEventHandler NewEmployeeInserted;

//public event NewEmployeeInsertingEventHandler NewEmployeeInserting;

// and insert these two lines

public event Action<object, EventArgs> NewEmployeeInserted;

public event Action<object, EmployeeEventArgs> NewEmployeeInserting;

For now we will finish our journey with Delegates and return to Reflection.

Lambda expressions

13/09/2016 / Darko / 0 Comments

A lambda expressions are an anonymous function that helps us write easy to read code.

Let’s see how we can achieve this. First we will take example from previous post about anonymous methods:

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y) { return x + y; };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y) { return x + y; };

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

We can simplify this code by removing delegate keyword and inserting => operator between anonymous method’s parameters and statement.

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) => { return x + y; };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) => { return x + y; };

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

How do you pronounce => operator?

There are quite a few names for => operator. Here are a few typical names:

Goes to
Maps
Such that
Becomes

Lambda expressions do not look like a easier way to write delegates, can we for example remove delegate declaration?

You are correct. We can simplify thing even more with Action and Func.

Action

Action is a generic delegate type that describes a method that does not return a value. Action can have 16 overloads, of which not a single one describes a return type. You can picture action like a method with a void return type.

Action example

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        //public delegate void SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            //SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) =>
            //{
            //    int sumTwoNumbers = x + y;
            //    Console.WriteLine(sumTwoNumbers);
            //};

            Action<int, int> sumOfTwoNumber = (int x, int y) =>
            {
                int sumTwoNumbers = x + y;
                Console.WriteLine(sumTwoNumbers);
            };

            sumOfTwoNumber(2, 2);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

//public delegate void SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

//SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) =>

//{

// int sumTwoNumbers = x + y;

// Console.WriteLine(sumTwoNumbers);

//};

Action<int, int> sumOfTwoNumber = (int x, int y) =>

{

int sumTwoNumbers = x + y;

Console.WriteLine(sumTwoNumbers);

};

sumOfTwoNumber(2, 2);

}

Code here is not deleted but commented out for you to see benefits of using Action. First of we do not need to declare delegate and lastly because we do not need to declare delegate we are free to decide upon our types while writing an Action.

Func

Func is a generic delegate type that describes a method that has an return a value. Func can have 17 overloads, but note that last type is your return type.

Func Example

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        //public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            //SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) => { return x + y; };
            Func<int, int, int> sumOfTwoNumber = (int x, int y) => { return x + y; };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

//public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

//SumTwoNumberDelegate sumOfTwoNumber = (int x, int y) => { return x + y; };

Func<int, int, int> sumOfTwoNumber = (int x, int y) => { return x + y; };

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

Same as Action but note, that when looking at our sumOfTwoNumber Func, third int type is our return type.

We will now continue our journey with delegates by learning about events.

Anonymous methods

13/09/2016 / Darko / 0 Comments

Anonymous methods allow us to create delegate methods inline.

What does that mean?

Let’s create a simple delegate whose role is to sum two numbers:

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = new SumTwoNumberDelegate(SumTwoNumber);
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }

        private static int SumTwoNumber(int x, int y)
        {
            return x + y;
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = new SumTwoNumberDelegate(SumTwoNumber);

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

private static int SumTwoNumber(int x, int y)

{

return x + y;

}

Would not it be nice if we could get rid of the SumTwoNumber method and just write it’s content while we instantiate delegate ? Yes it would and we can do it! Steps are:

While instantiating your delegate, remove new… part.
Write delegate keyword followed by input parameter in round brackets.
Type your code inside curly brackets.

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y) { return x + y; };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y) { return x + y; };

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

What we essentially did is we created a method without method name and thus we created anonymous method. Don’t believe me? Look again at the same code that has been reformatted a bit:

using System;

namespace AnonymousMethodsTutorial
{
    class Program
    {
        public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);
        static void Main(string[] args)
        {
            SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y)
            {
                return x + y;
            };
            int sum = sumOfTwoNumber(2, 2);
            Console.WriteLine(sum);
        }
    }
}

using System;

namespace AnonymousMethodsTutorial

{

class Program

{

public delegate int SumTwoNumberDelegate(int numberOne, int numberTwo);

static void Main(string[] args)

{

SumTwoNumberDelegate sumOfTwoNumber = delegate (int x, int y)

{

return x + y;

};

int sum = sumOfTwoNumber(2, 2);

Console.WriteLine(sum);

}

When you mentioned we can write delegate methods inline, does that mean we can write methods in one line only?

No, you can write as many lines as you want. Notice semicolon (;) on line 12, you can write additional code below. But beware of that feature, because if you write too many lines whole purpose of anonymous methods disappears and that is readability. Generally you would like to keep it to 1-3 lines, more than that would best be very good candidate for standalone method.

How do i know which parameters and return types to use wile writing an anonymous methods?

Your delegate tells you that information. In our example SumTwoNumberDelegate delegate expects return type int and two int input parameters, so that is what we provided him within anonymous method.

Anonymous methods are awesome! Are there any drawbacks to using them?

You would normally use delegate, instead of method, if you do not intend to use a function multiple times. On the other hand it makes no sense to write same anonymous method multiple times if you can reuse one method + it is easier to maintain that one method than multiple anonymous methods.

Can i make my code even simpler?

Yes you can, by using lambda expressions!

Delegates part 2 Multicast Delegate

26/08/2016 / Darko / 2 Comments

A useful feature of delegates is that delegates can point to more than one method. A delegate that points to multiple methods is called Multicast Delegate. When invoking Multicast Delegate all methods that he points to are invoked. We add methods to delegate by using + or += operator. Methods can be removed from delegate by using – or -= operators.

When delegate has return type void, all methods are executed. The same is with all other return types. Difference is that when return type is not void, we will receive only value of last method executed.

Examples of Multicast Delegate using void return type:

Add methods to delegate by using + operator

We will create console application that will print content of four methods by using delegates.

public delegate void VoidDelegate();

class App
{
    private static void Main()
    {
        VoidDelegate voidDelegate1, voidDelegate2, voidDelegate3, voidDelegate4, voidDelegate5;

        voidDelegate1 = new VoidDelegate(ShowMessageOne);
        voidDelegate2 = new VoidDelegate(ShowMessageTwo);
        voidDelegate3 = new VoidDelegate(ShowMessageThree);
        voidDelegate4 = new VoidDelegate(ShowMessageFour);

        voidDelegate5 = voidDelegate1 + voidDelegate2 + voidDelegate3 + voidDelegate4;

        voidDelegate5();
    }

    public static void ShowMessageOne()
    {
        Console.WriteLine("ShowMessageOne method invoked.");
    }
    public static void ShowMessageTwo()
    {
        Console.WriteLine("ShowMessageTwo method invoked.");
    }
    public static void ShowMessageThree()
    {
        Console.WriteLine("ShowMessageThree method invoked.");
    }
    public static void ShowMessageFour()
    {
        Console.WriteLine("ShowMessageFour method invoked.");
    }


}

public delegate void VoidDelegate();

class App

{

private static void Main()

{

VoidDelegate voidDelegate1, voidDelegate2, voidDelegate3, voidDelegate4, voidDelegate5;

voidDelegate1 = new VoidDelegate(ShowMessageOne);

voidDelegate2 = new VoidDelegate(ShowMessageTwo);

voidDelegate3 = new VoidDelegate(ShowMessageThree);

voidDelegate4 = new VoidDelegate(ShowMessageFour);

voidDelegate5 = voidDelegate1 + voidDelegate2 + voidDelegate3 + voidDelegate4;

voidDelegate5();

}

public static void ShowMessageOne()

{

Console.WriteLine("ShowMessageOne method invoked.");

}

public static void ShowMessageTwo()

{

Console.WriteLine("ShowMessageTwo method invoked.");

}

public static void ShowMessageThree()

{

Console.WriteLine("ShowMessageThree method invoked.");

}

public static void ShowMessageFour()

{

Console.WriteLine("ShowMessageFour method invoked.");

}

First we created our new delegate VoidDelegate that has return type void and takes no input parameters. Then, inside our Main method, we defined 5 VoidDelegates, and instantiate four of the them. After we are done with instantiating 4 delegates, we assign those 4 delegates using + operator to fifth delegate. Lastly, we invoke the delegate. Console output will show all 4 ShowMessage methods results.

Remove methods from delegate by using – operator

Let’s rework our previous code so we can see example of removing methods from a delegates by using – operator. Next example will show you only Main method, because no changes are needed to be maid for ShowMessage methods.

private static void Main()
{
	VoidDelegate voidDelegate1, voidDelegate2, voidDelegate3, voidDelegate4, voidDelegate5;

	voidDelegate1 = new VoidDelegate(ShowMessageOne);
	voidDelegate2 = new VoidDelegate(ShowMessageTwo);
	voidDelegate3 = new VoidDelegate(ShowMessageThree);
	voidDelegate4 = new VoidDelegate(ShowMessageFour);

	voidDelegate5 = voidDelegate1 + voidDelegate2 + voidDelegate3 + voidDelegate4;
	voidDelegate5();

	Console.WriteLine("***");

	voidDelegate5 = voidDelegate5 - voidDelegate1;
	voidDelegate5();
}

private static void Main()

{

VoidDelegate voidDelegate1, voidDelegate2, voidDelegate3, voidDelegate4, voidDelegate5;

voidDelegate1 = new VoidDelegate(ShowMessageOne);

voidDelegate2 = new VoidDelegate(ShowMessageTwo);

voidDelegate3 = new VoidDelegate(ShowMessageThree);

voidDelegate4 = new VoidDelegate(ShowMessageFour);

voidDelegate5 = voidDelegate1 + voidDelegate2 + voidDelegate3 + voidDelegate4;

voidDelegate5();

Console.WriteLine("***");

voidDelegate5 = voidDelegate5 - voidDelegate1;

voidDelegate5();

}

First part of a code is same as in previous example, but later on we just use – operator to unsubscribe voidDelegate1 delegate (that uses ShowMessageOne method) from voidDelegate5 delegate. Note that ShowMessageOne message is not shown.

Add methods to delegate by using += operator

private static void Main()
{
	VoidDelegate voidDelegate = new VoidDelegate(ShowMessageOne);
	voidDelegate += ShowMessageTwo;
	voidDelegate += ShowMessageThree;
	voidDelegate += ShowMessageFour;

	voidDelegate();
}

private static void Main()

{

VoidDelegate voidDelegate = new VoidDelegate(ShowMessageOne);

voidDelegate += ShowMessageTwo;

voidDelegate += ShowMessageThree;

voidDelegate += ShowMessageFour;

voidDelegate();

}

Seems that += operators shortened our code and made it a lot readable. This time we needed to declare only one delegate and add methods to him by only using += operators.

Remove methods from delegate by using -= operator

private static void Main()
{
	VoidDelegate voidDelegate = new VoidDelegate(ShowMessageOne);
	voidDelegate += ShowMessageTwo;
	voidDelegate += ShowMessageThree;
	voidDelegate += ShowMessageFour;

	voidDelegate();

	Console.WriteLine("***");

	voidDelegate -= ShowMessageOne;
	voidDelegate();
}

private static void Main()

{

VoidDelegate voidDelegate = new VoidDelegate(ShowMessageOne);

voidDelegate += ShowMessageTwo;

voidDelegate += ShowMessageThree;

voidDelegate += ShowMessageFour;

voidDelegate();

Console.WriteLine("***");

voidDelegate -= ShowMessageOne;

voidDelegate();

}

Example of Multicast Delegate using string return type

public delegate string StringDelegate();

class App
{
	private static void Main()
	{
		StringDelegate stringDelegate = new StringDelegate(ShowMessageOne);
		stringDelegate += ShowMessageTwo;
		stringDelegate += ShowMessageThree;
		stringDelegate += ShowMessageFour;

		string message = stringDelegate();

		Console.WriteLine(message);
	}

	public static string ShowMessageOne()
	{
		return "ShowMessageOne method invoked.";
	}
	public static string ShowMessageTwo()
	{
		return "ShowMessageTwo method invoked.";
	}
	public static string ShowMessageThree()
	{
		return "ShowMessageThree method invoked.";
	}
	public static string ShowMessageFour()
	{
		return "ShowMessageFour method invoked.";
	}


}

public delegate string StringDelegate();

class App

{

private static void Main()

{

StringDelegate stringDelegate = new StringDelegate(ShowMessageOne);

stringDelegate += ShowMessageTwo;

stringDelegate += ShowMessageThree;

stringDelegate += ShowMessageFour;

string message = stringDelegate();

Console.WriteLine(message);

}

public static string ShowMessageOne()

{

return "ShowMessageOne method invoked.";

}

public static string ShowMessageTwo()

{

return "ShowMessageTwo method invoked.";

}

public static string ShowMessageThree()

{

return "ShowMessageThree method invoked.";

}

public static string ShowMessageFour()

{

return "ShowMessageFour method invoked.";

}

While running this app, try entering debug mode, you will see that all methods were hit but only ShowMessageFour message was sent. Remember that while consuming your delegates.

We will continue delegates discussion with Anonymous methods.

Delegates part 1

25/08/2016 / Darko / 0 Comments

A delegate is a reference type, type-safe function(method) pointer. Delegates are used to invoke the method through the delegate instance. To invoke method, delegates methods signature and return type must be same as that of a delegate.

You declare delegate similar to declaring the method:

public delegate void MyFirstDelegate(string parameterName);

1	public delegate void MyFirstDelegate(string parameterName);

How do we use delegates?

Lets create simple console application that will use method to display value:

class App
{
    static void Main()
    {
        PrintMessage("Hello World!");
    }

    public static void PrintMessage(string message)
    {
        Console.WriteLine(message);
    }
}

class App

{

static void Main()

{

PrintMessage("Hello World!");

}

public static void PrintMessage(string message)

{

Console.WriteLine(message);

}

This class does its intended yob nicely, but we can expand it by adding delegate. First we must declare delegate outside our class and instantiate our newly created delegate inside Main method then we can use our delegate to pass the value to our function.

public delegate void MyFirstDelegate(string parameterName);

class App
{
	static void Main()
	{
		MyFirstDelegate del = new MyFirstDelegate(PrintMessage);
		del("Hello World!");
	}

	public static void PrintMessage(string message)
	{
		Console.WriteLine(message);
	}
}

public delegate void MyFirstDelegate(string parameterName);

class App

{

static void Main()

{

MyFirstDelegate del = new MyFirstDelegate(PrintMessage);

del("Hello World!");

}

public static void PrintMessage(string message)

{

Console.WriteLine(message);

}

Q: This look very complicated process just to invoke function. Why would i ever need to use delegates?

A: Yes it takes some extra work to create delegates but in next example you will see where delegates make much more sense.

Why do we use delegates?

Imagine that you need to create application for HR department and in that application you need to predict salary increase for employees that are employed full-time in that company. You would create application that behaves like this:

class App
{
    static void Main()
    {
        List<Employee> listOfEmployees = new List<Employee>();
        listOfEmployees.Add(new Employee() { Id = 1, FirstName = "John", LastName = "Doe", Salary = 5000.68, YearsEmployed = 3, IsFullTime = true});
        listOfEmployees.Add(new Employee() { Id = 2, FirstName = "Jane", LastName = "Doe", Salary = 6990.11, YearsEmployed = 1, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 3, FirstName = "Tommy", LastName = "Atkins", Salary = 4500, YearsEmployed = 4, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 4, FirstName = "Richard", LastName = "Roe", Salary = 4500, YearsEmployed = 1, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 5, FirstName = "Janie ", LastName = "Smith", Salary = 10025.33, YearsEmployed = 6, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 6, FirstName = "John", LastName = "Doe", Salary = 26500.83, YearsEmployed = 2, IsFullTime = true });

        Employee printEmployees = new Employee();
        printEmployees.NextYearSalary(listOfEmployees);
    } 
}
public class Employee
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public double Salary { get; set; }
    public int YearsEmployed { get; set; }
    public bool IsFullTime { get; set; }

    public void NextYearSalary(List<Employee> employees)
    {
        foreach (var employee in employees)
        {
            if (employee.IsFullTime)
            {
                double salaryMultiplyer = employee.YearsEmployed * 0.01;
                double expectedSalary = employee.Salary * salaryMultiplyer;
                Console.WriteLine(string.Format("Expected salary increase for employee: {0} {1} is: {2}$", employee.FirstName, employee.LastName, expectedSalary));
            }
        }
    }

}

class App

{

static void Main()

{

List<Employee> listOfEmployees = new List<Employee>();

listOfEmployees.Add(new Employee() { Id = 1, FirstName = "John", LastName = "Doe", Salary = 5000.68, YearsEmployed = 3, IsFullTime = true});

listOfEmployees.Add(new Employee() { Id = 2, FirstName = "Jane", LastName = "Doe", Salary = 6990.11, YearsEmployed = 1, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 3, FirstName = "Tommy", LastName = "Atkins", Salary = 4500, YearsEmployed = 4, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 4, FirstName = "Richard", LastName = "Roe", Salary = 4500, YearsEmployed = 1, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 5, FirstName = "Janie ", LastName = "Smith", Salary = 10025.33, YearsEmployed = 6, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 6, FirstName = "John", LastName = "Doe", Salary = 26500.83, YearsEmployed = 2, IsFullTime = true });

Employee printEmployees = new Employee();

printEmployees.NextYearSalary(listOfEmployees);

}

public class Employee

{

public int Id { get; set; }

public string FirstName { get; set; }

public string LastName { get; set; }

public double Salary { get; set; }

public int YearsEmployed { get; set; }

public bool IsFullTime { get; set; }

public void NextYearSalary(List<Employee> employees)

{

foreach (var employee in employees)

{

if (employee.IsFullTime)

{

double salaryMultiplyer = employee.YearsEmployed * 0.01;

double expectedSalary = employee.Salary * salaryMultiplyer;

Console.WriteLine(string.Format("Expected salary increase for employee: {0} {1} is: {2}$", employee.FirstName, employee.LastName, expectedSalary));

}

Here we have Employee class that has necessary properties and NextYearSalary method. NextYearSalary that takes List of Employees and checks each employee for his IsFullTime status, if that status is true then it multiplies employees years of service in company with 1% then multiplies it again with current salary. That way we get potential salary increase and print it to the console. We compile our program and ship it to all companies that use our application.

After some time we receive request from another company. Other company wants to see potential salary increase not for its full time employees but for those employees who have worked there for at least 3 years.

We could expand NextYearSllary method to accommodate that request or create another method only for that company, but these two approaches are not good solution for our problem because we always tend to have clean code and because second approach breaks DRY principle. Instead we will use delegates:

public delegate bool SalaryIncreaseDelegate(Employee empl);

class App
{
    static void Main()
    {
        List<Employee> listOfEmployees = new List<Employee>();
        listOfEmployees.Add(new Employee() { Id = 1, FirstName = "John", LastName = "Doe", Salary = 5000.68, YearsEmployed = 3, IsFullTime = false });
        listOfEmployees.Add(new Employee() { Id = 2, FirstName = "Jane", LastName = "Doe", Salary = 6990.11, YearsEmployed = 3, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 3, FirstName = "Tommy", LastName = "Atkins", Salary = 4500, YearsEmployed = 3, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 4, FirstName = "Richard", LastName = "Roe", Salary = 4500, YearsEmployed = 3, IsFullTime = false });
        listOfEmployees.Add(new Employee() { Id = 5, FirstName = "Janie ", LastName = "Smith", Salary = 10025.33, YearsEmployed = 3, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 6, FirstName = "John", LastName = "Doe", Salary = 26500.83, YearsEmployed = 3, IsFullTime = true });

        SalaryIncreaseDelegate potentialSalaryIncrease = new SalaryIncreaseDelegate(PotentialSalaryIncreaseForFullTimeEmployees);

        Employee printEmployees = new Employee();
        printEmployees.NextYearSalary(listOfEmployees, potentialSalaryIncrease);
    }

    public static bool PotentialSalaryIncreaseForFullTimeEmployees(Employee empl)
    {
        if (empl.IsFullTime)
            return true;
        else
            return false;
    }
}
public class Employee
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public double Salary { get; set; }
    public int YearsEmployed { get; set; }
    public bool IsFullTime { get; set; }

    public void NextYearSalary(List<Employee> employees, SalaryIncreaseDelegate salaryIncreaseDelegate)
    {
        foreach (var employee in employees)
        {
            if (salaryIncreaseDelegate(employee))
            {
                double salaryMultiplyer = employee.YearsEmployed * 0.01;
                double expectedSalary = employee.Salary * salaryMultiplyer;
                Console.WriteLine(string.Format("Expected salary increase for employee: {0} {1} is: {2}$", employee.FirstName, employee.LastName, expectedSalary));
            }
        }
    }

}

public delegate bool SalaryIncreaseDelegate(Employee empl);

class App

{

static void Main()

{

List<Employee> listOfEmployees = new List<Employee>();

listOfEmployees.Add(new Employee() { Id = 1, FirstName = "John", LastName = "Doe", Salary = 5000.68, YearsEmployed = 3, IsFullTime = false });

listOfEmployees.Add(new Employee() { Id = 2, FirstName = "Jane", LastName = "Doe", Salary = 6990.11, YearsEmployed = 3, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 3, FirstName = "Tommy", LastName = "Atkins", Salary = 4500, YearsEmployed = 3, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 4, FirstName = "Richard", LastName = "Roe", Salary = 4500, YearsEmployed = 3, IsFullTime = false });

listOfEmployees.Add(new Employee() { Id = 5, FirstName = "Janie ", LastName = "Smith", Salary = 10025.33, YearsEmployed = 3, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 6, FirstName = "John", LastName = "Doe", Salary = 26500.83, YearsEmployed = 3, IsFullTime = true });

SalaryIncreaseDelegate potentialSalaryIncrease = new SalaryIncreaseDelegate(PotentialSalaryIncreaseForFullTimeEmployees);

Employee printEmployees = new Employee();

printEmployees.NextYearSalary(listOfEmployees, potentialSalaryIncrease);

}

public static bool PotentialSalaryIncreaseForFullTimeEmployees(Employee empl)

{

if (empl.IsFullTime)

return true;

else

return false;

}

public class Employee

{

public int Id { get; set; }

public string FirstName { get; set; }

public string LastName { get; set; }

public double Salary { get; set; }

public int YearsEmployed { get; set; }

public bool IsFullTime { get; set; }

public void NextYearSalary(List<Employee> employees, SalaryIncreaseDelegate salaryIncreaseDelegate)

{

foreach (var employee in employees)

{

if (salaryIncreaseDelegate(employee))

{

double salaryMultiplyer = employee.YearsEmployed * 0.01;

double expectedSalary = employee.Salary * salaryMultiplyer;

Console.WriteLine(string.Format("Expected salary increase for employee: {0} {1} is: {2}$", employee.FirstName, employee.LastName, expectedSalary));

}

First wee took a look in NextYearSalary method. Inside our foreach loop we found if statement that needed to be changed. If statement is a boolean and checks Employee object so we created delegate that returns bool value and takes Employee object as a parameter. Now we needed to create method that matches that signature, so we created PotentialSalaryIncreaseForFullTimeEmployees method in our Main method. Next step was to expand signature of NextYearSalary method with SalaryIncreaseDelegate delegate and replace condition of if statement with our delegates variable. Lastly, we call of NextYearSalary method in Main method with missing delegate variable.

Exercise 1:

Try to create method that:

can be used for SalaryIncreaseDelegate
can decide which Employees next years potential salaries will be displayed using NextYearSalary method for those employees that have worked in company at least 3 years.

public delegate bool SalaryIncreaseDelegate(Employee empl);
class App
{
	static void Main()
	{
		List<Employee> listOfEmployees = new List<Employee>();
		listOfEmployees.Add(new Employee() { Id = 1, FirstName = "John", LastName = "Doe", Salary = 5000.68, YearsEmployed = 3, IsFullTime = true });
		listOfEmployees.Add(new Employee() { Id = 2, FirstName = "Jane", LastName = "Doe", Salary = 6990.11, YearsEmployed = 1, IsFullTime = true });
		listOfEmployees.Add(new Employee() { Id = 3, FirstName = "Tommy", LastName = "Atkins", Salary = 4500, YearsEmployed = 4, IsFullTime = true });
		listOfEmployees.Add(new Employee() { Id = 4, FirstName = "Richard", LastName = "Roe", Salary = 4500, YearsEmployed = 1, IsFullTime = true });
		listOfEmployees.Add(new Employee() { Id = 5, FirstName = "Janie ", LastName = "Smith", Salary = 10025.33, YearsEmployed = 6, IsFullTime = true });
		listOfEmployees.Add(new Employee() { Id = 6, FirstName = "John", LastName = "Doe", Salary = 26500.83, YearsEmployed = 2, IsFullTime = true });

		SalaryIncreaseDelegate potentialSalaryIncrease = new SalaryIncreaseDelegate(PotentialSalaryIncreaseForEmployeesWith3YearsOfService);

		Employee printEmployees = new Employee();
		printEmployees.NextYearSalary(listOfEmployees, potentialSalaryIncrease);
	}

	public static bool PotentialSalaryIncreaseForFullTimeEmployees(Employee empl)
	{
		if (empl.IsFullTime)
			return true;
		else
			return false;
	}

	public static bool PotentialSalaryIncreaseForEmployeesWith3YearsOfService(Employee empl)
	{
		if (empl.YearsEmployed >= 3)
			return true;
		else
			return false;
	}


}
public class Employee
{
	public int Id { get; set; }
	public string FirstName { get; set; }
	public string LastName { get; set; }
	public double Salary { get; set; }
	public int YearsEmployed { get; set; }
	public bool IsFullTime { get; set; }

	public void NextYearSalary(List<Employee> employees, SalaryIncreaseDelegate salaryIncreaseDelegate)
	{
		foreach (var employee in employees)
		{
			if (salaryIncreaseDelegate(employee))
			{
				double salaryMultiplyer = employee.YearsEmployed * 0.01;
				double expectedSalary = employee.Salary * salaryMultiplyer;
				Console.WriteLine(string.Format("Expected salary increase for employee: {0} {1} is: {2}$", employee.FirstName, employee.LastName, expectedSalary));
			}
		}
	}

}

public delegate bool SalaryIncreaseDelegate(Employee empl);

class App

{

static void Main()

{

List<Employee> listOfEmployees = new List<Employee>();

listOfEmployees.Add(new Employee() { Id = 1, FirstName = "John", LastName = "Doe", Salary = 5000.68, YearsEmployed = 3, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 2, FirstName = "Jane", LastName = "Doe", Salary = 6990.11, YearsEmployed = 1, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 3, FirstName = "Tommy", LastName = "Atkins", Salary = 4500, YearsEmployed = 4, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 4, FirstName = "Richard", LastName = "Roe", Salary = 4500, YearsEmployed = 1, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 5, FirstName = "Janie ", LastName = "Smith", Salary = 10025.33, YearsEmployed = 6, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 6, FirstName = "John", LastName = "Doe", Salary = 26500.83, YearsEmployed = 2, IsFullTime = true });

SalaryIncreaseDelegate potentialSalaryIncrease = new SalaryIncreaseDelegate(PotentialSalaryIncreaseForEmployeesWith3YearsOfService);

Employee printEmployees = new Employee();

printEmployees.NextYearSalary(listOfEmployees, potentialSalaryIncrease);

}

public static bool PotentialSalaryIncreaseForFullTimeEmployees(Employee empl)

{

if (empl.IsFullTime)

return true;

else

return false;

}

public static bool PotentialSalaryIncreaseForEmployeesWith3YearsOfService(Employee empl)

{

if (empl.YearsEmployed >= 3)

return true;

else

return false;

}

public class Employee

{

public int Id { get; set; }

public string FirstName { get; set; }

public string LastName { get; set; }

public double Salary { get; set; }

public int YearsEmployed { get; set; }

public bool IsFullTime { get; set; }

public void NextYearSalary(List<Employee> employees, SalaryIncreaseDelegate salaryIncreaseDelegate)

{

foreach (var employee in employees)

{

if (salaryIncreaseDelegate(employee))

{

double salaryMultiplyer = employee.YearsEmployed * 0.01;

double expectedSalary = employee.Salary * salaryMultiplyer;

Console.WriteLine(string.Format("Expected salary increase for employee: {0} {1} is: {2}$", employee.FirstName, employee.LastName, expectedSalary));

}

Exercise 2:

Try to create delegate that will emulate NextYearSalary logic for expected salary:

public delegate bool SalaryIncreaseDelegate(Employee empl);
public delegate double ExpectedSalaryDelegate(Employee empl);

class App
{
    static void Main()
    {
        List<Employee> listOfEmployees = new List<Employee>();
        listOfEmployees.Add(new Employee() { Id = 1, FirstName = "John", LastName = "Doe", Salary = 5000.68, YearsEmployed = 3, IsFullTime = false });
        listOfEmployees.Add(new Employee() { Id = 2, FirstName = "Jane", LastName = "Doe", Salary = 6990.11, YearsEmployed = 3, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 3, FirstName = "Tommy", LastName = "Atkins", Salary = 4500, YearsEmployed = 3, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 4, FirstName = "Richard", LastName = "Roe", Salary = 4500, YearsEmployed = 3, IsFullTime = false });
        listOfEmployees.Add(new Employee() { Id = 5, FirstName = "Janie ", LastName = "Smith", Salary = 10025.33, YearsEmployed = 3, IsFullTime = true });
        listOfEmployees.Add(new Employee() { Id = 6, FirstName = "John", LastName = "Doe", Salary = 26500.83, YearsEmployed = 3, IsFullTime = true });

        SalaryIncreaseDelegate potentialSalaryIncrease = new SalaryIncreaseDelegate(PotentialSalaryIncreaseForFullTimeEmployees);

        ExpectedSalaryDelegate expectedSalaryDelegate = new ExpectedSalaryDelegate(ExpectedSalaryForEmployee);

        Employee printEmployees = new Employee();
        printEmployees.NextYearSalary(listOfEmployees, potentialSalaryIncrease, expectedSalaryDelegate);
    }

    public static bool PotentialSalaryIncreaseForFullTimeEmployees(Employee empl)
    {
        if (empl.IsFullTime)
            return true;
        else
            return false;
    }

    public static double ExpectedSalaryForEmployee(Employee empl)
    {
        double salaryMultiplyer = empl.YearsEmployed * 0.01;
        return empl.Salary * salaryMultiplyer;
    }
}
public class Employee
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public double Salary { get; set; }
    public int YearsEmployed { get; set; }
    public bool IsFullTime { get; set; }

    public void NextYearSalary(List<Employee> employees, SalaryIncreaseDelegate salaryIncreaseDelegate, ExpectedSalaryDelegate expectedSalaryDelegate)
    {
        foreach (var employee in employees)
        {
            if (salaryIncreaseDelegate(employee))
            {
                double expectedSalary = expectedSalaryDelegate(employee);
                Console.WriteLine(string.Format("Expected salary increase for employee: {0} {1} is: {2}$", employee.FirstName, employee.LastName, expectedSalary));
            }
        }
    }

}

public delegate bool SalaryIncreaseDelegate(Employee empl);

public delegate double ExpectedSalaryDelegate(Employee empl);

class App

{

static void Main()

{

List<Employee> listOfEmployees = new List<Employee>();

listOfEmployees.Add(new Employee() { Id = 1, FirstName = "John", LastName = "Doe", Salary = 5000.68, YearsEmployed = 3, IsFullTime = false });

listOfEmployees.Add(new Employee() { Id = 2, FirstName = "Jane", LastName = "Doe", Salary = 6990.11, YearsEmployed = 3, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 3, FirstName = "Tommy", LastName = "Atkins", Salary = 4500, YearsEmployed = 3, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 4, FirstName = "Richard", LastName = "Roe", Salary = 4500, YearsEmployed = 3, IsFullTime = false });

listOfEmployees.Add(new Employee() { Id = 5, FirstName = "Janie ", LastName = "Smith", Salary = 10025.33, YearsEmployed = 3, IsFullTime = true });

listOfEmployees.Add(new Employee() { Id = 6, FirstName = "John", LastName = "Doe", Salary = 26500.83, YearsEmployed = 3, IsFullTime = true });

SalaryIncreaseDelegate potentialSalaryIncrease = new SalaryIncreaseDelegate(PotentialSalaryIncreaseForFullTimeEmployees);

ExpectedSalaryDelegate expectedSalaryDelegate = new ExpectedSalaryDelegate(ExpectedSalaryForEmployee);

Employee printEmployees = new Employee();

printEmployees.NextYearSalary(listOfEmployees, potentialSalaryIncrease, expectedSalaryDelegate);

}

public static bool PotentialSalaryIncreaseForFullTimeEmployees(Employee empl)

{

if (empl.IsFullTime)

return true;

else

return false;

}

public static double ExpectedSalaryForEmployee(Employee empl)

{

double salaryMultiplyer = empl.YearsEmployed * 0.01;

return empl.Salary * salaryMultiplyer;

}

public class Employee

{

public int Id { get; set; }

public string FirstName { get; set; }

public string LastName { get; set; }

public double Salary { get; set; }

public int YearsEmployed { get; set; }

public bool IsFullTime { get; set; }

public void NextYearSalary(List<Employee> employees, SalaryIncreaseDelegate salaryIncreaseDelegate, ExpectedSalaryDelegate expectedSalaryDelegate)

{

foreach (var employee in employees)

{

if (salaryIncreaseDelegate(employee))

{

double expectedSalary = expectedSalaryDelegate(employee);

Console.WriteLine(string.Format("Expected salary increase for employee: {0} {1} is: {2}$", employee.FirstName, employee.LastName, expectedSalary));

}

Continue to Delegates part 2

Theme by Anders Noren — Up ↑

Language

Recent Posts

Archives

Categories

TagDelegates

Events

Example:

Lambda expressions

How do you pronounce => operator?

Lambda expressions do not look like a easier way to write delegates, can we for example remove delegate declaration?

Action

Action example

Func

Func Example

Anonymous methods

What does that mean?

Would not it be nice if we could get rid of the SumTwoNumber method and just write it’s content while we instantiate delegate ? Yes it would and we can do it! Steps are:

When you mentioned we can write delegate methods inline, does that mean we can write methods in one line only?

How do i know which parameters and return types to use wile writing an anonymous methods?

Anonymous methods are awesome! Are there any drawbacks to using them?

Can i make my code even simpler?

Delegates part 2 Multicast Delegate

Examples of Multicast Delegate using void return type:

Add methods to delegate by using + operator

Remove methods from delegate by using – operator

Add methods to delegate by using += operator

Remove methods from delegate by using -= operator

Example of Multicast Delegate using string return type

Delegates part 1

How do we use delegates?

Why do we use delegates?

Exercise 1:

Exercise 2: