Delegate Classe

  • Referência

Definição

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Representa um representante que é uma estrutura de dados que faz referência a um método estático ou a uma classe e a um método de instância daquela classe.

public ref class Delegate abstract
public ref class Delegate abstract : ICloneable, System::Runtime::Serialization::ISerializable
public abstract class Delegate
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
type Delegate = class
type Delegate = class
    interface ICloneable
    interface ISerializable
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
type Delegate = class
    interface ICloneable
    interface ISerializable
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Delegate = class
    interface ICloneable
    interface ISerializable
Public MustInherit Class Delegate
Public MustInherit Class Delegate
Implements ICloneable, ISerializable
Herança
Object
Delegate
Derivado
Atributos
ClassInterfaceAttribute SerializableAttribute ComVisibleAttribute
Implementações
ICloneable ISerializable

Exemplos

O exemplo a seguir mostra como definir um delegado chamado myMethodDelegate. As instâncias desse delegado são criadas para um método de instância e um método estático da classe aninhada mySampleClass . O delegado para o método de instância requer uma instância de mySampleClass. A mySampleClass instância é salva em uma variável chamada mySC.

using namespace System;
delegate String^ myMethodDelegate( // Declares a delegate for a method that takes in an int and returns a String.
int myInt );

// Defines some methods to which the delegate can point.
ref class mySampleClass
{
public:

   // Defines an instance method.
   String^ myStringMethod( int myInt )
   {
      if ( myInt > 0 )
            return ("positive");

      if ( myInt < 0 )
            return ("negative");

      return ("zero");
   }


   // Defines a static method.
   static String^ mySignMethod( int myInt )
   {
      if ( myInt > 0 )
            return ("+");

      if ( myInt < 0 )
            return ("-");

      return ("");
   }

};

int main()
{
   
   // Creates one delegate for each method. For the instance method, an 
   // instance (mySC) must be supplied. For the static method, only the
   // method name is needed.
   mySampleClass^ mySC = gcnew mySampleClass;
   myMethodDelegate^ myD1 = gcnew myMethodDelegate( mySC, &mySampleClass::myStringMethod );
   myMethodDelegate^ myD2 = gcnew myMethodDelegate( mySampleClass::mySignMethod );
   
   // Invokes the delegates.
   Console::WriteLine( "{0} is {1}; use the sign \"{2}\".", 5, myD1( 5 ), myD2( 5 ) );
   Console::WriteLine( "{0} is {1}; use the sign \"{2}\".",  -3, myD1(  -3 ), myD2(  -3 ) );
   Console::WriteLine( "{0} is {1}; use the sign \"{2}\".", 0, myD1( 0 ), myD2( 0 ) );
}

/*
This code produces the following output:

5 is positive; use the sign "+".
-3 is negative; use the sign "-".
0 is zero; use the sign "".
*/

using System;
public class SamplesDelegate  {

   // Declares a delegate for a method that takes in an int and returns a string.
   public delegate string myMethodDelegate( int myInt );

   // Defines some methods to which the delegate can point.
   public class mySampleClass  {

      // Defines an instance method.
      public string myStringMethod ( int myInt )  {
         if ( myInt > 0 )
            return( "positive" );
         if ( myInt < 0 )
            return( "negative" );
         return ( "zero" );
      }

      // Defines a static method.
      public static string mySignMethod ( int myInt )  {
         if ( myInt > 0 )
            return( "+" );
         if ( myInt < 0 )
            return( "-" );
         return ( "" );
      }
   }

   public static void Main()  {

      // Creates one delegate for each method. For the instance method, an
      // instance (mySC) must be supplied. For the static method, use the
      // class name.
      mySampleClass mySC = new mySampleClass();
      myMethodDelegate myD1 = new myMethodDelegate( mySC.myStringMethod );
      myMethodDelegate myD2 = new myMethodDelegate( mySampleClass.mySignMethod );

      // Invokes the delegates.
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", 5, myD1( 5 ), myD2( 5 ) );
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", -3, myD1( -3 ), myD2( -3 ) );
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", 0, myD1( 0 ), myD2( 0 ) );
   }
}


/*
This code produces the following output:

5 is positive; use the sign "+".
-3 is negative; use the sign "-".
0 is zero; use the sign "".
*/

// Declares a delegate for a method that takes in an int and returns a string.
type MyMethodDelegate = delegate of int -> string

// Defines some methods to which the delegate can point.
type MySampleClass() =
    // Defines an instance method.
    member _.MyStringMethod(myInt) =
        if myInt > 0 then "positive"
        elif myInt < 0 then "negative"
        else "zero"

    // Defines a static method.
    static member MySignMethod(myInt) =
        if myInt > 0 then "+"
        elif myInt < 0 then "-"
        else ""

// Creates one delegate for each method. For the instance method, an
// instance (mySC) must be supplied. For the static method, use the
// class name.
let mySC = MySampleClass()
let myD1 = MyMethodDelegate mySC.MyStringMethod
let myD2 = MyMethodDelegate MySampleClass.MySignMethod

// Invokes the delegates.
printfn $"{5} is {myD1.Invoke 5} use the sign \"{myD2.Invoke 5}\"."
printfn $"{-3} is {myD1.Invoke -3} use the sign \"{myD2.Invoke -3}\"."
printfn $"{0} is {myD1.Invoke 0} use the sign \"{myD2.Invoke 0}\"."

// This code produces the following output:
//     5 is positive use the sign "+".
//     -3 is negative use the sign "-".
//     0 is zero use the sign "".

Public Class SamplesDelegate

   ' Declares a delegate for a method that takes in an int and returns a String.
   Delegate Function myMethodDelegate(myInt As Integer) As [String]

   ' Defines some methods to which the delegate can point.
   Public Class mySampleClass

      ' Defines an instance method.
      Public Function myStringMethod(myInt As Integer) As [String]
         If myInt > 0 Then
            Return "positive"
         End If
         If myInt < 0 Then
            Return "negative"
         End If
         Return "zero"
      End Function 'myStringMethod

      ' Defines a static method.
      Public Shared Function mySignMethod(myInt As Integer) As [String]
         If myInt > 0 Then
            Return "+"
         End If
         If myInt < 0 Then
            Return "-"
         End If
         Return ""
      End Function 'mySignMethod
   End Class

   Public Shared Sub Main()

      ' Creates one delegate for each method. For the instance method, an
      ' instance (mySC) must be supplied. For the Shared method, the
      ' method name is qualified by the class name.
      Dim mySC As New mySampleClass()
      Dim myD1 As New myMethodDelegate(AddressOf mySC.myStringMethod)
      Dim myD2 As New myMethodDelegate(AddressOf mySampleClass.mySignMethod)

      ' Invokes the delegates.
      Console.WriteLine("{0} is {1}; use the sign ""{2}"".", 5, myD1(5), myD2(5))
      Console.WriteLine("{0} is {1}; use the sign ""{2}"".", - 3, myD1(- 3), myD2(- 3))
      Console.WriteLine("{0} is {1}; use the sign ""{2}"".", 0, myD1(0), myD2(0))

   End Sub

End Class


'This code produces the following output:
' 
'5 is positive; use the sign "+".
'-3 is negative; use the sign "-".
'0 is zero; use the sign "".

Comentários

A Delegate classe é a classe base para tipos delegados. No entanto, somente o sistema e os compiladores podem derivar explicitamente da Delegate classe ou da MulticastDelegate classe . Também não é permitido derivar um novo tipo de um tipo delegado. A Delegate classe não é considerada um tipo delegado; é uma classe usada para derivar tipos delegados.

A maioria das linguagens implementa um delegate palavra-chave e os compiladores para essas linguagens são capazes de derivar da MulticastDelegate classe ; portanto, os usuários devem usar o delegate palavra-chave fornecido pelo idioma.

Observação

O Common Language Runtime fornece um Invoke método para cada tipo delegado, com a mesma assinatura que o delegado. Você não precisa chamar esse método explicitamente de C#, Visual Basic ou Visual C++, porque os compiladores o chamam automaticamente. O Invoke método é útil na reflexão quando você deseja encontrar a assinatura do tipo delegado.

O Common Language Runtime fornece cada tipo delegado com BeginInvoke métodos e EndInvoke para habilitar a invocação assíncrona do delegado. Para obter mais informações sobre esses métodos, consulte Chamando métodos síncronos de forma assíncrona.

A declaração de um tipo delegado estabelece um contrato que especifica a assinatura de um ou mais métodos. Um delegado é uma instância de um tipo delegado que tem referências a:

  • Um método de instância de um tipo e um objeto de destino atribuível a esse tipo.

  • Um método de instância de um tipo, com o parâmetro oculto this exposto na lista de parâmetros formais. Diz-se que o delegado é um delegado de instância aberta.

  • Um método estático.

  • Um método estático e um objeto de destino atribuível ao primeiro parâmetro do método. Diz-se que o delegado está fechado sobre seu primeiro argumento.

Para obter mais informações sobre a associação de delegados, consulte a sobrecarga de CreateDelegate(Type, Object, MethodInfo, Boolean) método.

Quando um delegado representa um método de instância fechado sobre seu primeiro argumento (o caso mais comum), o delegado armazena uma referência ao ponto de entrada do método e uma referência a um objeto, chamado de destino, que é de um tipo atribuível ao tipo que definiu o método. Quando um delegado representa um método de instância aberta, ele armazena uma referência ao ponto de entrada do método. A assinatura delegada deve incluir o parâmetro oculto this em sua lista de parâmetros formais; nesse caso, o delegado não tem uma referência a um objeto de destino e um objeto de destino deve ser fornecido quando o delegado é invocado.

Quando um delegado representa um método estático, o delegado armazena uma referência ao ponto de entrada do método. Quando um delegado representa um método estático fechado sobre seu primeiro argumento, o delegado armazena uma referência ao ponto de entrada do método e uma referência a um objeto de destino atribuível ao tipo do primeiro argumento do método. Quando o delegado é invocado, o primeiro argumento do método estático recebe o objeto de destino. Esse primeiro argumento deve ser um tipo de referência.

A lista de invocação de um delegado é um conjunto ordenado de delegados no qual cada elemento da lista invoca exatamente um dos métodos representados pelo delegado. Uma lista de invocação pode conter métodos duplicados. Durante uma invocação, os métodos são invocados na ordem em que aparecem na lista de invocação. Um delegado tenta invocar todos os métodos em sua lista de invocação; duplicatas são invocadas uma vez para cada vez que aparecem na lista de invocação. Os delegados são imutáveis; depois de criada, a lista de invocação de um delegado não é alterada.

Os delegados são chamados de multicast ou combináveis, porque um delegado pode invocar um ou mais métodos e pode ser usado na combinação de operações.

A combinação de operações, como Combine e Remove, não altera os delegados existentes. Em vez disso, essa operação retorna um novo delegado que contém os resultados da operação, um delegado inalterado ou null. Uma operação de combinação retorna null quando o resultado da operação é um delegado que não faz referência a pelo menos um método. Uma operação de combinação retorna um delegado inalterado quando a operação solicitada não tem efeito.

Observação

As linguagens gerenciadas usam os Combine métodos e Remove para implementar operações delegadas. Os exemplos incluem as AddHandler instruções e RemoveHandler no Visual Basic e os operadores += e -= em tipos delegados em C#.

A partir do .NET Framework 4, os tipos de delegado genéricos podem ter parâmetros de tipo variante. Parâmetros de tipo contravariante podem ser usados como tipos de parâmetro do delegado e um parâmetro de tipo covariante pode ser usado como o tipo de retorno. Esse recurso permite que tipos delegados genéricos construídos a partir da mesma definição de tipo genérico sejam compatíveis com atribuição se seus argumentos de tipo forem tipos de referência com uma relação de herança, conforme explicado em Covariância e Contravariância.

Observação

Delegados genéricos compatíveis com atribuição devido à variação não são necessariamente combináveis. Para serem combináveis, os tipos devem corresponder exatamente. Por exemplo, suponha que uma classe chamada Derived seja derivada de uma classe chamada Base. Um delegado do tipo Action<Base> (Action(Of Base) no Visual Basic) pode ser atribuído a uma variável do tipo Action<Derived>, mas os dois delegados não podem ser combinados porque os tipos não correspondem exatamente.

Se um método invocado gerar uma exceção, o método interromperá a execução, a exceção será passada de volta para o chamador do delegado e os métodos restantes na lista de invocação não serão invocados. Capturar a exceção no chamador não altera esse comportamento.

Quando a assinatura dos métodos invocados por um delegado inclui um valor retornado, o delegado retorna o valor retornado do último elemento na lista de invocação. Quando a assinatura inclui um parâmetro que é passado por referência, o valor final do parâmetro é o resultado de cada método na lista de invocação em execução sequencial e atualização do valor do parâmetro.

O equivalente mais próximo de um delegado em C é um ponteiro de função. Um delegado pode representar um método estático ou um método de instância. Quando o delegado representa um método de instância, o delegado armazena não apenas uma referência ao ponto de entrada do método, mas também uma referência à instância de classe. Ao contrário dos ponteiros de função, os delegados são orientados a objetos e são fortemente tipado.

Construtores

Delegate(Object, String)

Inicializa um delegado que invoca o método de instância especificado na instância de classe especificada.
Delegate(Type, String)

Inicializa um delegado que invoca o método estático especificado da classe especificada.

Propriedades

Method

Obtém o método representado pelo delegado.
Target

Obtém a instância da classe em que o delegado atual invoca o método de instância.

Métodos

Clone()

Cria uma cópia superficial do delegado.
Combine(Delegate, Delegate)

Concatena as listas de invocação de dois representantes.
Combine(Delegate[])

Concatena as listas de invocação de uma matriz de delegados.
CombineImpl(Delegate)

Concatena as listas de invocação do delegado (combinável) multicast especificado e do delegado (combinável) multicast atual.
CreateDelegate(Type, MethodInfo)

Cria um delegado do tipo especificado para representar o método especificado.
CreateDelegate(Type, MethodInfo, Boolean)

Cria um delegado do tipo especificado para representar o método estático especificado, com o comportamento em falhas especificado a ser associado.
CreateDelegate(Type, Object, MethodInfo)

Cria um delegado do tipo especificado que representa o método de instância ou estático especificado com o primeiro argumento especificado.
CreateDelegate(Type, Object, MethodInfo, Boolean)

Cria um delegado do tipo especificado que representa o método de instância ou estático especificado, com o primeiro argumento especificado e o comportamento especificado na falha para associação.
CreateDelegate(Type, Object, String)

Cria um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada.
CreateDelegate(Type, Object, String, Boolean)

Cria um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada.
CreateDelegate(Type, Object, String, Boolean, Boolean)

Cria um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada e o comportamento especificado na falha de associação.
CreateDelegate(Type, Type, String)

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada.
CreateDelegate(Type, Type, String, Boolean)

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada.
CreateDelegate(Type, Type, String, Boolean, Boolean)

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada e o comportamento especificado na falha de associação.
DynamicInvoke(Object[])

Invoca dinamicamente (associação tardia) o método representado pelo delegado atual.
DynamicInvokeImpl(Object[])

Invoca dinamicamente (associação tardia) o método representado pelo delegado atual.
Equals(Object)

Determina se o objeto especificado e o delegado atual são do mesmo tipo e compartilham os mesmos destinos, métodos e lista de invocação.
GetHashCode()

Retorna um código hash para o delegado.
GetInvocationList()

Retorna a lista de invocação do delegado.
GetMethodImpl()

Obtém o método representado pelo delegado atual.
GetObjectData(SerializationInfo, StreamingContext)
Obsoleto.

Sem suporte.
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
Remove(Delegate, Delegate)

Remove a última ocorrência da lista de invocação de um delegado da lista de invocação de outro delegado.
RemoveAll(Delegate, Delegate)

Remove todas as ocorrências da lista de invocação de um delegado da lista de invocação de outro delegado.
RemoveImpl(Delegate)

Remove a lista de invocação de um delegado da lista de invocação de outro delegado.
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Operadores

Equality(Delegate, Delegate)

Determina se os delegados especificados são iguais.
Inequality(Delegate, Delegate)

Determina se os delegados especificados não são iguais.

Métodos de Extensão

GetMethodInfo(Delegate)

Obtém um objeto que representa o método representado pelo delegado especificado.

Aplica-se a

Confira também