Curso de C#: Lição 14: Delegates

Esta lição ensina C # Interfaces. Os nossos objectivos são os seguintes: Entenda os Objetivos de Interfaces. Definir uma interface. Use uma interface. Implementar interface herança

Por | @oficinadanet Programação
Esta lição introduz delegados e eventos. Os nossos objetivos são os seguintes:

  • Entenda o que é um Delegates
  • Entenda o que é um evento
  • Implementar Delegates
  • Incêndio Eventos


Delegates


Durante lições anteriores, você aprendeu como referência para implementar tipos utilizando linguagem constrói como classes e interfaces. Estes tipos de referência permitiu-lhe criar instâncias de objetos e utilizá-las em especial as formas de realizar o seu software objectivos de desenvolvimento. Classes permitem que você crie objetos que continha membros com atributos ou comportamento. Interfaces permitiu-lhe declarar um conjunto de atributos e comportamento que todos os objetos a sua execução seria expor publicamente. Hoje, eu estou indo para introduzir um novo tipo de chamada de referência delegado.

Um delegate C # é um elemento que permite ao usuário um método de referência.Se você fosse um C ou C + + programador, esta seria uma boa, porque conhecemos um delegado é basicamente uma função ponteiro. No entanto, os desenvolvedores que têm utilizado outras línguas são provavelmente se perguntando, "Por que eu preciso de uma referência a um método?". A resposta resume-se a dar-lhe um máximo de flexibilidade para implementar qualquer funcionalidade que você quer no decorrer do processo.

Pense em 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. O que se 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 era um algoritmo que apoiaram algum tipo de estrutura de dados que você queria ter ordenado, mas você também quiser permitir que esta estrutura de dados para realizar diferentes tipos. Se você não sabe o que são os tipos, como você poderá decidir uma comparação adequada rotina? Talvez você possa se implementar um / então / senão mudar ou declaração de tratar bem conhecida de tipos, mas este ainda seria limitar e exigir a sobrecarga determinar o tipo. Outra alternativa seria para todos os tipos de implementar uma interface que declarou um método comum seu algoritmo seria chamada, o que é realmente uma solução agradável. 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 para o seu algoritmo e deixar que o contido método, que remete para o delegado, efectuar a comparação operação.

Tal operação é realizada na listagem 14-1.
 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 x=0; x < names.Length; x++)
        {
            for (int j=x; j < names.Length; j++)
            {
                // using delegate "compare" just like
                // a normal method
                if ( compare(names[x], names[j]) > 0 )
                {
                    temp = names[x];
                    names[x] = 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 em Listing 14-1 faz é declarar um delegate. Declarações delegate olhar um pouco como métodos, excepto as que tenham delegado modificador, são encerrados com um ponto e vírgula (;), e não têm qualquer aplicação.

A seguir, é a declaração de delegado 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 a Comparer delegado, pode ter qualquer nome, mas deve ter um primeiro parâmetro tipo de objeto, um segundo parâmetro tipo de objeto, e retornar um tipo int. O seguinte método de Listando 14-1 mostra um delegado manipulador método que está em conformidade com a assinatura do Comparer delegado.
 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 adequado para identificar o delegado manipulador método, como mostrado abaixo.
Comparer cmp = new Comparer(Name.CompareFirstNames);


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


Usando essa técnica, nenhum método pode ser delegado manipulador passado para o Ordenar () método em tempo de execução. ou seja, você poderia definir um método chamado manipulador CompareLastNames (), exemplificam um novo delegado Comparer exemplo, com ela, e passar o novo delegado para a Classificar () método.

Eventos


Console a funcionem aplicações tradicionais à espera de um usuário para pressionar uma tecla ou um tipo de comando e pressione a tecla Enter. Então eles executar alguns pré-definidos operação e quer sair ou retornar ao prompt inicial que eles começaram a partir de. Isso funciona, mas é inflexível em que tudo é com fios e segue um rígido caminho da execução. Em contraste gritante, modernos programas gráficos operam em um evento baseado em modelo. Isto é, um evento ocorre no sistema de módulos e os interessados sejam notificados para que eles possam reagir adequadamente. Com o Windows Forms, não existe um mecanismo de votação tendo-se recursos e você não tem um código de laço que se sente à espera de uma entrada. É construído em todos os eventos com o sistema.

O evento C #  é membro de uma classe que é ativado sempre que o evento foi projetado para ocorrer. Eu gosto de usar o termo "fogos" quando o evento é activado. Quem estiver interessado em caso pode se cadastrar e ser notificado assim que o evento incêndios. Na altura em que um caso de incêndios, registados métodos serão invocados.

Eventos e delegados trabalho de mão dada a proporcionar uma funcionalidade do programa. Começa com uma classe que declara um evento. Qualquer classe, incluindo a mesma classe que o evento é declarada 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 está registada para o evento. O delegado pode ser um dos pré-definidos. NET ou delegar-lhe uma declarar-se. Consoante o que for necessário, você atribui ao delegado para o evento, que efectivamente registos o método que será chamado quando o evento incêndios.

Listagem 14-2 mostra um jovem diferentes maneiras de implementar eventos.
 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 ou outra IDE, lembre-se de adicionar referências ao System.Drawing.dll e antes de compilar System.Windows.Forms.dll Listing 14,2 ou apenas adicionar o código a um projeto Windows Forms. Teaching the operation of Visual Studio or other IDE's is out-of-scope for this tutorial. Ensinar o funcionamento do Visual Studio ou outra IDE's está fora de alcance para este tutorial.

Você pode ter observado que Listing 14-2 é um programa Windows Forms. Embora eu não abrangidos Windows Forms neste tutorial, você deve saber suficiente sobre programação C #, em geral, que você não será perdido. Para ajudar, eu darei uma breve explicação de algumas das peças que você pode não estar familiarizado.

A classe herda Eventdemo Forma, essencialmente, que a torna um Windows Form. Isto dá-lhe automaticamente todas as funcionalidades de um formulário Windows, incluindo o seu Título Bar, Minimizar / Maximizar / Fechar botões, Sistema de Menu, e Fronteiras. Um lote de poder, que a herança coisa, eh?

A forma como um Windows Form da aplicação é iniciada a chamada é a Run () do método estático Application objeto com uma referência à forma como seu objeto parâmetro. Esta inicia-se subjacente a todas as canalizações Windows, exibe o GUI, e garante que os eventos são disparadas conforme o caso.

Vamos analisar o primeiro evento personalizado. Abaixo está a declaração evento, que é um membro da classe Eventdemo. É declarado o evento com a palavra-chave, um delegado tipo e, caso um nome.
public  event Startdelegate StartEvent;


Quem estiver interessado em um evento pode registrar Ligação por um delegado para esse evento. Na próxima linha, temos um delegado do tipo Startdelegate, que o evento foi declarada a aceitar, até o viciado StartEvent evento. A sintaxe + = registra um delegado com um evento. Para cancelar o registro em um evento, use o -= com a mesma sintaxe.
StartEvent += new Startdelegate(OnStartEvent);


Disparar um evento olha apenas como um método de chamada, como mostrado a seguir:
StartEvent ();


Esta foi a forma de implementar eventos a partir do zero, declara o evento e delegar-se. No entanto, grande parte da programação do evento você vai fazer será com eventos pré-definidos e delegate. Isto nos leva para o outro evento código que aparece na listagem 14-2, onde temos até um link de um delegate EventHandler Button Clique evento.
clickMe.Click +=  new EventHandler(OnClickMeClicked);


Clique O evento já pertence à classe Button e todos nós temos de fazer é referência quando se registar um delegado. Do mesmo modo, o delegado EventHandler já existe no Sistema namespace do. NET Quadros Class Library. Tudo o que você precisa fazer é definir o seu método callback (delegado método handler) que é invocado quando alguém apertar o botão Confira. O OnClickMeClicked () método, mostrado abaixo, está em conformidade com a assinatura do EventHander delegado, que você pode ver, no. NET Framework Class Library referência.
     public  void OnClickMeClicked(object sender, EventArgs ea)
    {
        MessageBox.Show("You Clicked My Button!");
    }


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

Resumo


Isso completa esta lição, que foi uma introdução aos delegados e eventos. Você aprendeu como a declarar e aplicar delegados, que prevêem dinâmica em tempo de execução método invocação de serviços. Você também sabe como declarar eventos e utilizá-las em um ou dois cenários diferentes. Uma forma é a de declarar o seu próprio caso, delegar e ch método a partir do zero. Outra maneira é utilizar a pré-existentes eventos e delegados e só aplicar o método callback, que irá lhe poupar tempo e tornar mais fácil codificação.

Artigo automaticamente traduzido de: http://www.csharp-station.com/Tutorials/Lesson14.aspx

Mais sobre: curso_c_sharp c_sharp Delegates
Share Tweet
Recomendado
Comentários
Carregar comentários
Destaquesver tudo