Cómo: Publicar eventos que cumplan las directrices de .NET Framework (Guía de programación de C#)

Artículo
08/10/2011

En el procedimiento siguiente se muestra cómo puede agregar eventos que se ajusten al modelo estándar de .NET Framework en sus propias clases y structs. Todos los eventos de la biblioteca de clases .NET Framework se basan en el delegado EventHandler, que se define del modo siguiente:

public delegate void EventHandler(object sender, EventArgs e);

Nota

.NET Framework 2.0 incluye una versión genérica de este delegado, EventHandler<TEventArgs>. Los ejemplos siguientes muestran cómo utilizar ambas versiones.

Aunque los eventos de las clases que defina se pueden basar en cualquier tipo de delegado válido, incluidos los delegados que devuelven un valor, normalmente es aconsejable que los eventos se basen en el modelo de .NET Framework a través de EventHandler, como se muestra en el ejemplo siguiente.

Para publicar eventos basados en el modelo EventHandler

(Omita este paso y vaya directamente al paso 3a si no tiene que enviar datos personalizados con el evento). Declare la clase de sus datos personalizados en un ámbito que sea visible para las clases del publicador y del suscriptor. A continuación, agregue los miembros necesarios para que contengan los datos de evento personalizados. En este ejemplo, se devuelve una cadena simple.
```
public class CustomEventArgs : EventArgs
{
    public CustomEventArgs(string s)
    {
        msg = s;
    }
    private string msg;
    public string Message
    {
        get { return msg; }
    } 
}
```
(Omita este paso si utiliza la versión genérica de EventHandler<TEventArgs>). Declare un delegado en la clase de publicación. Asígnele un nombre que acabe en EventHandler. El segundo parámetro especifica el tipo EventArgs personalizado.
```
public delegate void CustomEventHandler(object sender, CustomEventArgs a);
```
Declare el evento en la clase de publicación mediante alguno de los procedimientos siguientes.
1. Si no tiene ninguna clase EventArgs personalizada, el tipo Event será el delegado EventHandler no genérico. No necesita declarar el delegado porque ya está declarado en el espacio de nombres System que se incluyó al crear el proyecto de C#. Agregue el código siguiente a la clase del publicador.
```
public event EventHandler RaiseCustomEvent;
```
2. Si usa la versión no genérica de EventHandler y tiene una clase personalizada derivada de EventArgs, declare el evento dentro de la clase de publicación y use el delegado del paso 2 como tipo.
```
public event CustomEventHandler RaiseCustomEvent;
```
3. Si utiliza la versión genérica, no necesita un delegado personalizado. En lugar de ello, en la clase de publicación, especifique el tipo de evento como EventHandler<CustomEventArgs> y sustituya el nombre de su propia clase incluido entre corchetes angulares.
```
public event EventHandler<CustomEventArgs> RaiseCustomEvent;
```

Ejemplo

En el ejemplo siguiente se muestran los pasos anteriores con una clase EventArgs personalizada y EventHandler<TEventArgs> como tipo de evento.

namespace DotNetEvents
{
    using System;
    using System.Collections.Generic;

    // Define a class to hold custom event info
    public class CustomEventArgs : EventArgs
    {
        public CustomEventArgs(string s)
        {
            message = s;
        }
        private string message;

        public string Message
        {
            get { return message; }
            set { message = value; }
        }
    }

    // Class that publishes an event
    class Publisher
    {

        // Declare the event using EventHandler<T>
        public event EventHandler<CustomEventArgs> RaiseCustomEvent;

        public void DoSomething()
        {
            // Write some code that does something useful here
            // then raise the event. You can also raise an event
            // before you execute a block of code.
            OnRaiseCustomEvent(new CustomEventArgs("Did something"));

        }

        // Wrap event invocations inside a protected virtual method
        // to allow derived classes to override the event invocation behavior
        protected virtual void OnRaiseCustomEvent(CustomEventArgs e)
        {
            // Make a temporary copy of the event to avoid possibility of
            // a race condition if the last subscriber unsubscribes
            // immediately after the null check and before the event is raised.
            EventHandler<CustomEventArgs> handler = RaiseCustomEvent;

            // Event will be null if there are no subscribers
            if (handler != null)
            {
                // Format the string to send inside the CustomEventArgs parameter
                e.Message += String.Format(" at {0}", DateTime.Now.ToString());

                // Use the () operator to raise the event.
                handler(this, e);
            }
        }
    }

    //Class that subscribes to an event
    class Subscriber
    {
        private string id;
        public Subscriber(string ID, Publisher pub)
        {
            id = ID;
            // Subscribe to the event using C# 2.0 syntax
            pub.RaiseCustomEvent += HandleCustomEvent;
        }

        // Define what actions to take when the event is raised.
        void HandleCustomEvent(object sender, CustomEventArgs e)
        {
            Console.WriteLine(id + " received this message: {0}", e.Message);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Publisher pub = new Publisher();
            Subscriber sub1 = new Subscriber("sub1", pub);
            Subscriber sub2 = new Subscriber("sub2", pub);

            // Call the method that raises the event.
            pub.DoSomething();

            // Keep the console window open
            Console.WriteLine("Press Enter to close this window.");
            Console.ReadLine();

        }
    }
}

Vea también

Referencia

Eventos (Guía de programación de C#)

Delegados (Guía de programación de C#)

Delegate

Conceptos

Guía de programación de C#

Diseño de eventos

Compartir a través de