Usando representantes (guia de programação do C#)
A delegar é um tipo que encapsula com segurança um método, semelhante a um ponteiro de função em c e C++.Diferentemente dos ponteiros de função C, delegates são orientados a objetos, tipo seguros, e protegidos.O tipo de delegate é definido pelo nome do delegate.O exemplo a seguir declara um seemo delegate chamado Del que pode encapsular um método que recebe uma Sequência como um argumento e retorna Void:
public delegate void Del(string message);
Um objeto delegado normalmente é construído pela fornecendo o nome do método que o delegado será quebrado, ou com um método anônimo.Depois que um representante é instanciado, uma chamada de método feita para o representante será passada pelo representante para esse método.Os parâmetros passados para o representante pelo chamador são passados para o método, e o valor de retorno, se houver, do método é retornado para o chamador pelo representante.Isso é conhecido como chamar o representante.Um representante instanciado pode ser chamado como se fosse o método disposto próprio.Por exemplo:
// Create a method for a delegate.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// Instantiate the delegate.
Del handler = DelegateMethod;
// Call the delegate.
handler("Hello World");
Tipos delegate derivam o Delegate classe na.NET Framework.Tipos delegados são lacrado— não pode ser derivados — e não é possível derivar classes personalizadas de Delegate.Como o representante instanciado é um objeto, ele pode ser passado como um parâmetro, ou atribuído a uma propriedade.Isso permite que um método para aceitar um representante como um parâmetro, e chamar o representante em algum momento posterior.Isso é conhecido como um retorno de chamada assíncrono, e é um método comum de notificar um chamador quando um processo longo foi concluído.Quando um representante é usado em dessa maneira, o código usando o representante não precisa qualquer conhecimento da implementação do método sendo usado.A funcionalidade é semelhante ao encapsulamento fornecer interfaces.Para obter mais informações, consulte Quando se usar Delegates em vez de interfaces.
Outro uso comum de retornos de chamada é definir um método de comparação personalizado e passar esse representante para um método de classificação.Ele permite que o código do chamador para se tornar parte do algoritmo de classificação.O método exemplo a seguir usa o Del tipo como um parâmetro:
public void MethodWithCallback(int param1, int param2, Del callback)
{
callback("The number is: " + (param1 + param2).ToString());
}
Você pode então passar o representante criado acima para esse método:
MethodWithCallback(1, 2, handler);
e receber o seguinte saído para o console:
The number is: 3
Usando o delegado como uma abstração, MethodWithCallback não precisa chamar o console diretamente — ele não precisa ser projetado com um console, lembre-se.O que MethodWithCallback fazer é simplesmente preparar uma sequência e passar a sequência a outro método.Isso é especialmente eficiente uma vez que um método delegado pode usar qualquer número de parâmetros.
Quando um representante é construído para ajustar um método da instância, o representante referencia a instância e o método.Um representante possui sem conhecer o tipo de ocorrência exceto do método ele disposição, portanto, um representante pode referir-se a qualquer tipo de objeto, desde que não seja um método sobre esse objeto que corresponda a assinatura de representante.Quando um representante é construído para ajustar um método estático, ele somente referencia o método.Considere as seguintes declarações:
public class MethodClass
{
public void Method1(string message) { }
public void Method2(string message) { }
}
Juntamente com o estático DelegateMethod mostrado anteriormente, agora temos três métodos que podem ser delimitados por uma Del instância.
Mais de um método quando chamado pode chamar um representante.Isso é chamado para de difusão seletiva.Para adicionar um método adicional lista de delegado dos métodos — a lista de invocação — requer simplesmente adicionando dois delegados usando a adição ou operadores de atribuição de adição ('+' ou '+ =').Por exemplo:
MethodClass obj = new MethodClass();
Del d1 = obj.Method1;
Del d2 = obj.Method2;
Del d3 = DelegateMethod;
//Both types of assignment are valid.
Del allMethodsDelegate = d1 + d2;
allMethodsDelegate += d3;
Neste ponto allMethodsDelegate contém três métodos em sua lista de invocação —Method1, Method2, e DelegateMethod.Originais três representantes, d1, d2, e d3, permanecem inalterados.Quando allMethodsDelegate é invocado, todos os três métodos são chamados na ordem.Se o representante usa parâmetros de referência, a referência é passada sequencialmente para cada um dos três métodos por sua vez, e quaisquer alterações por um método estão visíveis para o próximo método.Quando qualquer um dos métodos gera uma exceção que não é detectada no método, que exceção é passada para o chamador do representante e nenhum método subsequentes na lista da chamada são chamados.E / ou se o representante tiver um valor de retorno sem parâmetros, ele retorna o valor de retorno e parâmetros do método último chamada.Para remover um método da lista da chamada, use o decrement ou Diminuir operador de atribuição ('-' ou '-= ').Por exemplo:
//remove Method1
allMethodsDelegate -= d1;
// copy AllMethodsDelegate while removing d2
Del oneMethodDelegate = allMethodsDelegate - d2;
Porque os tipos de delegado é derivada de System.Delegate, os métodos e propriedades definidas pela classe podem ser chamadas no delegado.Por exemplo, para localizar o número de métodos na lista da chamada Um do representante, você pode escrever:
int invocationCount = d1.GetInvocationList().GetLength(0);
Derivam de representantes com mais de um método na sua lista de invocação de MulticastDelegate, que é uma subclasse de System.Delegate.O código acima funciona em ambos os casos, porque o suporte de ambas as classes GetInvocationList.
Representantes de difusão seletiva são usadas extensivamente em Manipulação eventos.Objetos de origem de evento enviar notificações de eventos para objetos que foram registrados para receber esse evento destinatário.Para registrar um evento, para o destinatário cria um método projetado para manipular o evento, e cria um representante para esse método e passa o representante para a fonte de eventos.A fonte chama o representante quando o evento ocorre.O representante chama o evento tratamento método no destinatário, entregar os dados do evento.O tipo Delegate para um determinado evento é definido pela fonte de eventos.Para obter mais informações, consulte Eventos (guia de programação do C#).
Comparar representantes de dois tipos diferentes atribuídos no tempo compilação-resultará em um erro de compilação.Se as instâncias de delegado estaticamente são do tipo System.Delegate, em seguida, a comparação é permitida, mas executará retornou falso no tempo.Por exemplo:
delegate void Delegate1();
delegate void Delegate2();
static void method(Delegate1 d, Delegate2 e, System.Delegate f)
{
// Compile-time error.
//Console.WriteLine(d == e);
// OK at compile-time. False if the run-time type of f
// is not the same as that of d.
System.Console.WriteLine(d == f);
}
Consulte também
Referência
Representantes (guia de programação do C#)
O uso de variação em delegados (C# e Visual Basic)
Usando a variação para representantes genéricos Func e ação (C# e Visual Basic)
Eventos (guia de programação do C#)