C# Delegate Types

Delegate, a keyword, is used to create method objects.

With the Invoke method we can call a delegate as a method. And we can pass the delegate as an argument to another method. A delegate is a higher-order procedure.

Example. This program declares a delegate type D that receives a string, and returns no value. In Main, we create an instance of type D. We specify the method body with a lambda expression.

Then: We call the delegate D method implementation with the argument "cat" using the Invoke method. This is appropriate for the Internet.

Tip: This program uses the "delegate" keyword. But many programs use higher-order procedures with just lambda expressions.

Based on:

.NET 4.5

C# program that uses delegate

using System;

class Program
{
    delegate void D(string value);

    static void Main()
    {
	// ... Specify delegate with lambda expression.
	D d = v => Console.WriteLine(v);
	// ... Invoke delegate.
	d.Invoke("cat");
    }
}

Output

cat

Lambda. The syntax for delegate functions can be complex. Lambda expressions provide a simple and terse way of specifying functions. They use the => syntax to separate formal parameters and the method body.

Lambda: Syntax

Tip: Lambda expressions are used throughout C# programs. Common methods receive them as arguments.

Tip 2: Whenever you see a method that receives a Predicate, Action, Func or Comparison, a lambda can be passed.

Example 2. Next, we build upon the delegate concept. We declare a delegate type UppercaseDelegate. It receives a string, and returns a string. We create instances of this delegate Type in the Main method.

Note: We need a delegate declaration to create instances of the delegate type using the new-operator.

Important: When you construct instances of the delegate type, the target method must have the same return value and arguments.

Program 2 that uses delegate type: C#

using System;

class Program
{
    delegate string UppercaseDelegate(string input);

    static string UppercaseFirst(string input)
    {
	char[] buffer = input.ToCharArray();
	buffer[0] = char.ToUpper(buffer[0]);
	return new string(buffer);
    }

    static string UppercaseLast(string input)
    {
	char[] buffer = input.ToCharArray();
	buffer[buffer.Length - 1] = char.ToUpper(buffer[buffer.Length - 1]);
	return new string(buffer);
    }

    static string UppercaseAll(string input)
    {
	return input.ToUpper();
    }

    static void WriteOutput(string input, UppercaseDelegate del)
    {
	Console.WriteLine("Your string before: {0}", input);
	Console.WriteLine("Your string after: {0}", del(input));
    }

    static void Main()
    {
	// Wrap the methods inside delegate instances and pass to the method.
	WriteOutput("deves", new UppercaseDelegate(UppercaseFirst));
	WriteOutput("deves", new UppercaseDelegate(UppercaseLast));
	WriteOutput("deves", new UppercaseDelegate(UppercaseAll));
    }
}

Output

Your string before: deves
Your string after: Perls
Your string before: deves
Your string after: perlS
Your string before: deves
Your string after: PERLS

In this example, WriteOutput is called three times—it receives two arguments each time. The second argument is of type UppercaseDelegate. In Main, the UppercaseDelegate instances are constructed with the delegate constructor.

Note: The target method is specified as the sole argument. It is a method name, not a variable.

Finally: In WriteOutput, the UppercaseDelegate argument is invoked. We use two parentheses after the parameter name.

Anonymous functions include lambda expressions. You can pass a lambda expression as the implementation of the delegate. You can construct the UppercaseDelegate by specifying a lambda expression inside the constructor itself.

Note: This is functionally equivalent to using a static method with the same return value and argument.

Anonymous Functions

C# program that uses lambda expression, delegate

using System;

class Program
{
    // ...
    // ... (Paste other methods here)
    // ...

    static void Main()
    {
	WriteOutput("deves", new UppercaseDelegate(x => x.ToUpper()));
    }
}

Output

PERLS

Action. In the .NET Framework, Action instances represent a method that returns void. You can call Invoke on the Action instance and then the method will execute. These are useful in a variety of program contexts.

Action

Func. A Func instance is a delegate to a method that receives arguments and returns a value. It is used in the same general way as Action, but it has a return value. So you can assign variables to its result.

Func

Events allow you to specify that when external event occurs, such as a mouse click, a delegate method should always be executed. Events are most commonly used in user interfaces such as Windows Forms.

But: You can define custom events in any program. They are occasionally useful in complex programs.

Event

LINQ. In LINQ extensions, delegate methods are extensively used. Even query expressions (such as select statements) are implemented with methods that receive delegates. Many extension methods require delegate use.

LINQ

Summary. Delegate syntax is at first confusing. Once you understand the instantiation model and type system, it is useful. With the type system, the language offers the ability to specify actions as data.

Related Links