How new operator works with delegates in C#

Question

In this code snippet how does new MyDel(this.WelcomeUser) work? What happens in memory, I know that delegate is reference type, so is there an object created in heap and which type of object is it - MyDel? what is exactly this.WelcomeUser? Is it a reference to a method?

using System;
namespace SampleApp {
public delegate string MyDel(string str);

class EventProgram {
  event MyDel MyEvent;

  public EventProgram() {
     this.MyEvent += new MyDel(this.WelcomeUser);
  }
  public string WelcomeUser(string username) {
     return "Welcome " + username;
  }
  static void Main(string[] args) {
     EventProgram obj1 = new EventProgram();
     string result = obj1.MyEvent("Tutorials Point");
     Console.WriteLine(result);
  }
 }
}

Answer 1

how does new MyDel(this.WelcomeUser) work?

It is a call to a constructor, with this.WelcomeUser as an argument.

public delegate string MyDel(string str);

Is a Type definition. The compiler uses this to generate a class deriving from System.Delegate. Note that this was designed before C# had generics.

what is exactly this.WelcomeUser?

It is the name of a method. In C# (and C, C++ etc) a method is always followed by a parameter (or argument) list, even if that list is empty: SomeMethod().
Omitting the list is the equivalent of adress-of.

It becomes clearer when you look at VB.NET, the equivalent code is

MyEvent += new MyDel(this.WelcomeUser);       // C#

AddHandler MyEvent, AddressOf Me.WelcomeUser  ' VB

And from C# 2 on, you can use the short notation:

MyEvent += this.WelcomeUser;       // modern C#

Answer 2

Is it a reference to a function?

Yes, but we generally call them methods in C#

• this refers to the current class
• WelcomeUser refers to the method name in the class.

The new MyDel call expects to be supplied with the name of a method that takes a string argument and returns a string (i.e. something that matches the inputs and output of the delegate). Any method that adheres to this will be acceptable

It would probably make more sense to see an example where the event raiser and consumer were in different classes:

using System;

public delegate string MyDel(string str);

class EventEmitter {
  event MyDel MyEvent;
}

class EventConsumer{

  private EventEmitter x = new EventEmitter();

  public EventConsumer() {
     x.MyEvent += new MyDel(this.MyEventHandler);
  }

  public string MyEventHandler(string username) {
     return "Welcome " + username;
  }

}

Here the EventConsumer can now know when the EventEmitter has raised its event. EventEmitter has no knowledge of any of the methods inside the consumer, what their names are etc.. The.NET runtime will call the method (in the consumer) attached to the event in the emitter. Multiple handlers can be attached:

class EventConsumer{

  private EventEmitter x = new EventEmitter();

  public EventConsumer() {
     x.MyEvent += new MyDel(this.MyEventHandler);
     x.MyEvent += new MyDel(this.MyEventHandler2);
  }

  public string MyEventHandler(string username) {
     return "Welcome " + username;
  }
  public string MyEventHandler2(string username) {
     return "Goodbye " + username;
  }

}

They will both be called (but in what order is not guaranteed) when the event is raised..

The event mechanism is important because it allows us to provide a way to alert other classes that things have happened without needing to know anything about that class. THe obvious use is something like a Button class - Microsoft had no idea what your method that handles the button click would be called when they wrote Button, so they just provide an event called Click, and you attach any method with a compatible signature to handle the click when the user presses the button