Events are the core mechanism for implementing observer patterns in C#. It allows an object to notify the occurrence of a specific action without being tightly coupled to other objects. Events are essentially encapsulation of delegates, allowing classes to expose subscription methods without giving call control. For example, the Click event in the Button class is based on the EventHandler delegation. When the button is clicked, the OnClick method will be called to trigger the event. Key points include: 1. Events can only be called by the class that declares them; 2. Subscribers can dynamically add or remove handlers at runtime. When defining custom events, you can create a class that inherits EventArgs and the corresponding delegate, such as the FileWatcher class passing file change information through the FileChanged event. Best practices for using events are: 3. When subscribers no longer need to update, they should unsubscribe to avoid memory leaks; 4. Prioritize the use of EventHandler over custom delegates; 5. Use null condition operators to avoid calling empty events; 6. Virtual methods support derived class extension behavior; 7. The event itself is not asynchronous, and asynchronous notifications need to be implemented in combination with async/await.

Events in C# are a core part of the language's support for the observer pattern. At their heart, they provide a way for one object to notify other objects when something happens—without those objects needing to be tightly coupled. If you've ever used buttons in a UI framework like WPF or WinForms, you've already worked with events.

What Exactly Is an Event?

An event is essentially a wrapper around a delegate. It allows a class to expose a way for other code to subscribe to certain actions, without exposing full control over invocation. You can think of it like a subscription list: interested parties can register themselves and get notified when a specific action occurs.

For example:

 public class Button
{
    public event EventHandler Click;

    protected virtual void OnClick()
    {
        Click?.Invoke(this, EventArgs.Empty);
    }
}

Here, Click is an event based on the EventHandler delegate. When someone clicks the button, OnClick gets called, which in turn raises the event. Any method that matches the signature of EventHandler can subscribe to this event.

Key points:

• Events can only be invoked from within the class that declares them.
• Subscribers can add ( = ) or remove ( -= ) their handlers at runtime.

How to Define Custom Events

While .NET provides many built-in delegates like EventHandler , sometimes you need your own custom data structure to pass along with the event. This is where defining your own delegate and event args becomes useful.

Let's say you're building a file watcher and want to notify subscribers when a file changes:

1. Define a custom EventArgs class:

    public class FileChangedEventArgs : EventArgs
   {
       public string FileName { get; set; }
       public DateTime ChangeTime { get; set; }
   }

2. Define a matching delegate:

    public delegate void FileChangedEventHandler(object sender, FileChangedEventArgs e);

3. Declare the event in your class:

    public class FileWatcher
   {
       public event FileChangedEventHandler FileChanged;
   
       protected virtual void OnFileChanged(string fileName)
       {
           FileChanged?.Invoke(this, new FileChangedEventArgs
           {
               FileName = fileName,
               ChangeTime = DateTime.Now
           });
       }
   }

   This gives you flexibility to carry rich contextual information when raising the event.

   Best Practices and Common Pitfalls

   Working with events is straightforward, but there are some gotchas:

   • Avoid memory leaks by unsubscribe : If a subscriber doesn't unsubscribe, the publisher will keep a reference to it, potentially preventing garbage collection. Always remember to use -= when the subscriber no longer needs updates.

   • Use EventHandler<t></t> instead of creating new delegates : Unless you have a very good reason, prefer using the generic EventHandler<t></t> rather than defining your own delegate. It reduces boilerplate and improves consistency.

   • Make sure to check for null before invoking : In older versions of C#, you'd write if (Click != null) Click(...); . In modern C#, you can safely use the null-conditional operator: Click?.Invoke(...) . This avoids NullReferenceExceptions if there are no subscribers.

   • Virtual methods for raising events help with inheritance : By making OnClick virtual, derived classes can override behavior without breaking encapsulation.

   Also, don't confuse events with async notifications—they're not inherently asynchronous. If you need async behavior, wrap the invocation in a task or use async/await .

   ---

   That's how events work under the hood and how to use them effectively. They're a powerful tool once you understand the mechanics.

   The above is the detailed content of Understanding the C# Eventing Model in Depth. For more information, please follow other related articles on the PHP Chinese website!