Объединить несколько событий в один интерфейс

В общем Interface и Events/Delegates используются для двух очень разных видов подхода. Давайте сначала опишем их -

Интерфейс. Основной целью интерфейса является то, что он обеспечивает некоторую функциональность для всех реализаций этого интерфейса. И всякий раз, когда вы реализуете его в подклассе, вы переопределяете реализацию суперкласса. Например -

interface IA
{
    void test();
}

class A : IA
{
    public void test(){
    }
}

class B : A 
{
    public void test(){
         //you can only go up by calling base.test(), but cannot move down, because you do not know whether there is an implementation down the tree or not. So you cannot call it.
    }
}

class C : B 
{
    public void test(){
         //you can only go up by calling base.test(), but cannot move down, because you do not know whether there is an implementation down the tree or not. So you cannot call it.
    }
}

Как вы можете видеть, с интерфейсом вы можете только оглянуться назад, но не можете рассчитывать на будущее и предположить, что будет еще больше реализаций.

События: События создаются для другой цели. позволяет просто сказать, что вы хотите дать разработчикам некоторую возможность полагаться на некоторые действия и выполнять некоторые другие действия, основанные на этих действиях и изменениях, и, самое главное, они будут реализовывать это в будущем. События не будут зависеть от вашей реализации, они просто подпишутся на нее и сделают что-то на этом основании. Независимо от того, существуют они или нет, ваша собственная реализация не изменяется или поведение вашего собственного кода не изменяется на их основе. Другими словами, вы можете двигаться только по дереву. Базовый класс захватил событие, а затем распространил его по дереву.

Это обычное использование Interface и Events и они предназначены для использования таким образом. Но его невозможно полностью закодировать таким образом, чтобы он полностью зависел от интерфейса и наоборот, то есть код, полностью зависящий от событий, но это не так, как они должны быть.

В этом случае: в вашем случае я думаю, что вы пытаетесь создать модульную систему, которая не будет зависеть друг от друга, но снова подпишитесь на события. Для этого существуют другие архитектуры и шаблоны, особенно контейнеры IOC будут очень полезны для вас, которые будут полностью зависимы от интерфейса, вам не понадобятся события. Некоторые контейнеры.net IOC - это AutoFac, Castle.Windsor, MEF

Я сам, как и MEF больше всего, вот сообщение на MEF, которое я написал несколько лет назад, показывает вам, как вы можете вводить обработчики времени выполнения внутри контейнера -

http://mahmudulislam.me/2012/04/20/1a-managed-extensibility-framework-introduction/

Кстати, статья немного устарела, я работаю над ее обновлением.

Решение с IOC: Я даю вероятное решение с MEF -

Interface ILifeCycle
{
  void OnCreated(...);
  void OnModified(...);
  ...
} 

[Export(typeof(ILifeCycle))] //export our classes for injection
classB : ILifeCycle{
   public void OnCreated(...)
   {
       ....
   }

   public void OnModified(...){
   }
}

[Export(typeof(ILifeCycle))] //export our classes for injection
classC : ILifeCycle{
   public void OnCreated(...)
   {
       ....
   }

   public void OnModified(...){
   }
}

classA
{

  [ImportMany] //get all exported classes for injection
  private IList<ILifeCycle> _observers;

  protecetd void OnCreated()
  {
     //use MEF to build composition and then do the following

     foreach(var o in _observers){
        o.OnCreated(...);
     }
  }

  protecetd void OnModified()
  {
     //use MEF to build composition and then do the following

     foreach(var o in _observers){
        o.OnModified(...);
     }
  }
  ...
}

Это очень простое решение. Но в вашем случае вы можете использовать асинхронное программирование. Потому что существует очень большая разница между событиями и интерфейсами. По умолчанию обработчики событий вызывают в отдельном потоке и, таким образом, не останавливают вызывающего абонента, но реализация интерфейса будет зависать вызывающего абонента до тех пор, пока метод не завершится. Поэтому убедитесь, что вы используете асинхронное программирование, чтобы не блокировать основной процесс.

Асинхронное программирование с использованием Async и Await (С# и Visual Basic)