Delegates And Events - What Are They And Their Use

I would like to explain one of the important usage of Delegates and Events.

Delegates

In most of the blogs, you can find the answer that Delegates are similar to function pointers in C/C++, and we can use Delegate to call methods at runtime.

I will explain one of the real need of Delegates: First, we need to understand what the Publisher subscriber model is.

"Publish/subscribe messaging, or pub/sub messaging, is a form of asynchronous service-to-service communication used in serverless and microservices architectures. In a pub/sub model, any message published to a topic is immediately received by all of the subscribers to the topic. Pub/sub messaging can be used to enable event-driven architectures, or to decouple applications in order to increase performance, reliability, and scalability".

Let's take one example and understand more about Publisher/Subscriber model and Delegates.

I have an ApplicationProcessing Service which is responsible to process the Application and my current requirement is when the Application processing is finished we should send an email to the admin team/IT ops team.

Let's look at my Services classes.

ApplicationProcessingService.cs

public class ApplicationProcessingService : IAppProcessingService
{
private readonly IEmailService _emailService;
public ApplicationProcessingService(IEmailService emailService)
{
_emailService = emailService;
}
public void ProcessApplications(IApplication application)
{
Thread.Sleep(2000);
//My application processing code goes here --- Adding some Thread.Sleep
_emailService.SendEmail(application);
}
}

My EmailSerice.cs Service

public partial class EmailService : IEmailService
{
public void SendEmail(IApplication application)
{
Console.WriteLine("Sending Email to " + application.ApplicantEmail);
}
}

So far everything is fantastic. Now, we have another change request saying, we need to add extra notification system to our application processing (it can be Text Message/ some other notification system).

What will you do?

Are you going to Inject ITextMessageService and update ApplicationProcessing Service to call TextMessageService provider?

This is not a good practice, we have to focus now on "O" in solid priniciples.

"Software entities … should be open for extension, but closed for modification."

Here we need to think about Delegates

As per the change request, we definitely need another notification provider class, lets build TextMessageService

public class TextMessageService : ITextMessageService
{
public void SendMessage(IApplication application)
{
Console.WriteLine("Sending Text Message to " + application.ApplicantPhone);
}
}

Modify our AppProcessingService (I have created another class with different name for this demo) and add a delegate TransmitMessageToconsumers(IApplication application)

public class ApplicationProcessingServiceWithDelegates : IAppProcessingService
{
public delegate void TransmitMessageToConsumers(IApplication application);
public TransmitMessageToConsumers TransmitMessageToConsumerDelegate = null;
public void ProcessApplications(IApplication application)
{
Thread.Sleep(1000);
Console.WriteLine("Application processing is done for the Applicant " + application.ApplicantName);
TransmitMessageToConsumerDelegate?.Invoke(application);
}
}

In our client application I need to make a few updates to use this Delegate.

My client application code:

public class DelegatesClient
{
public static void PerformApplicationProcessing()
{
IApplication application = new Application();
application.ApplicantEmail = "[email protected]";
application.ApplicantName = "xxxxx";
application.ApplicantPhone = "+xxxxxx";
application.ApplicationDOB = new DateTimeOffset(1991, 09, 25, 0, 0, 0, TimeSpan.Zero);
application.ApplicationId = 123456;
var appProcessingServiceInstance = new ApplicationProcessingServiceWithDelegates();
var emailSeriveInstance = new EmailService();
var textMessageServiceInstance = new TextMessageService();
appProcessingServiceInstance.TransmitMessageToConsumerDelegate += emailSeriveInstance.SendEmail;
appProcessingServiceInstance.TransmitMessageToConsumerDelegate += textMessageServiceInstance.SendMessage;
appProcessingServiceInstance.ProcessApplications(application);
//Problem with Delegates --> Data Encapsulation
ApplicationProcessingServiceWithDelegates.TransmitMessageToConsumers text = new ApplicationProcessingServiceWithDelegates.TransmitMessageToConsumers(MyClassMethod);
text(application);
}

Observe that we are registering two methods to Delegate and in my ProcessApplications method I am invoking the delegate. If I run my application ProcessApplication method Delegate will call Sendmail and SendMessage methods. In future, if we want to skip sending mail we can detach Sendmail process without touching AppProcessing Service.

Everything is cool with Delegate. Now, there is a problem with the above code, that is Delegate is exposed to client and client can do whatever they want (make Delegate instance null or some other operations). That is not good. we need to hide exposing this delegate to the public.

Events will solve this Data Encapsulation problem of Delegates.

Let's look at my modified code with Events.

AppProcessingService.cs

public class ApplicationProcessingWithEvents : IAppProcessingService
{
public delegate void TransmitMessageToConsumers(IApplication application);
public event TransmitMessageToConsumers TrasmitMessageToConsumerEvent;
public void ProcessApplications(IApplication application)
{
Thread.Sleep(1000);
Console.WriteLine("Application processing is done for the Applicant " + application.ApplicantName);
OnTransmitMessageToConsumers(application);
}
protected virtual void OnTransmitMessageToConsumers(IApplication application)
{
TrasmitMessageToConsumerEvent?.Invoke(application);
}
}

I have created an Event and that event is responsible for Inovoking the Methods registered by client.

Let's look at my client code.

public class EventsClient
{
public static void PerformApplicationProcessing()
{
IApplication application = new Application();
application.ApplicantEmail = "[email protected]";
application.ApplicantName = "xxxxxx";
application.ApplicantPhone = "+91XXXXXX";
application.ApplicationDOB = new DateTimeOffset(1991, 09, 25, 0, 0, 0, TimeSpan.Zero);
application.ApplicationId = 123456;
var appProcessingServiceInstance = new ApplicationProcessingWithEvents();
var emailSeriveInstance = new EmailService();
var textMessageServiceInstance = new TextMessageService();
appProcessingServiceInstance.TrasmitMessageToConsumerEvent += emailSeriveInstance.SendEmail;
appProcessingServiceInstance.TrasmitMessageToConsumerEvent += textMessageServiceInstance.SendMessage;
appProcessingServiceInstance.ProcessApplications(application);
}
}

I have registerd those events from the client code and whenever the app processing is done, OnTransmitMessageToCosumenrEvent will trigger the registered methods.

App processing service event will not allow client code to access Delegate, you will get a compile time error when you try to access it. In this way, we can encapsulate the Delegates.

I have attached the sample code block to this blog.

Have a good day.