Practical use of interface events [closed]

Answer 1

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
}

Answer 2

A classic scenario is MVP pattern with passive view. The form implememts an view inteface that has a NameChanged event. The presenter that creates/uses the view subscribes to this event. When the name text in textbox is changed view fires this event. The presenter is then notified. Since the presenter only knows about event from view interface you can provide a mock view for testing. The view is completely decoupled from presenter.

Answer 3

INotifyPropertyChanged is used through out the framework.

Just look at the INotifyPropertyChanged.PropertyChanged Event

Answer 4

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; }
}

Answer 5

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.

Answer 6

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.