Delegate declaration and instantiation in C Sharp (C#)

Introduction

Delegates let you store references to methods. This helps you call methods indirectly and pass them around like variables.

When you want to call different methods using the same variable.

When you want to pass a method as a parameter to another method.

When you want to define callback methods for events.

When you want to create flexible and reusable code that can change behavior at runtime.

Syntax

C Sharp (C#)

delegate return_type DelegateName(parameter_list);

DelegateName delegateInstance = new DelegateName(MethodName);

The delegate keyword declares a delegate type.

Delegate instances are created by passing a method name matching the delegate signature.

Examples

This declares a delegate that points to methods with no parameters and no return value. Then it creates an instance pointing to SayHello.

C Sharp (C#)

delegate void SimpleDelegate();

void SayHello() {
    Console.WriteLine("Hello!");
}

SimpleDelegate d = new SimpleDelegate(SayHello);

This delegate points to methods taking two integers and returning an integer. It is assigned to the Add method.

C Sharp (C#)

delegate int MathOperation(int x, int y);

int Add(int x, int y) {
    return x + y;
}

MathOperation op = new MathOperation(Add);

Sample Program

This program declares a delegate GreetDelegate for methods that take a string and return nothing. It creates instances pointing to two different greeting methods and calls them.

C Sharp (C#)

using System;

class Program {
    delegate void GreetDelegate(string name);

    static void GreetMorning(string name) {
        Console.WriteLine($"Good morning, {name}!");
    }

    static void GreetEvening(string name) {
        Console.WriteLine($"Good evening, {name}!");
    }

    static void Main() {
        GreetDelegate greet = new GreetDelegate(GreetMorning);
        greet("Alice");

        greet = new GreetDelegate(GreetEvening);
        greet("Bob");
    }
}

Important Notes

Delegate method signatures must match exactly (parameters and return type).

You can use shorthand syntax: GreetDelegate greet = GreetMorning; without new.

Delegates can point to multiple methods using multicast, but that is an advanced topic.

Summary

Delegates hold references to methods with a specific signature.

Declare delegates with the delegate keyword and instantiate by passing a method name.

Delegates enable flexible and reusable code by allowing methods to be passed and called indirectly.

Practice

1. What is a delegate in C# used for?

easy

A. To define variables that cannot change

B. To hold references to methods with a specific signature

C. To store values like integers or strings

D. To create new classes dynamically

Solution

1. Step 1: Understand delegate purpose

   A delegate is a type that holds references to methods with a matching signature.

2. Step 2: Compare options to definition

   Only To hold references to methods with a specific signature correctly describes this purpose; others describe unrelated concepts.

3. Final Answer:

   To hold references to methods with a specific signature -> Option B

4. Quick Check:

   Delegate = method reference holder [OK]

Hint: Delegates point to methods, not data or classes [OK]

Common Mistakes:

• Confusing delegates with variables
• Thinking delegates create classes
• Assuming delegates store simple values

2. Which of the following is the correct way to declare a delegate that takes an int and returns void?

easy

A. void delegate MyDelegate(int number);

B. delegate int MyDelegate(void number);

C. delegate MyDelegate void(int number);

D. delegate void MyDelegate(int number);

Solution

1. Step 1: Recall delegate declaration syntax

   The correct syntax is: delegate returnType DelegateName(parameterList);

2. Step 2: Match syntax to options

   delegate void MyDelegate(int number); matches this exactly: delegate void MyDelegate(int number); others have incorrect order or types.

3. Final Answer:

   delegate void MyDelegate(int number); -> Option D

4. Quick Check:

   delegate returnType Name(params) = delegate void MyDelegate(int number); [OK]

Hint: Remember: 'delegate' keyword + return type + name + parameters [OK]

Common Mistakes:

• Placing 'void' before 'delegate'
• Swapping delegate name and return type
• Using 'void' as parameter type

3. What will be the output of the following code?

delegate int Operation(int x, int y);
class Program {
  static int Add(int a, int b) => a + b;
  static void Main() {
    Operation op = Add;
    Console.WriteLine(op(3, 4));
  }
}

medium

A. 0

B. 34

C. 7

D. Compile error

Solution

1. Step 1: Understand delegate assignment

   The delegate 'Operation' matches the method 'Add' signature (two ints, returns int), so 'op' points to 'Add'.

2. Step 2: Evaluate delegate invocation

   Calling 'op(3, 4)' calls 'Add(3, 4)', which returns 3 + 4 = 7.

3. Final Answer:

   7 -> Option C

4. Quick Check:

   Delegate calls Add(3,4) = 7 [OK]

Hint: Delegate calls assigned method with given arguments [OK]

Common Mistakes:

• Thinking delegate concatenates numbers
• Expecting string output
• Assuming compile error due to delegate

4. Identify the error in the following delegate instantiation:

delegate void Printer(string message);
class Program {
  static void PrintMessage() { Console.WriteLine("Hello"); }
  static void Main() {
    Printer p = PrintMessage;
    p("Hi");
  }
}

medium

A. PrintMessage method signature does not match delegate

B. Delegate cannot be assigned to a method

C. Missing parentheses when assigning delegate

D. Delegate must return a value

Solution

1. Step 1: Compare delegate and method signatures

   The delegate 'Printer' expects a method with a string parameter and void return type.

2. Step 2: Check method signature

   'PrintMessage' has no parameters, so it does not match the delegate signature.

3. Final Answer:

   PrintMessage method signature does not match delegate -> Option A

4. Quick Check:

   Delegate and method signatures must match [OK]

Hint: Delegate and method signatures must match exactly [OK]

Common Mistakes:

• Ignoring parameter mismatch
• Thinking delegate needs parentheses on assignment
• Assuming delegate must return a value

5. Given the delegate declaration:

delegate bool Filter(int value);

Which of the following correctly instantiates the delegate to a method that returns true if the number is even?

hard

A. Filter f = x => x % 2 == 0;

B. Filter f = (int x) => { return x * 2; };

C. Filter f = delegate(int x) { Console.WriteLine(x); };

D. Filter f = x => x + 2 == 0;

Solution

1. Step 1: Understand delegate signature

   'Filter' expects a method taking an int and returning a bool.

2. Step 2: Check each option's return type and logic

   Filter f = x => x % 2 == 0; returns true if x is even (x % 2 == 0), matching bool return.
   Filter f = (int x) => { return x * 2; }; returns int, not bool.
   Filter f = delegate(int x) { Console.WriteLine(x); }; returns void (no return), invalid.
   Filter f = x => x + 2 == 0; returns bool but checks x + 2 == 0, which is not the even check.

3. Final Answer:

   Filter f = x => x % 2 == 0; -> Option A

4. Quick Check:

   Delegate needs bool return matching even check [OK]

Hint: Match delegate return type and logic exactly [OK]

Common Mistakes:

• Returning wrong type (int instead of bool)
• Missing return statement in anonymous method
• Incorrect condition for even check