Practical use of interface events

Question

What is a good example of the power of interface events (declaring events inside interface)?

Most of the times I have seen only public abstract methods inside interface.

Solution 1

I used events to signal when a serial port received data.

Here is my interface.

public interface ISerialPortWatcher
{
    event EventHandler<ReceivedDataEventArgs> ReceivedData;
    event EventHandler StartedListening;
    event EventHandler StoppedListening;

    SerialPortSettings PortOptions { set; }

    bool Listening { get; set; }
    void Stop();
    void Start();
}

public class ReceivedDataEventArgs : EventArgs
{
    public ReceivedDataEventArgs(string data)
    {
        Data = data;
    }
    public string Data { get; private set; }
}

Solution 2

An excellent example within the .NET framework is the INotifyPropertyChanged interface. This interface consists of only one member: the PropertyChanged event.

In WPF, you can state that a control will display a specific property of an object instance. But how will this control update if the underlying property changes?

If the bound object implements the INotifyPropertyChanged interface, the WPF framework can just listen to PropertyChanged and update appropriately.

Solution 3

here is one example

public interface IMainAppWindow
{
   event EventHandler Closed;
}

// version 1 main window
public MainForm : Form , IMainAppWindow
{

}

// version 2 main window
public MainWindow : Window , IMainAppWindow
{
  event EventHandler Closed;

  public void OnClosed(object sender,RoutedEventArgs e)
  {
    if(Closed != null)
    {
      Closed(this,e);
    }
  }
}

I have some code like this in 1 of my applications. The app was written in winforms, then upgraded to WPF.

Solution 4

INotifyPropertyChanged is used through out the framework.

Just look at the INotifyPropertyChanged.PropertyChanged Event

Solution 5

Events in interfaces work pretty much just like methods. You can use them just how you would use any interface.

public interface IInterface {
    event EventHandler QuestionAsked;
}

public class Class : IInterface {
    event EventHandler QuestionAsked;

    //As with typical events you might want an protected OnQuestionAsked
}

View more solutions

Comments

[DavidRR]

When raising an event, you should make a copy of the event (see OnRaiseCustomEvent()) to avoid the possibility of a race condition: EventHandler handler = this.Closed; if (handler != null) { ... }

[DavidRR]

In the article Model View Presenter Styles which describes three different MVP patterns, the third pattern called Observing Presenter Style appears to be most closely aligned with the Passive View pattern described here.

[Dai]

.NET's event seems to now be unpopular, I suppose because their use-cases are mostly gone (e.g. WinForms isn't popular, WPF prefers MVVM with event bindings in XAML, WebForms is completely dead, and (ab)use of events for async programming in the EAP Pattern is also dead because TPL with await is far better) - finally there's a problem inherent in event in that it's very easy to forget to de-register and end-up leaking object-references as EventHandler does not use a Weak-Reference.