Aumento de eventos vs llamadas a métodos directos diferencias

Question

Al generar un evento, se llamará a su controlador de eventos. ej. http://msdn.microsoft.com/en-us/library/aa645739%28VS.71%29.aspx

¿Cuál es la diferencia entre utilizar el mecanismo de eventos y las llamadas directas a otros métodos (por ejemplo, si se cumple una condición en el método A(), llame a B())?

¿Y cuál es la diferencia entre consumir y elevar eventos?

Gracias

Answer 1

provoca un evento, se llame su caso manejador

que comenzó mal. Puede haber no controlador de eventos. O muchos. Tu no sabes Cuál es la diferencia principal de llamar un método directamente. Busque el "patrón de observador" en su libro de patrones de diseño favorito.

Answer 2

provoca un evento (o Invocación, para usar el término de su enlace) significa que va a enviar el evento a todos los consumidores. Por ejemplo, una ventana puede generar un evento cuando se hace clic con el mouse.

El consumo de un evento significa que está recibiendo y procesando el evento de quien lo envió. Por ejemplo, es posible que desee saber cuándo se hace clic en la ventana con el mouse.

Si sólo tiene un consumidor, entonces se podría lograr algo similar con sólo el suministro de una devolución de llamada directa:

// 'Event' type: 
delegate void DelMyEvent(); 
// consumer: 
class Consumer 
{ 
    Producer _theProducer; 
    void RegisterForNotification() 
    { 
     _theProducer.OnMyEvent = new DelMyEvent(OnMyEvent); 
    } 
    void OnMyEvent() { } 
} 
// producer: 
class Producer 
{ 
    public DelMyEvent OnMyEvent; 
    void SendNotification() 
    { 
     if(OnMyEvent != null) OnMyEvent(); 
    } 
} 

El mecanismo de eventos limpia esto un poco por prevenir al consumidor de ajustar el valor de delegado directamente. En cambio, hace que el consumidor se registre con el operador +=. Cuando el primer consumidor se registra, el delegado se establece, y cuando el segundo consumidor se registra, sus dos devoluciones de llamadas se encadenan juntas por Delegate.Combine.

Answer 3

¿Cuál es la diferencia entre usar el mecanismo de eventos y llamadas directas a otros métodos (por ejemplo, si una condición es se reunió en el método A() llamada B())?

Business logic wise no hay diferencia entre los dos. Lo que quiero decir con esto es que puedes lograr la misma tarea en todos los sentidos. Es solo una forma diferente de hacerlo. La diferencia real es la cantidad de trabajo que tiene que hacer para manejar la notificación de otros módulos.

Al plantear un evento, básicamente estás diciendo "hey, ha ocurrido algo de código que se ha registrado para recibir una notificación cuando esto sucedió, házselo saber. Los módulos que se notifican no me conciernen, porque estoy asumiendo que (en tiempo de ejecución) todos los módulos que necesitan saber están configurados para la notificación ".

Al llamar a cada método directamente, está tomando la decisión de indicarle a este (o a estos) módulos, y solo a éstos, que algo ha ocurrido. Usted está haciendo esa afirmación de que no importa en qué estado se encuentren estos módulos no es importante y necesitan saber que sucedió este evento.

Ambos son correctos para diferentes situaciones. Las notificaciones de eventos son más dinámicas. Diferentes módulos pueden registrarse y cancelar el registro de notificaciones. Las llamadas a métodos directos son más estáticas.Un cierto conjunto de objetos (o módulos, etc.) serán absolutamente notificados (salvo excepciones por supuesto) de que algo sucedió, pero solo estos serán notificados.

Answer 4

Además de los escenarios de suscriptores múltiples/sin susodicho, los eventos también se usan para reducir el acoplamiento de códigos, por ejemplo, el método A() no necesita saber nada sobre el método B() en tiempo de compilación. Esto permite una mejor separación de preocupaciones y un código menos frágil.

En la naturaleza, es más probable que vea eventos usados ​​en el marco y código de UI, mientras que dentro de la lógica de dominio de una aplicación los desarrolladores utilizan más a menudo cosas como Separated Interface y Dependency Injection para desacoplar el código. Recientemente ha habido un poco más de discusión en varios ámbitos con respecto al uso de eventos dentro de la lógica del dominio, un enfoque que astutamente se llama Domain Events.

Answer 5

La diferencia es la siguiente:

llamada al método = "Haz esto cosa específica"

Evento elevar = "Si alguien está escuchando y se preocupa, esto acaba de suceder."

Es fundamental para la Separación de Preocupaciones y la reutilización. Un botón no es un componente reutilizable si al hacer clic en él se llama a un método específico. Pero si simplemente "anuncia" al programa que se hizo clic, y las partes interesadas son responsables de suscribirse a eso, es infinitamente reutilizable.

La implementación técnica subyacente de cómo se realiza esto (a través del delegado) es irrelevante.

Answer 6

Para cualquiera que esté interesado en la realización de llamadas de eventos, he hecho este sencillo punto de referencia. Muestra las diferencias entre llamar a un método directamente, llamarlo a través de la interfaz, a través de un delegado y a través de un evento, donde se adjunta un controlador.

En cada escenario, el método se llama de manera correspondiente 1 000 000 000 veces. Aquí hay resultados (tal vez sorprendentes):

llamada Delegado: 23 240 ms - el más rápido de llamadas

Evento: 23 295 ms

llamada directa: 23 396 ms

llamada

Interfaz: 23 716 ms - el más lento

Las medidas se realizaron en la compilación de lanzamiento usando C# en .NET4.0.

El código está aquí:

class Program 
{ 
    static void Main(string[] args) 
    { 
     TestClass.RunTest(); 
     Console.ReadLine(); 
    } 
} 

interface ITestClass 
{ 
    void TestMethod(object sender, TestEventArgs eventErgs); 
} 

class TestClass : ITestClass 
{ 
    #region Events 

    event EventHandler<TestEventArgs> TestEvent; 

    #endregion 

    #region Constructor 

    public TestClass() 
    { 
     TestEvent += TestMethod; 
    } 

    #endregion 

    #region Public Methods 

    public static void RunTest() 
    { 
     int testCount = 1000000000; //1 000 000 000 

     string format = "{0:### ### ### ##0}"; 

     #region Direct Call 

     Console.WriteLine("Direct call"); 
     TestClass testClass = new TestClass(); 

     testClass.TestMethod(testClass, new TestEventArgs(3)); 

     Stopwatch stopwatch = Stopwatch.StartNew(); 
     for (int i = 0; i < testCount; ++i) 
     { 
      testClass.TestMethod(testClass, new TestEventArgs(3)); 
     } 
     stopwatch.Stop(); 
     Console.WriteLine(string.Format(format, stopwatch.ElapsedMilliseconds)); 
     Console.WriteLine(); 

     #endregion 

     #region Interface Call 

     Console.WriteLine("Interface call"); 
     ITestClass itestClass = new TestClass(); 
     itestClass.TestMethod(testClass, new TestEventArgs(3)); 

     stopwatch = Stopwatch.StartNew(); 
     for (int i = 0; i < testCount; ++i) 
     { 
      itestClass.TestMethod(testClass, new TestEventArgs(3)); 
     } 
     stopwatch.Stop(); 
     Console.WriteLine(string.Format(format, stopwatch.ElapsedMilliseconds)); 
     Console.WriteLine(); 

     #endregion 

     #region Delegate Call 

     Console.WriteLine("Delegate call"); 
     TestClass delegateTestClass = new TestClass(); 
     Action<object, TestEventArgs> delegateMethod = delegateTestClass.TestMethod; 
     delegateMethod(testClass, new TestEventArgs(3)); 

     stopwatch = Stopwatch.StartNew(); 
     for (int i = 0; i < testCount; ++i) 
     { 
      delegateMethod(testClass, new TestEventArgs(3)); 
     } 
     stopwatch.Stop(); 
     Console.WriteLine(string.Format(format, stopwatch.ElapsedMilliseconds)); 
     Console.WriteLine(); 

     #endregion 

     #region Event Call 

     Console.WriteLine("Event call"); 
     TestClass eventTestClast = new TestClass(); 
     eventTestClast.TestEvent(testClass, new TestEventArgs(3)); 

     stopwatch = Stopwatch.StartNew(); 
     for (int i = 0; i < testCount; ++i) 
     { 
      eventTestClast.TestEvent(testClass, new TestEventArgs(3)); 
     } 
     stopwatch.Stop(); 
     Console.WriteLine(string.Format(format, stopwatch.ElapsedMilliseconds)); 
     Console.WriteLine(); 

     #endregion 
    } 

    #endregion 

    #region ITestClass Members 

    public void TestMethod(object sender, TestEventArgs e) 
    { 
     e.Result = e.Value * 3; 
    } 

    #endregion 
} 

class TestEventArgs : EventArgs 
{ 
    public int Value { get; private set; } 

    public int Result { get; set; } 

    public TestEventArgs(int value) 
    { 
     Value = value; 
    } 
}