Delegate declaration and instantiation in C Sharp (C#) - Time & Space Complexity

Time Complexity: Delegate declaration and instantiation

O(n)

Understanding Time Complexity

When we declare and create delegates in C#, it's important to know how the time to do this grows as we add more delegates.

We want to understand how the work changes when we create more delegate instances.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

    delegate void SimpleDelegate();

    void Method() { }

    SimpleDelegate[] delegates = new SimpleDelegate[n];
    for (int i = 0; i < n; i++)
    {
        delegates[i] = new SimpleDelegate(Method);
    }
    

This code creates an array of delegates and fills it by creating a new delegate instance for each element.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Creating a new delegate instance inside a loop.
• How many times: Exactly n times, once for each element in the array.

How Execution Grows With Input

As the number of delegates n increases, the total work grows directly with n.

Input Size (n)	Approx. Operations
10	10 delegate creations
100	100 delegate creations
1000	1000 delegate creations

Pattern observation: The work grows in a straight line as we add more delegates.

Final Time Complexity

Time Complexity: O(n)

This means the time to create all delegates grows directly with the number of delegates you want to create.

Common Mistake

[X] Wrong: "Creating multiple delegates at once is a constant time operation regardless of how many delegates."

[OK] Correct: Each delegate creation takes time, so doing it many times adds up linearly, not instantly.

Interview Connect

Understanding how delegate creation scales helps you reason about event handling and callbacks in real applications, showing you can think about performance even in simple code.

Self-Check

"What if we reused the same delegate instance for all array elements instead of creating new ones? How would the time complexity change?"

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