Event Handling Samples.cs

delegate void SignalHandler(object, SignalEventArgs);
delegate void SignalErrorHandler(object, SignalErrorEventArgs);

interface ISignalRecipient {
  void ProcessSignal(object sender, SignalEventArgs e);
  void ProcessError(object sender, SignalErrorEventArgs e);
}

interface ISignalSource {
  event SignalHandler SignalOccurred;
  event SignalErrorHandler ErrorOccurred;
  
  // the following is simply to demonstrate an alternative below:
  void RegisterSignalRecipient(ISignalRecipient recipient);
}

class SampleSignalSource : ISignalSource 
{
  public event SignalHandler SignalOccurred;
  public event SignalErrorHandler ErrorOccurred;
  
  // not typical, just an example of usage
  private event SignalHandler PrivateSignalOccurred;
  private event SignalErrorHandler PrivateSignalErrorOccurred;
  
  public ContextAwareSignalSource() 
  {
    foreach (var recipient in GlobalSpot.AllRecipients) 
    {
      // just some random example logic
      if (recipient is ISignalRecipient) 
      {
        this.SignalOccured += recipient.ProcessSignal;
        this.ErrorOccurred += recipient.ProcessError;
        
        // your example would produce the following:
        //this.SignalOccurred += recipient;
        //this.ErrorOCcurred += recipient;
        // to me the above code implies the same exact thing will 
        // happen for signals and errors.
        
        // alternatively this could leverage the register approach
        // to allow initial wireup and dynamic additions later
        RegisterSignalRecipient(recipient);
      }
    }
  }
  
  public void RegisterSignalRecipient(ISignalRecipient recipient)
  {
    this.PrivateSignalOccurred += recipient.ProcessSignal;
    this.
  }
}