Procedimiento Publicar eventos que cumplan las directrices de .NET (guía de programación de C#)

  • Artículo

En el siguiente procedimiento se muestra cómo agregar eventos que cumplan el patrón de .NET estándar a las clases y structs. Todos los eventos de la biblioteca de clases de .NET se basan en el delegado EventHandler, que se define de la siguiente manera:

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

Nota:

.NET Framework 2.0 incluye una versión genérica de este delegado, EventHandler<TEventArgs>. En los siguientes ejemplos se muestra cómo usar las dos 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, por lo general se recomienda que base los eventos en el patrón de .NET mediante EventHandler, como se muestra en el ejemplo siguiente.

El nombre EventHandler puede dar lugar a un poco de confusión, ya que realmente no controla el evento. EventHandler y EventHandler<TEventArgs> genérico son tipos de delegado. Un método o una expresión lambda cuya firma coincide con la definición de delegado es el controlador de eventos y se invocará cuando se genere el evento.

Publicación de eventos basados en el patrón EventHandler

  1. (Omita este paso y vaya al paso 3a si no tiene que enviar datos personalizados con el evento). Declare la clase de los datos personalizados en un ámbito que sea visible para las clases de publicador y suscriptor. Luego, agregue los miembros necesarios para almacenar los datos de eventos personalizados. En este ejemplo se devuelve una cadena simple.

    public class CustomEventArgs : EventArgs
{
    public CustomEventArgs(string message)
    {
        Message = message;
    }

    public string Message { get; set; }
}

  2. (Omita este paso si usa la versión genérica de EventHandler<TEventArgs>). Declare un delegado en la clase de publicación. Asígnele un nombre que termine con EventHandler. El segundo parámetro especifica el tipo EventArgs personalizado.

    public delegate void CustomEventHandler(object? sender, CustomEventArgs args);

  3. Declare el evento en la clase de publicación llevando a cabo uno de los siguientes pasos.

    1. Si no tiene ninguna clase EventArgs personalizada, el tipo Event será el delegado EventHandler no genérico. No es necesario declarar el delegado, porque ya está declarado en el espacio de nombres System que se incluye al crear el proyecto de C#. Agregue el código siguiente a la clase de 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 usa la versión genérica, no necesita ningún delegado personalizado. En su lugar, en la clase de publicación, especifique el tipo de evento como EventHandler<CustomEventArgs>, sustituyendo el nombre de su propia clase que aparece entre corchetes angulares.

      public event EventHandler<CustomEventArgs>? RaiseCustomEvent;

Ejemplo

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

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

        public string Message { get; set; }
    }

    // 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("Event triggered"));
        }

        // 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>? raiseEvent = RaiseCustomEvent;

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

                // Call to raise the event.
                raiseEvent(this, e);
            }
        }
    }

    //Class that subscribes to an event
    class Subscriber
    {
        private readonly string _id;

        public Subscriber(string id, Publisher pub)
        {
            _id = id;

            // Subscribe to the event
            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: {e.Message}");
        }
    }

    class Program
    {
        static void Main()
        {
            var pub = new Publisher();
            var sub1 = new Subscriber("sub1", pub);
            var sub2 = new Subscriber("sub2", pub);

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

            // Keep the console window open
            Console.WriteLine("Press any key to continue...");
            Console.ReadLine();
        }
    }
}

Consulte también