In C#, an event is a language feature that allows one class (the publisher) to notify other classes (subscribers or listeners) when a specific action or state change occurs. Events are commonly used for implementing the observer pattern, enabling objects to react to changes without needing to know explicitly which objects need to be notified. Events play a pivotal role in building responsive and loosely coupled applications.
Key characteristics of C# events include:
- Declaration: Events are declared using the `event` keyword within a class. They are typically defined as a delegate type, which specifies the method signature that subscribers must adhere to.
- Publisher-Subscriber Model: In the event-driven model, a class exposes events that other classes can subscribe to. Subscribers register event handlers (methods) that should be executed when the event occurs.
- Encapsulation: Events promote encapsulation because subscribers do not have direct access to the publisher’s internals. Instead, they interact through event handlers.
- Event Invocation: The publisher raises (invokes) an event when the associated action or condition occurs. Subscribed event handlers are then called to respond to the event.
Here’s a simplified example of declaring and using an event in C#:
```csharp
public class TemperatureSensor
{
// Declare an event using a delegate type
public event Action<float> TemperatureChanged;
private float currentTemperature;
public float CurrentTemperature
{
get { return currentTemperature; }
set
{
currentTemperature = value;
// Raise the TemperatureChanged event when the temperature changes
TemperatureChanged?.Invoke(currentTemperature);
}
}
}
```
In this example, the `TemperatureSensor` class exposes an event named `TemperatureChanged`. When the `CurrentTemperature` property is set, it raises the event, notifying any subscribed event handlers of the temperature change.
Events are a fundamental concept in C# for building responsive and modular applications, especially in scenarios where objects need to communicate and respond to changing conditions or user interactions. They help achieve decoupling and extensibility by allowing objects to interact without direct dependencies on one another.
