Eventos (C# vs. Java)

Um evento é uma forma de uma classe notificar sistema autônomo usuários de um objeto quando algo interessante acontece neste objeto, sistema autônomo, clicando em um controle em uma interface gráfica do usuário.Esta notificação é chamada de disparar um evento.O objeto que gera um evento é conhecido sistema autônomo fonte ou o remetente do evento.

Ao contrário de manipulação de eventos no Java, que é executada com a implementação de classes de ouvinte personalizado, os desenvolvedores translation from VPE for Csharp podem usar representantes para a manipulação de eventos.Um delegado é um tipo que encapsula um método.Depois que um delegado é inicializado com um método, ele se comporta exatamente como esse método e pode ser chamado com o operador ().É semelhante a um ponteiro de função do C++, mas é fortemente tipado.

O delegado pode ser usado sistema autônomo qualquer Outros método, parâmetros e um valor retornado, sistema autônomo neste exemplo:

public delegate int ReturnResult(int x, int y);

Para obter mais informações sobre delegados, consulte Representantes (guia de programação C#).

Eventos, assim como os métodos, tem uma assinatura que inclui um nome e uma lista de parâmetros.Esta assinatura é definida por um tipo de delegado, por exemplo:

public delegate void MyEventHandler(object sender, System.EventArgs e);

Na programação de interface do usuário do Windows, é comum ter o primeiro parâmetro sistema autônomo objeto referir-se fonte do evento e o segundo parâmetro sistema autônomo objeto transportar dados relacionados ao evento.No entanto, esse design não necessários ou imposto pelo linguagem translation from VPE for Csharp; uma assinatura de evento pode ser o mesmo que qualquer assinatura do delegado válida, desde que ele retorna void.

Um evento pode ser declarado usando a event palavra-chave como neste exemplo:

public event MyEventHandler TriggerIt;

Para acionar o evento, defina o método seja chamado quando o evento é gerado como neste exemplo:

public void Trigger()
{
    TriggerIt();
}

Para acionar um evento, chamar o delegado e passar os parâmetros relacionados ao evento.O delegado chama os manipuladores que foram adicionados ao evento.Cada evento pode ter mais de um manipulador atribuído ao receber o evento.Nesse caso, o evento chama cada receptor automaticamente.Disparar um evento requer apenas uma telefonar para o evento independentemente do número de destinatários.

Se desejar que uma classe para receber um evento, assinar esse evento adicionando o delegado para o evento usando o += operador, por exemplo:

myEvent.TriggerIt += myEvent.MyMethod;

Para cancelar a inscrição de um evento, remova o delegado do evento usando o -= operador, por exemplo:

myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod);

For more information on events, see Eventos (Guia de programação do C#).

Observação:
Em translation from VPE for Csharp 2.0, delegados podem encapsular os métodos anônimo e métodos nomeados.Para obter mais informações sobre métodos anônimo, consulte Métodos anônimos (Guia de programação do C#).

Exemplo

Descrição

O exemplo a seguir define um evento com três métodos associados a ele.Quando o evento é acionado os métodos são executados.Um método é removido o evento e o evento é acionado novamente.

Código

// Declare the delegate handler for the event:
public delegate void MyEventHandler();

class TestEvent
{
    // Declare the event implemented by MyEventHandler.
    public event MyEventHandler TriggerIt;

    // Declare a method that triggers the event:
    public void Trigger()
    {
        TriggerIt();
    }
    // Declare the methods that will be associated with the TriggerIt event.
    public void MyMethod1()
    {
        System.Console.WriteLine("Hello!");
    }
    public void MyMethod2()
    {
        System.Console.WriteLine("Hello again!");
    }
    public void MyMethod3()
    {
        System.Console.WriteLine("Good-bye!");
    }

    static void Main()
    {
        // Create an instance of the TestEvent class.
        TestEvent myEvent = new TestEvent();

        // Subscribe to the event by associating the handlers with the events:
        myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod1);
        myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod2);
        myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod3);
        // Trigger the event:
        myEvent.Trigger();

        // Unsuscribe from the the event by removing the handler from the event:
        myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod2);
        System.Console.WriteLine("\"Hello again!\" unsubscribed from the event."); 

        // Trigger the new event:
        myEvent.Trigger();
    }
}

Saída

Hello!
Hello again!
Good-bye!
"Hello again!" unsubscribed from the event.
Hello!
Good-bye!

Consulte também

Conceitos

Guia de Programação C#

Referência

evento (translation from VPE for Csharp Reference)

delegado (referência C#) 

Outros recursos

Translation from VPE for Csharp para desenvolvedores Java