Chapter 2.2: Object-Oriented Programming with C#: Understanding Interfaces, Delegates, and Events in C#

 Introduction:

In our previous article, we explored classes, objects, and inheritance in the context of Object-Oriented Programming with C#. In this article, we'll delve into interfaces, delegates, and events, which are crucial concepts for designing flexible, modular, and maintainable applications in C#. In the next article, we'll cover constructors and destructors.

Interfaces:

An interface is a contract that defines a set of methods and properties a class must implement. Interfaces promote loose coupling and ensure that classes adhere to a specific structure. To define an interface, use the interface keyword followed by the interface name:

interface IPrintable
{
    void Print();
}

To implement an interface in a class, use the : symbol followed by the interface name:

class Document : IPrintable
{
    public void Print()
    {
        Console.WriteLine("Printing the document...");
    }
}

Delegates:

A delegate is a type-safe function pointer that can reference a method with a specific signature. Delegates allow you to pass methods as arguments to other methods, enabling a higher degree of flexibility and modularity in your code. To declare a delegate, use the delegate keyword followed by the method signature:

delegate void PrintDelegate(string message);

Example of using a delegate:

static void Main()
{
    PrintDelegate print = PrintToConsole;
    print("Hello, world!");
}

static void PrintToConsole(string message)
{
    Console.WriteLine(message);
}

Events:

Events allow a class to notify other classes when something happens, adhering to the publisher-subscriber pattern. Events are typically used in conjunction with delegates. To declare an event, use the event keyword followed by the delegate type and the event name:

class Publisher
{
    public delegate void EventHandler(string message);
    public event EventHandler OnPublish;

    public void Publish(string message)
    {
        OnPublish?.Invoke(message);
    }
}

Subscribing to and handling the event:

static void Main()
{
    Publisher publisher = new Publisher();
    publisher.OnPublish += HandlePublishEvent;
    publisher.Publish("Event published!");
}

static void HandlePublishEvent(string message)
{
    Console.WriteLine("Received event: " + message);
}

Conclusion:

In this article, we covered the concepts of interfaces, delegates, and events in C#. Understanding these concepts is essential for designing flexible and modular applications in C#. In the next article, we'll discuss constructors and destructors, which are crucial components of object lifecycle management in C#. Stay tuned for more C# learning!