Ultimate C# tuto/Lição 14 - Introdução aos Delegados e Eventos

[ÐλяkFeλя]

Lição 14 - Introdução aos Delegados e Eventos


Esta lição introduz delegados e eventos. Os nossos objectivos são os seguintes:

     * Entender O que um delegado é
     * Entender O que é um evento
     * Implementar Delegados
     * Fogo Eventos

Delegados

Durante lições anteriores, você aprendeu como referência para implementar tipos utilizando linguagem construtos tais como classes e interfaces. Estes tipos referência permitiu-lhe criar instâncias de objetos e usá-los em especial as formas de realizar seu desenvolvimento de software objetivos. Classes permitem a você criar objetos que continham membros com atributos ou comportamento. Interfaces permitiu-lhe declarar um conjunto de atributos e comportamento que todos os objetos que os apliquem iria expor publicamente. Hoje, eu estou indo para introduzir um novo tipo de referência chamado um delegado.

Um delegado linguagem C # é um elemento que lhe permite um método de referência. Se você fosse um programador C ou C, esta seria uma boa, porque conhecemos um delegado é basicamente uma função ponteiro. No entanto, os programadores que utilizaram outros idiomas provavelmente estão se perguntando, "Por que eu preciso de uma referência a um método?". A resposta resume-se a conferir-lhe maior flexibilidade para implementar qualquer funcionalidade que você quer em tempo de execução.

Pense sobre como você usa métodos agora. Você escreve um algoritmo que faz a sua coisa, manipulando os valores das variáveis e métodos chamando diretamente pelo nome. E se você quisesse um algoritmo que foi muito flexível, reutilizável, e permitiu-lhe implementar diferentes funcionalidades em caso de necessidade? Além disso, vamos dizer que este foi um algoritmo que apoiaram algum tipo de estrutura de dados que você queria ter classificado, mas quer também permitir que esta estrutura de dados para armazenar diferentes tipos. Se você não sabe o que são os tipos, como você pode decidir uma comparação apropriada rotina? Talvez você possa aplicar um caso / então / ou outra declaração alternar para lidar com tipos bem conhecidos, mas este ainda seria limitar e exigem sobrecarga para determinar o tipo. Outra alternativa seria que todos os tipos de implementar uma interface que declara um método comum que chamaria o seu algoritmo, que é realmente uma bela solução. No entanto, uma vez que esta lição é de cerca de delegados, vamos aplicar uma solução delegado, que é bastante elegante.

Você poderia resolver este problema passa por um delegado ao seu algoritmo e deixando que o contido método, que remete para o delegado, realize a comparação operação. Essa é uma operação realizada na listing 14-1.

Listing 14-1. Implementar um delegado e declara: SimpleDelegate.cs

Code Select Expand

using System;

// this is the delegate declaration
public delegate int Comparer(object obj1, object obj2);

public class Name
{
    public string FirstName = null;
    public string LastName = null;

    public Name(string first, string last)
    {
        FirstName = first;
        LastName = last;
    }

    // this is the delegate method handler
    public static int CompareFirstNames(object name1, object name2)
    {
        string n1 = ((Name)name1).FirstName;
        string n2 = ((Name)name2).FirstName;

        if (String.Compare(n1, n2) > 0)
        {
            return 1;
        }
        else if (String.Compare(n1, n2) < 0)
        {
            return -1;
        }
        else
        {
            return 0;
        }
    }

    public override string ToString()
    {
        return FirstName   " "   LastName;
    }
}

class SimpleDelegate
{
    Name[] names = new Name[5];

    public SimpleDelegate()
    {
        names[0] = new Name("Joe", "Mayo");
        names[1] = new Name("John", "Hancock");
        names[2] = new Name("Jane", "Doe");
        names[3] = new Name("John", "Doe");
        names[4] = new Name("Jack", "Smith");
    }

    static void Main(string[] args)
    {
        SimpleDelegate sd = new SimpleDelegate();

        // this is the delegate instantiation
        Comparer cmp = new Comparer(Name.CompareFirstNames);

        Console.WriteLine("\nBefore Sort: \n");

        sd.PrintNames();

        // observe the delegate argument
        sd.Sort(cmp);

        Console.WriteLine("\nAfter Sort: \n");

        sd.PrintNames();
    }

    // observe  the delegate parameter
    public void Sort(Comparer compare)
    {
        object temp;

        for (int i=0; i < names.Length; i  )
        {
            for (int j=i; j < names.Length; j  )
            {
                // using delegate "compare" just like
                // a normal method
                if ( compare(names[i], names[j]) > 0 )
                {
                    temp = names[i];
                    names[i] = names[j];
                    names[j] = (Name)temp;
                }
            }
        }
    }

    public void PrintNames()
    {
        Console.WriteLine("Names: \n");

        foreach (Name name in names)
        {
            Console.WriteLine(name.ToString());
        }
    }
}
A primeira coisa que o programa na listagem 14-1 faz é declarar um delegado. Delegado declarações olhar um pouco como métodos, com exceção de terem o delegado modificador, são encerrados com um ponto e vírgula {;}, e não têm aplicação. Abaixo, é o delegado da declaração Listing 14-1.

public delegate int Comparer(object obj1, object obj2);

Esta declaração define delegar a assinatura de um delegado manipulador que este método pode referir-se a delegar. O delegado manipulador método, para as Comparer delegado, pode ter qualquer nome, mas deve ter um primeiro parâmetro do tipo objeto, um segundo parâmetro do tipo objeto, e retornar um tipo int. O seguinte método de Listagem 14-1 mostra um delegado manipulador método que está em conformidade com a assinatura do delegado Comparer.

public static int CompareFirstNames(object name1, object name2)
    {
        ...
    }

Para usar um delegado, você deve criar uma instância do mesmo. A instância é criada, semelhante a uma classe exemplo, com um único parâmetro para identificar o método adequado delegado manipulador, conforme mostrado abaixo.

Comparer cmp = new Comparer(Name.CompareFirstNames);

O delegado, cmp, é então usado como parâmetro para o Sort () método, que utiliza-lo apenas como um método normal. Observar a forma como o delegado é passado para o Sort () método como um parâmetro no código abaixo.

sd.Sort (CMP);

Com esta técnica, qualquer delegado manipulador método podem ser passados para o Sort () método em tempo de execução. ou seja, você poderia definir um manipulador chamado método CompareLastNames (), Comparer delegado instanciar uma nova instância com ela, e passar o novo delegado para o Sort () método.

Eventos

Tradicionais aplicações funcionam Console pela espera de um usuário para pressionar uma tecla ou digitar um comando e pressione a tecla Enter. Em seguida, eles executar alguns pré-definido de operação e quer sair ou voltar para o original solicitação que eles começaram a partir. Esta obra, mas é inflexível em que tudo é hard-wired e segue uma rígida caminho de execução. Em contraste gritante, GUI modernos programas funcionem em um evento baseado em modelo. Ou seja, algum evento ocorre no sistema de módulos e os interessados são notificados para que eles possam reagir adequadamente. Com o Windows Forms, não existe um mecanismo de voto, tendo os recursos e você não tem um código de loop que se sente à espera de uma entrada. É tudo incorporadas ao sistema, com eventos.

AC # evento é uma classe membro que é ativado quando o evento foi projetado para ocorrer. Gosto de usar o termo "fogos", quando o evento é activado. Quem estiver interessado no evento podem inscrever e ser notificado logo que o caso de incêndios. Na altura em que um evento de incêndios, registrados métodos serão invocados.

Eventos e delegados trabalhar de mão dada para proporcionar uma funcionalidade do programa. Começa com uma classe que declara um evento. Qualquer classe, incluindo a mesma classe que o evento seja declarado em, pode registrar um dos seus métodos para o evento. Isso ocorre através de um delegado, que especifica a assinatura do método que é registrado para o evento. O delegado pode ser um dos pré-definidas. NET delegados ou uma que você declare-se. Seja qual for apropriado, você atribui o delegado para o evento, que efetivamente registra o método que será chamado quando o evento incêndios. Listing 14-2 mostra um casal diferentes maneiras de executar eventos.

Listing 14-2. Implementar e declara Ocorrências: Eventdemo.cs

Code Select Expand

using System;
using System.Drawing;
using System.Windows.Forms;

// custom delegate
public delegate void Startdelegate();

class Eventdemo : Form
{
    // custom event
    public event Startdelegate StartEvent;

    public Eventdemo()
    {
        Button clickMe = new Button();

        clickMe.Parent = this;
        clickMe.Text = "Click Me";
        clickMe.Location = new Point(
            (ClientSize.Width - clickMe.Width) /2,
            (ClientSize.Height - clickMe.Height)/2);

        // an EventHandler delegate is assigned
        // to the button's Click event
        clickMe.Click  = new EventHandler(OnClickMeClicked);

        // our custom "Startdelegate" delegate is assigned
        // to our custom "StartEvent" event.
        StartEvent  = new Startdelegate(OnStartEvent);

        // fire our custom event
        StartEvent();
    }

    // this method is called when the "clickMe" button is pressed
    public void OnClickMeClicked(object sender, EventArgs ea)
    {
        MessageBox.Show("You Clicked My Button!");
    }

    // this method is called when the "StartEvent" Event is fired
    public void OnStartEvent()
    {
        MessageBox.Show("I Just Started!");
    }

    static void Main(string[] args)
    {
        Application.Run(new Eventdemo());
    }
}
Nota: Se você estiver usando o Visual Studio IDE ou outro, lembre-se de adicionar referências ao System.Drawing.dll system.Windows.Forms.dll e antes de compilar Listing 14.2 ou simplesmente adicionar o código a um projeto Windows Forms. Ensinar o funcionamento do Visual Studio ou outras IDE's está fora de alcance para este tutorial.

Você deve ter notado que a listagem 14-2 é um programa do Windows Forms. Embora eu não tenha Windows Forms cobertos neste tutorial, você deve saber o suficiente sobre programação C #, em geral, que não será perdido. Para ajudar, eu vou dar uma breve explicação de algumas das peças que você pode não estar familiarizado.

A classe herda Eventdemo Form, que basicamente torna um Windows Form. Isto dá-lhe automaticamente todas as funcionalidades de um formulário do Windows, incluindo a Barra de título, Minimizar / Maximizar / Fechar botões, Menu Sistema, e Fronteiras. Um lote de potência, que a herança coisa, hein?

A forma como um Windows Form da aplicação é iniciada pela está chamando a Executar () método do objeto Application estático com uma referência à forma como seu objeto parâmetro. Isto inicia o Windows subjacente a todas as canalizações, exibe a interface gráfica, e assegura que os eventos são disparadas, conforme o caso.

Olhemos para o primeiro evento personalizado. Abaixo está a declaração evento, que é um membro da classe Eventdemo. É declarado o evento com a palavra-chave, digite um delegado, e um evento nome.

public event Startdelegate StartEvent;

Quem estiver interessado em um evento pode se registrar por ligação de um delegado para esse evento. Na linha seguinte, temos um delegado do tipo Startdelegate, que o evento foi declarada a aceitar, ligado ao StartEvent evento. = A sintaxe registra um delegado com um evento. Para cancelar o registro de um caso, o uso -= com a mesma sintaxe.

StartEvent = new Startdelegate (OnStartEvent);

Disparando um evento parece exatamente como um método chamada, conforme mostrado abaixo:

StartEvent ();

Esta foi a forma de implementar eventos a partir do zero, que declara o evento eo delegado-se. No entanto, grande parte da programação do evento você vai fazer vai ser com eventos pré-definidos e delegados. Isto nos leva ao outro evento código que você vê na listagem 14-2, onde ficou um EventHandler delegado para um evento Click Button.

clickMe.Click = new EventHandler (OnClickMeClicked);

O evento Click já pertence à classe Button e todos temos de fazer referência a ela quando for registrar um delegado. Da mesma forma, o delegado EventHandler já existe no sistema do namespace. NET Frameworks Class Library. Tudo que você realmente precisa fazer é definir o método de callback (delegado manipulador método) que é invocado quando alguém pressiona o botão Confira. O OnClickMeClicked () método, ilustrado abaixo, está em conformidade com a assinatura do EventHander delegado, que você pode olhar para cima no. NET Framework Class Library referência.

public void OnClickMeClicked (objeto sender, EventArgs e bis)
     (
         MessageBox.Show ( "Você Clicado Meu Button!");
     )

Confira a qualquer momento botão for pressionado com um rato, ele irá disparar o evento Click, que irá invocar o OnClickMeClicked () método. A classe Button cuida do disparo o evento Click e não há nada mais que você tem que fazer. Porque é tão fácil de usar a pré-definido de eventos e delegados, seria uma boa idéia para verificar se existem alguns que já vai fazer o que você precisa, antes de criar o seu próprio.


Resumo, Isso conclui esta lição, que era uma introdução aos delegados e eventos. Você aprendeu a declarar e implementar delegados, que proporcionam dinâmica em tempo de execução do método de invocação de serviços. Você sabe como também para declarar eventos e utilizá-las em um ou dois cenários diferentes. Uma forma é a de declarar o seu próprio evento, delegar e método chamada a partir do zero. Outra maneira é utilizar a pré-existente e eventos delegados e os resp só implementar método, que vai lhe poupar tempo e faça coding mais fácil.

CONTINUA.....


Dark Fear