Como: Publicar eventos que estão em conformidade com diretrizes do .NET estrutura (guia de programação translation from VPE for Csharp)

Artigo
08/25/2010

O procedimento a seguir demonstra como adicionar eventos que seguem o padrão .NET Framework padrão de suas próprias classes e estruturas. Todos sistema autônomo eventos no .NET Framework biblioteca de classes são baseados na EventHandler delegado é definido da seguinte forma:

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

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

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

Para publicar os eventos baseados em padrão EventHandler

(ignorar essa etapa e vá para etapa 3a se não tiver que enviar dados personalizados com o seu evento.) Declarar sua classe em um escopo visível para seu publicador e o assinante classes e adicionar os membros necessário para manter seus dados de evento personalizado.Neste exemplo, uma simples cadeia 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 estiver usando a versão genérica de EventHandler<TEventArgs> .) Declare um delegado na sua classe de publicação.Atribua um nome que termine 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 seguintes etapas.
1. Se nenhuma classe EventArgs personalizada, seu tipo de evento será delegado EventHandler não genérica.Não é necessário declará-lo porque já foi declarado no System namespace que está incluído quando você cria seu projeto translation from VPE for Csharp:
```
public event EventHandler RaiseCustomEvent;
```
2. Se você estiver usando a versão não-genéricas de EventHandler e você tem uma classe personalizada derivada de EventArgs, declarar seu evento dentro de sua classe de publicação e usar o delegado sistema autônomo o tipo de:
```
class Publisher
{
    public event CustomEventHandler RaiseCustomEvent;
}
```
3. Se você estiver usando a versão genérica, não é necessário um delegado personalizado.Em vez disso, especifique o tipo de evento sistema autônomo EventHandler<CustomEventArgs>, substituindo o nome de sua própria classe entre sistema autônomo colchetes.
```
public event EventHandler<CustomEventArgs> RaiseCustomEvent;
```

Exemplo

O exemplo a seguir demonstra sistema autônomo etapas anteriores fornecidas usando uma classe EventArgs personalizada e EventHandler<TEventArgs> sistema autônomo 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

Conceitos

Guia de Programação C#

Exemplo eventos

Referência

Eventos (Guia de programação do C#)

Representantes (guia de programação C#)

Delegate

Partilhar via