How to: Publica os eventos que seguem.Diretrizes do NET Framework (guia de programação de C#)

Artigo
08/04/2011

O procedimento a seguir demonstra como adicionar eventos que sigam o padrão .NET Framework padrão para as 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);

Observação
O .NET Framework 2.0 apresenta uma versão genérica deste delegado, EventHandler<TEventArgs>. Os exemplos a seguir mostram como usar as duas versões.

Embora os eventos em classes que define por você podem ser baseados em qualquer tipo de delegado válido, delegados, mesmo que retornam um valor, normalmente é recomendável que você basear seus eventos de .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<TEventArgs> .) Declare um delegado na sua classe de publicação. Dê 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 que nenhuma classe EventArgs personalizada, o seu tipo de evento será delegado EventHandler não genéricas. Não é necessário declarar o delegado porque já foi declarado na System namespace incluída quando você cria seu C# projeto. Adicione o seguinte código à sua classe do publisher.
```
public event EventHandler RaiseCustomEvent;
```
2. Se você estiver usando a versão não-genéricas do EventHandler e você tem uma classe personalizada derivada de EventArgs, o seu evento dentro de sua classe de publicação de declarar 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, você não precisa um delegado personalizado. Em vez disso, na sua classe de publicação, você especificar o tipo de evento, como EventHandler<CustomEventArgs>, substituindo o nome de sua própria classe entre colchetes angulares.
```
public event EventHandler<CustomEventArgs> RaiseCustomEvent;
```

Exemplo

O exemplo a seguir demonstra as etapas anteriores por meio de uma classe EventArgs personalizada e EventHandler<TEventArgs> 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

Events (C# Programming Guide)

Delegates (C# Programming Guide)

Delegate

Conceitos

C# Programming Guide

Exemplo eventos

Partilhar via