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.