Understanding the 'event' Keyword in C#

Previous Page
Next Page

C# event Keyword

In C#, the event keyword is used to declare and handle events. Events are a mechanism that allows classes or objects to communicate and signal the occurrence of specific actions or states to other parts of the application. They are commonly used in event-driven programming and are fundamental in building responsive and interactive applications.

Here's how you declare an event using the event keyword: 

public class ExampleClass
{
    // Declare an event named "MyEvent" using EventHandler delegate.
    public event EventHandler MyEvent;

    // Other members and methods of the class go here.
}

In this example, we declare an event named MyEvent of type EventHandler. EventHandler is a predefined delegate type in C# that is often used for declaring events. You can use other delegate types as well, depending on the requirements of your event.To raise (invoke) the event, you typically create a method in the class and call it whenever the event should be triggered. For example: 

public class ExampleClass
{
    public event EventHandler MyEvent;

    public void DoSomething()
    {
        // Some action here...

        // Raise the event when needed.
        OnMyEvent();
    }

    protected virtual void OnMyEvent()
    {
        // Check if any subscribers (event handlers) are attached to the event.
        if (MyEvent != null)
        {
            // Invoke the event.
            MyEvent(this, EventArgs.Empty);
        }
    }

    // Other members and methods of the class go here.
}

In this updated example, we added the DoSomething method, which represents an action that may trigger the event. When DoSomething is called, it invokes the OnMyEvent method, which then checks if there are any subscribers (event handlers) attached to the MyEvent event. If there are subscribers, it invokes the event and notifies them.To subscribe to the event and handle its occurrence, you need to attach an event handler method to the event.

Here's an example of how you can subscribe to the MyEvent event: 

public class EventSubscriber
{
    public void MyEventHandler(object sender, EventArgs e)
    {
        // Event handling code goes here.
        Console.WriteLine("MyEvent was triggered!");
    }
}

// Usage example:
ExampleClass example = new ExampleClass();
EventSubscriber subscriber = new EventSubscriber();

// Subscribe to the event by attaching the event handler.
example.MyEvent += subscriber.MyEventHandler;

// Call the method that triggers the event.
example.DoSomething(); // This will trigger the event, and the event handler will be executed.

In this example, we create an instance of EventSubscriber and attach its MyEventHandler method to the MyEvent event of the ExampleClass instance. When DoSomething is called on the ExampleClass instance, it triggers the event, and the event handler is executed.

Events are essential for creating loosely coupled and maintainable code, as they allow classes to interact without having direct knowledge of each other. They promote the separation of concerns and help build more modular and flexible applications.

Previous Page
Next Page