Como publicar eventos em conformidade com as diretrizes do .NET Framework (Guia de Programação em C#)

Artigo
06/10/2015

O procedimento a seguir demonstra como adicionar eventos que seguem o padrão .NET Framework padrão a seu classes e estruturas. Todos os eventos do .NET Framework class library baseiam-se na EventHandler delegar, que é definido da seguinte maneira:

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

Dica

O .NET Framework 2,0 apresenta uma versão genérica deste delegado, EventHandler.Os exemplos a seguir mostram como usar as duas versões.

Embora as classes que você define os eventos podem ser baseados em qualquer tipo de delegado válido, delegados, mesmo que retornam um valor, geralmente é recomendado que você basear seus eventos na .NET Framework padrão usando EventHandler, conforme mostrado no exemplo a seguir.

Para publicar os eventos com base no padrão EventHandler

(Pule esta etapa e vá para a etapa 3a, se você não precisa enviar dados personalizados com o seu evento). Declare a classe de dados personalizados em um escopo que é visível para as classes de seu editor e o assinante. Em seguida, adicione membros necessários para manter seus dados de evento personalizado. Neste exemplo, uma simple seqüência de caracteres é retornada.
```
public class CustomEventArgs : EventArgs
{
    public CustomEventArgs(string s)
    {
        msg = s;
    }
    private string msg;
    public string Message
    {
        get { return msg; }
    } 
}
```
(Pule esta etapa, se você estiver usando a versão genérica do EventHandler .) Declare um delegado na sua classe de publicação. Atribua um nome que termina com EventHandler. O segundo parâmetro especifica o tipo EventArgs personalizado.
```
public delegate void CustomEventHandler(object sender, CustomEventArgs a);
```
Declare o evento na sua classe de publicação usando uma das etapas a seguir.
1. Se você não tiver nenhuma classe EventArgs personalizada, seu tipo de evento será delegado EventHandler não genérico. Você não precisa declarar o delegado porque ele já está declarado na System espaço para nome que é incluído quando você criar o projeto C#. Adicione o seguinte código à sua classe do publisher.
```
public event EventHandler RaiseCustomEvent;
```
2. Se você estiver usando a versão não genérica do EventHandler e você tem uma classe personalizada derivada de EventArgs, declarar seu evento dentro de sua classe de publicação e usar o seu representante da etapa 2 como o tipo.
```
public event CustomEventHandler RaiseCustomEvent;
```
3. Se você estiver usando a versão genérica, não é necessário um delegado personalizado. Em vez disso, na sua classe de publicação, você especifica o tipo de evento como EventHandler<CustomEventArgs>, substituindo o nome de sua própria classe entre os colchetes angulares.
```
public event EventHandler<CustomEventArgs> RaiseCustomEvent;
```

Exemplo

O exemplo a seguir demonstra as etapas anteriores, usando uma classe EventArgs personalizada e EventHandler como o 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();

        }
    }
}

Consulte também

Referência

Eventos (Guia de Programação em C#)

Delegados (Guia de Programação em C#)

Delegate

Conceitos

Guia de Programação em C#

Share via