Entiendo cómo funcionan los eventos en C# (soy un novato justo en este campo). Lo que intento entender es por qué usamos eventos.¿Por qué usar Eventos?
¿Conoces una aplicación bien codificada/diseñada que utiliza eventos?
** resto del mensaje cortó y se puso en como una respuesta **
Para dar un ejemplo concreto mundo normal ....
Tiene un formulario, el formulario tiene un cuadro de lista. Hay una buena clase feliz para el listbox. Cuando el usuario selecciona algo del cuadro de lista, desea saber y modificar otras cosas en el formulario.
Sin eventos:
Se derivan del cuadro de lista, anulando cosas para asegurarse de que su padre es la forma que espera estar en. Anula un método ListSelected o algo así, que manipula otras cosas en su formulario principal.
Con eventos: Su formulario escucha el evento para indicar que un usuario ha seleccionado algo, y manipula otras cosas en el formulario.
La diferencia es que en el caso sin eventos ha creado una clase de propósito único, y también una que está estrechamente ligada al entorno en el que espera estar. En el caso con eventos, el código que manipula su el formulario está localizado en su formulario, y el cuadro de lista es, bueno, un cuadro de lista.
Siempre se puede construir su propio modo de envío/recepción de eventos, suscribirse/cancelar la suscripción a fuentes de eventos. Pero el lenguaje le ofrece una forma simple/estándar de hacerlo, por lo que es una buena razón para utilizar "eventos" de lenguaje en lugar de su propia técnica de eventos.
Además, usar el lenguaje "eventos" le permite hacer todo tipo de cosas interesantes utilizando la reflexión porque está estandarizado.
En cuanto a por qué usar una técnica de evento en absoluto. Hay todo tipo de ejemplos de la vida real donde esto es bastante útil y más simple de usar eventos. Los eventos son casi similares en su utilidad que los mensajes de Windows.
En el nivel conceptual más básico, los eventos son los que permiten que la computadora reaccione a lo que haces, en lugar de que se te exija que reacciones a lo que hace la computadora. Cuando está sentado frente a su PC con varias aplicaciones en ejecución (incluido el sistema operativo) y varios objetos clicables disponibles en cada contexto para que pueda elegir, los Eventos son lo que sucede cuando elige uno y todas las piezas involucradas pueden ser debidamente notificado.
Incluso al mover el mouse se inicia una secuencia de eventos (para mover el cursor, por ejemplo).
Puede implementar el Observer Pattern en C# con eventos y delegados.
Aquí hay un enlace a un artículo que describe como: http://blogs.msdn.com/bashmohandes/archive/2007/03/10/observer-pattern-in-c-events-delegates.aspx
alt text http://dofactory.com/Patterns/Diagrams/observer.gif
* esto solía ser en el cuerpo cuestión
Lo que sería muy útil es un no trivial ejemplo de una aplicación que utiliza eventos (¿supongo que realmente ayuda a probar también?)
Pensamientos hasta ahora son:
¿Por qué utilizar Eventos o publicar/suscribir?
Se puede notificar cualquier cantidad de clases cuando se produce un evento.
La suscripción clases no necesitan saber cómo el metrónomo (ver código de abajo) funciona, y el metrónomo no necesitan saber lo que van a hacer en respuesta al evento
El editor y los suscriptores están desacoplados por el delegado. Esto es altamente deseable ya que hace que el código sea más flexible y robusto. El metrónomo puede cambiar la forma en que detecta el tiempo sin romper ninguna de las clases que se suscriben. Las clases de suscripción pueden cambiar la forma en que responden a los cambios de tiempo sin romper el metrónomo. Las dos clases giran independientemente unas de otras, lo que hace que el código sea más fácil de mantener.
class Program
{
static void Main()
{
// setup the metronome and make sure the EventHandler delegate is ready
Metronome metronome = new Metronome();
// wires up the metronome_Tick method to the EventHandler delegate
Listener listener = new Listener(metronome);
ListenerB listenerB = new ListenerB(metronome);
metronome.Go();
}
}
public class Metronome
{
// a delegate
// so every time Tick is called, the runtime calls another method
// in this case Listener.metronome_Tick and ListenerB.metronome_Tick
public event EventHandler Tick;
// virtual so can override default behaviour in inherited classes easily
protected virtual void OnTick(EventArgs e)
{
// null guard so if there are no listeners attached it wont throw an exception
if (Tick != null)
Tick(this, e);
}
public void Go()
{
while (true)
{
Thread.Sleep(2000);
// because using EventHandler delegate, need to include the sending object and eventargs
// although we are not using them
OnTick(EventArgs.Empty);
}
}
}
public class Listener
{
public Listener(Metronome metronome)
{
metronome.Tick += new EventHandler(metronome_Tick);
}
private void metronome_Tick(object sender, EventArgs e)
{
Console.WriteLine("Heard it");
}
}
public class ListenerB
{
public ListenerB(Metronome metronome)
{
metronome.Tick += new EventHandler(metronome_Tick);
}
private void metronome_Tick(object sender, EventArgs e)
{
Console.WriteLine("ListenerB: Heard it");
}
}
Artículo completo que estoy escribiendo en mi sitio: http://www.programgood.net/
nb parte de este texto es de http://www.akadia.com/services/dotnet_delegates_and_events.html
Saludos.
este es un sitio de preguntas y respuestas, no es un blog ... si realmente quieres recibir comentarios aquí, reduce tu pregunta a ... solo la pregunta, y publica el resto como respuesta. – Shog9