see - Cómo enviar eventos en C#

see cref c#

Question

Deseo crear eventos propios y despacharlos. Nunca había hecho esto antes en C #, solo en Flex ... Supongo que debe haber muchas diferencias.

¿Alguien puede darme un buen ejemplo?

Answer 1

Hay un patrón que se utiliza en todas las clases de la biblioteca. También se recomienda para sus propias clases, especialmente para el código del marco / biblioteca. Pero nadie lo detendrá cuando se desvíe o se salte unos pasos.

Aquí hay un esquema basado en el delegado de eventos más simple, System.Eventhandler .

// The delegate type. This one is already defined in the library, in the System namespace
// the `void (object, EventArgs)` signature is also the recommended pattern
public delegate void Eventhandler(object sender, Eventargs args);
// your publishing class
class Foo
{
public event EventHandler Changed; // the Event
protected virtual void OnChanged() // the Trigger method, called to raise the event
{
// make a copy to be more thread-safe
EventHandler handler = Changed;
if (handler != null)
{
// invoke the subscribed event-handler(s)
handler(this, EventArgs.Empty);
}
}
// an example of raising the event
void SomeMethod()
{
if (...) // on some condition
OnChanged(); // raise the event
}
}

Y cómo usarlo:

// your subscribing class
class Bar
{
public Bar()
{
Foo f = new Foo();
f.Changed += Foo_Changed; // Subscribe, using the short notation
}
// the handler must conform to the signature
void Foo_Changed(object sender, EventArgs args) // the Handler (reacts)
{
// the things Bar has to do when Foo changes
}
}

Y cuando tengas información para transmitir:

class MyEventArgs : EventArgs // guideline: derive from EventArgs
{
public string Info { get; set; }
}
class Foo
{
public event EventHandler<MyEventArgs> Changed; // the Event
...
protected virtual void OnChanged(string info) // the Trigger
{
EventHandler handler = Changed; // make a copy to be more thread-safe
if (handler != null)
{
var args = new MyEventArgs(){Info = info}; // this part will vary
handler(this, args);
}
}
}
class Bar
{
void Foo_Changed(object sender, MyEventArgs args) // the Handler
{
string s = args.Info;
...
}
}

Actualizar

Comenzando con C # 6, el código de llamada en el método ''Disparador'' se ha vuelto mucho más fácil, la prueba nula se puede acortar con el operador condicional nulo ?. sin hacer una copia manteniendo la seguridad del hilo:

protected virtual void OnChanged(string info) // the Trigger
{
var args = new MyEventArgs{Info = info}; // this part will vary
Changed?.Invoke(this, args);
}

Answer 2

Los eventos en C # usan delegados.

public static event EventHandler<EventArgs> myEvent;
static void Main()
{
//add method to be called
myEvent += Handler;
//call all methods that have been added to the event
myEvent(this, EventArgs.Empty);
}
static void Handler(object sender, EventArgs args)
{
Console.WriteLine("Event Handled!");
}

Answer 3

Mira en ''delegates''.

• Definir un delegado
• Utilice el tipo de delegado como campo / propiedad (agregando la palabra clave ''Evento'')
• Ahora está exponiendo los eventos que los usuarios pueden conectar con "+ = MyEventMethod";

Espero que esto ayude,

Answer 4

Use el patrón de eventos típico de .NET y suponga que no necesita ningún argumento especial en su evento. Tu patrón típico de evento y envío se ve así.

public class MyClassWithEvents
{
public event EventHandler MyEvent;
protected void OnMyEvent(object sender, EventArgs eventArgs)
{
if (MyEvent != null)
{
MyEvent(sender, eventArgs);
}
}
public void TriggerMyEvent()
{
OnMyEvent(sender, eventArgs);
}
}

Atar algo al evento puede ser tan simple como:

public class Program
{
public static void Main(string[] args)
{
MyClassWithEvents obj = new MyClassWithEvents();
obj.MyEvent += obj_myEvent;
}
private static void obj_myEvent(object sender, EventArgs e)
{
//Code called when my event is dispatched.
}
}

Eche un vistazo a los enlaces en esta página de MSDN