Delegate declaration and instantiation in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Delegate declaration and instantiation

Declare delegate type

↓

Create method matching delegate signature

↓

Instantiate delegate with method

↓

Call delegate to invoke method

↓

End

First, you declare a delegate type. Then, you create a method that matches its signature. Next, you create an instance of the delegate pointing to that method. Finally, you call the delegate to run the method.

Execution Sample

C Sharp (C#)

delegate void Greet(string name);

void SayHello(string name) {
    Console.WriteLine($"Hello, {name}!");
}

Greet greet = SayHello;
greet("Alice");

This code declares a delegate, defines a method, creates a delegate instance pointing to that method, and calls it with "Alice".

Execution Table

Step	Action	Evaluation	Result
1	Declare delegate type Greet	delegate void Greet(string)	Delegate type created
2	Define method SayHello(string)	void SayHello(string)	Method ready
3	Instantiate delegate greet = SayHello	greet points to SayHello	Delegate instance created
4	Call greet("Alice")	Invoke SayHello("Alice")	Output: Hello, Alice!
5	End of execution	No more calls	Program ends

💡 Program ends after delegate call completes

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
greet	null	points to SayHello method	invoked SayHello with "Alice"	points to SayHello method

Key Moments - 3 Insights

Why do we need to declare a delegate type before using it?

The delegate type defines the method signature it can point to. Without declaring it first (see Step 1), the compiler won't know what methods are compatible.

What happens when we assign a method to a delegate variable?

Assigning a method to a delegate (Step 3) creates an instance that holds a reference to that method, allowing us to call it indirectly.

Does calling the delegate run the method immediately?

Yes, calling the delegate (Step 4) invokes the method it points to right away, producing the output shown.

Visual Quiz - 3 Questions

Look at the execution table, what does the delegate variable 'greet' point to after Step 3?

A It points to Console.WriteLine

B It points to the SayHello method

C It is null

D It points to a string

💡 Hint

Check the 'Result' column in Step 3 of the execution table

At which step does the program output 'Hello, Alice!'?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'Result' column for the output in the execution table

If we change the method signature to take an int instead of string, what must we also change?

A Nothing, it works automatically

B Only the method name

C The delegate declaration to match the new signature

D Only the delegate variable name

💡 Hint

Refer to Step 1 and Step 2 in the execution table about matching signatures

Concept Snapshot

Delegate declaration and instantiation in C#:
- Declare delegate type with method signature
- Define method matching that signature
- Instantiate delegate with method name
- Call delegate to invoke method
Delegate acts like a method pointer

Full Transcript

In C#, a delegate is a type that holds references to methods with a specific signature. First, you declare the delegate type specifying the return type and parameters. Then, you define a method that matches this signature. Next, you create an instance of the delegate and assign it the method. Finally, calling the delegate runs the method it points to. This lets you call methods indirectly and pass them around like variables.

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