title: Subscribe to an event many times with EventHandlerList
body: <p>The goal: I want to subscribe many times to the same event in different classes. I have the following class:</p>
  
  <pre><code>public class MyEngine : IEngine
  {
      private EventHandlerList _events = new EventHandlerList();
  
      protected EventHandlerList Events
      {
          get
          {
              return _events;
          }
      }
  
      private readonly string OnReceivedEventName = "OnReceived";
  
      public event MessageEventHandler OnReceived
      {
          add
          {
              lock (this)
              {
                  Events.AddHandler(OnReceivedEventName, value);
              }
          }
          remove
          {
              lock (this)
              {
                  Events.RemoveHandler(OnReceivedEventName, value);
              }
          }
      }
  
      protected internal virtual void MessageReceived(MessageEventArgs e)
      {
  
          var handler = Events[OnReceivedEventName] as MessageEventHandler;
          TryFireMessageEvent(handler, e);
      }
  
      private void TryFireMessageEvent(MessageEventHandler handler, MessageEventArgs e)
      {
          try
          {
              if (handler != null)
                  handler.Invoke(this, e);
          }
          catch (Exception ex)
          {
              log.Error("Message Received - Exception caught", ex);
              ErrorOccurred(ex);
          }
      }
  }
  </code></pre>
  
  <p>The main module has an instance of IEngine:</p>
  
  <pre><code>public class MyProvider
  {
      protected internal IEngine Engine { get; set; }
      public MyProvider(IEngine engine)
      {
          Engine = engine;
          engine.OnReceived += Engine_Received;
      }
      protected internal void Engine_Received(IEngine engine, MessageEventArgs args)
      {...}
  }
  </code></pre>
  
  <p>I also have a function 'DoAction' that create an operation and inject the engine:</p>
  
  <pre><code>public class MyProvider
  {
      ....
      public Result DoAction()
      {
          using (var operation = new SyncOperation(Engine))
          {
              operationResult = operation.Execute();
          }
      }
  }
  </code></pre>
  
  <p>The SyncOperation:</p>
  
  <pre><code>public class SyncOperation : IDisposable
  {
      private IEngine _engine;
  
      public SyncOperation (IEngine engine)
      {
          Ensure.NotNull(engine, "engine");
          _engine = engine;
  
          _engine.OnReceived += Engine_OnReceived;
      }
  
      internal void Engine_OnReceived(IEngine engine, MessageEventArgs args)
      {...}
  }
  </code></pre>
  
  <p>When calling to operation.Execute(); not all the received events are being raised on the SyncOperation class.</p>
  
  <p>Am I missing something?</p>