Delegate Delegate Delegate Delegate Class

Definição

Representa um delegado, que é uma estrutura de dados que se refere a um método estático ou a uma instância da classe e um método de instância dessa classe.Represents a delegate, which is a data structure that refers to a static method or to a class instance and an instance method of that class.

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

Exemplos

O exemplo a seguir mostra como definir um representante chamado myMethodDelegate.The following example shows how to define a delegate named myMethodDelegate. São criadas instâncias desse delegado para um método de instância e um método estático do aninhada mySampleClass classe.Instances of this delegate are created for an instance method and a static method of the nested mySampleClass class. O delegado para o método de instância requer uma instância de mySampleClass.The delegate for the instance method requires an instance of mySampleClass. O mySampleClass instância é salvo em uma variável chamada mySC.The mySampleClass instance is saved in a variable named 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 "".
*/ 

Imports System

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 'mySampleClass

   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 'Main

End Class 'SamplesDelegate 


'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

O Delegate é a classe base para tipos de delegado.The Delegate class is the base class for delegate types. No entanto, somente o sistema e os compiladores podem derivar explicitamente o Delegate classe ou a partir de MulticastDelegate classe.However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. Também não é permitido para derivar um novo tipo de um tipo de delegado.It is also not permissible to derive a new type from a delegate type. O Delegate classe não é considerado um tipo de delegado; é uma classe usada para derivar tipos de delegado.The Delegate class is not considered a delegate type; it is a class used to derive delegate types.

Implementar a maioria das linguagens uma delegate palavra-chave e compiladores para essas linguagens são capazes de derivar o MulticastDelegate classe; portanto, os usuários devem usar o delegate fornecido pela linguagem de palavra-chave.Most languages implement a delegate keyword, and compilers for those languages are able to derive from the MulticastDelegate class; therefore, users should use the delegate keyword provided by the language.

Observação

O common language runtime fornece um Invoke método para cada tipo de delegado, com a mesma assinatura que o delegado.The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. Não é necessário chamar esse método explicitamente do c#, Visual Basic ou Visual C++, pois os compiladores de chamá-lo automaticamente.You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. O Invoke método é útil na reflexão quando você deseja localizar a assinatura do tipo delegado.The Invoke method is useful in reflection when you want to find the signature of the delegate type.

O common language runtime fornece a cada tipo de delegado com BeginInvoke e EndInvoke métodos, para permitir a invocação assíncrona do delegado.The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. Para obter mais informações sobre esses métodos, consulte chamando métodos síncronos assincronamente.For more information about these methods, see Calling Synchronous Methods Asynchronously.

A declaração de um tipo delegado estabelece um contrato que especifica a assinatura de um ou mais métodos.The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. Um delegado é uma instância de um tipo de delegado que possui referências a:A delegate is an instance of a delegate type that has references to:

  • Um método de instância de um tipo e um objeto de destino pode ser atribuído a esse tipo.An instance method of a type and a target object assignable to that type.

  • Um método de instância de um tipo, com o oculto this parâmetro exposto na lista de parâmetros formais.An instance method of a type, with the hidden this parameter exposed in the formal parameter list. O delegado deve ser um representante de instância aberta.The delegate is said to be an open instance delegate.

  • Um método estático.A static method.

  • Um método estático e um objeto de destino pode ser atribuído ao primeiro parâmetro do método.A static method and a target object assignable to the first parameter of the method. O delegado deve ser fechado ao longo de seu primeiro argumento.The delegate is said to be closed over its first argument.

Para obter mais informações sobre associação de delegados, consulte o CreateDelegate(Type, Object, MethodInfo, Boolean) sobrecarga de método.For more information on delegate binding, see the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload.

Observação

Nas versões do .NET Framework 1.0 e 1.1, um delegado pode representar um método somente se a assinatura do método corresponde exatamente à assinatura especificada pelo tipo de delegado.In the .NET Framework versions 1.0 and 1.1, a delegate can represent a method only if the signature of the method exactly matches the signature specified by the delegate type. Assim, somente os primeiros e terceiro marcadores na lista acima têm suporte e o primeiro marcador requer uma correspondência de tipo exato.Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

Quando um delegado representa um método de instância fechado ao longo de 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 destino, que é de um tipo atribuível ao tipo de definido o método.When a delegate represents an instance method closed over its first argument (the most common case), the delegate stores a reference to the method's entry point and a reference to an object, called the target, which is of a type assignable to the type that defined the method. Quando um delegado representa um método de instância aberto, ele armazena uma referência ao ponto de entrada do método.When a delegate represents an open instance method, it stores a reference to the method's entry point. A assinatura do delegado deve incluir o oculto this parâmetro na 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.The delegate signature must include the hidden this parameter in its formal parameter list; in this case, the delegate does not have a reference to a target object, and a target object must be supplied when the delegate is invoked.

Quando um delegado representa um método estático, o delegado armazena uma referência ao ponto de entrada do método.When a delegate represents a static method, the delegate stores a reference to the method's entry point. Quando um delegado representa um método estático fechado ao longo de 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 pode ser atribuído para o tipo do primeiro argumento de um método.When a delegate represents a static method closed over its first argument, the delegate stores a reference to the method's entry point and a reference to a target object assignable to the type of the method's first argument. Quando o delegado é invocado, o primeiro argumento do método estático recebe o objeto de destino.When the delegate is invoked, the first argument of the static method receives the target object.

A lista de invocação de um delegado é um conjunto ordenado de delegados em que cada elemento da lista invoca exatamente um dos métodos representados pelo delegado.The invocation list of a delegate is an ordered set of delegates in which each element of the list invokes exactly one of the methods represented by the delegate. Uma lista de invocação pode conter métodos duplicados.An invocation list can contain duplicate methods. Durante uma invocação, os métodos são chamados na ordem em que aparecem na lista de invocação.During an invocation, methods are invoked in the order in which they appear in the invocation list. Um delegado tenta chamar cada método em sua lista de invocação; as duplicatas são invocadas depois de cada vez que eles aparecem na lista de invocação.A delegate attempts to invoke every method in its invocation list; duplicates are invoked once for each time they appear in the invocation list. Os delegados são imutáveis; Depois de criado, não altera a lista de invocação de um delegado.Delegates are immutable; once created, the invocation list of a delegate does not change.

Delegados são chamados como multicast, ou podem ser combinadas, pois pode invocar um ou mais métodos de um delegado e pode ser usado em combinação de operações.Delegates are referred to as multicast, or combinable, because a delegate can invoke one or more methods and can be used in combining operations.

Combinação de operações, como Combine e Remove, não alteram os delegados existentes.Combining operations, such as Combine and Remove, do not alter existing delegates. Em vez disso, essa operação retorna um novo delegado que contém os resultados da operação, um delegado inalterado, ou null.Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. Retorna uma operação de combinação null quando o resultado da operação é um delegado que não faz referência a pelo menos um método.A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. Uma operação de combinação retorna um delegado inalterado quando a operação solicitada não tem nenhum efeito.A combining operation returns an unchanged delegate when the requested operation has no effect.

Observação

Os gerenciados usam linguagens a Combine e Remove métodos para implementar operações de delegado.Managed languages use the Combine and Remove methods to implement delegate operations. Os exemplos incluem o AddHandler e RemoveHandler instruções no Visual Basic e os operadores + = e -= no representante de tipos em c#.Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

Começando com o .NET Framework 4.NET Framework 4, tipos de delegado genérico podem ter parâmetros de tipo variantes.Starting with the .NET Framework 4.NET Framework 4, generic delegate types can have variant type parameters. Parâmetros de tipo Contravariantes 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.Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. Esse recurso permite que o delegado genérico tipos construídos da mesma definição de tipo genérico para ser compatíveis com a atribuição se seus argumentos de tipo são tipos de referência com uma relação de herança, conforme explicado em covariância e A contravariância.This feature allows generic delegate types that are constructed from the same generic type definition to be assignment-compatible if their type arguments are reference types with an inheritance relationship, as explained in Covariance and Contravariance.

Observação

Delegados genéricos que são compatíveis com a atribuição devido à variação não são necessariamente podem ser combinadas.Generic delegates that are assignment-compatible because of variance are not necessarily combinable. Para ser combináveis, os tipos devem corresponder exatamente.To be combinable, the types must match exactly. Por exemplo, suponha que uma classe denominada Derived é derivado de uma classe chamada Base.For example, suppose that a class named Derived is derived from a class named 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.A delegate of type Action<Base> (Action(Of Base) in Visual Basic) can be assigned to a variable of type Action<Derived>, but the two delegates cannot be combined because the types do not match exactly.

Se um método invocado gera uma exceção, o método interromperá a execução, a exceção é passada para o chamador do delegado e métodos restantes na lista de invocação não são invocados.If an invoked method throws an exception, the method stops executing, the exception is passed back to the caller of the delegate, and remaining methods in the invocation list are not invoked. Capturar a exceção no chamador não altera esse comportamento.Catching the exception in the caller does not alter this behavior.

Quando a assinatura dos métodos invocados por um delegado inclui um valor de retorno, o delegado retorna o valor retornado do último elemento na lista de invocação.When the signature of the methods invoked by a delegate includes a return value, the delegate returns the return value of the last element in the invocation list. 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, executar em sequência e atualizando o valor do parâmetro.When the signature includes a parameter that is passed by reference, the final value of the parameter is the result of every method in the invocation list executing sequentially and updating the parameter's value.

O equivalente mais próximo de um delegado em C é um ponteiro de função.The closest equivalent of a delegate in C is a function pointer. Um delegado pode representar um método estático ou um método de instância.A delegate can represent a static method or an instance method. 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 para a instância da classe.When the delegate represents an instance method, the delegate stores not only a reference to the method's entry point, but also a reference to the class instance. Ao contrário dos ponteiros de função, delegados são orientada a objeto e fortemente tipados.Unlike function pointers, delegates are object oriented and type safe.

Construtores

Delegate(Object, String) Delegate(Object, String) Delegate(Object, String) Delegate(Object, String)

Inicializa um delegado que invoca o método de instância especificado na instância de classe especificada.Initializes a delegate that invokes the specified instance method on the specified class instance.

Delegate(Type, String) Delegate(Type, String) Delegate(Type, String) Delegate(Type, String)

Inicializa um delegado que invoca o método estático especificado da classe especificada.Initializes a delegate that invokes the specified static method from the specified class.

Propriedades

Method Method Method Method

Obtém o método representado pelo delegado.Gets the method represented by the delegate.

Target Target Target Target

Obtém a instância da classe em que o delegado atual invoca o método de instância.Gets the class instance on which the current delegate invokes the instance method.

Métodos

Clone() Clone() Clone() Clone()

Cria uma cópia superficial do delegado.Creates a shallow copy of the delegate.

Combine(Delegate, Delegate) Combine(Delegate, Delegate) Combine(Delegate, Delegate) Combine(Delegate, Delegate)

Concatena as listas de invocação de dois representantes.Concatenates the invocation lists of two delegates.

Combine(Delegate[]) Combine(Delegate[]) Combine(Delegate[]) Combine(Delegate[])

Concatena as listas de invocação de uma matriz de delegados.Concatenates the invocation lists of an array of delegates.

CombineImpl(Delegate) CombineImpl(Delegate) CombineImpl(Delegate) CombineImpl(Delegate)

Concatena as listas de invocação do delegado (combinável) multicast especificado e do delegado (combinável) multicast atual.Concatenates the invocation lists of the specified multicast (combinable) delegate and the current multicast (combinable) delegate.

CreateDelegate(Type, MethodInfo) CreateDelegate(Type, MethodInfo) CreateDelegate(Type, MethodInfo) CreateDelegate(Type, MethodInfo)

Cria um delegado do tipo especificado para representar o método estático especificado.Creates a delegate of the specified type to represent the specified static method.

CreateDelegate(Type, MethodInfo, Boolean) CreateDelegate(Type, MethodInfo, Boolean) CreateDelegate(Type, MethodInfo, Boolean) 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.Creates a delegate of the specified type to represent the specified static method, with the specified behavior on failure to bind.

CreateDelegate(Type, Object, MethodInfo) CreateDelegate(Type, Object, MethodInfo) CreateDelegate(Type, Object, MethodInfo) 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.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

CreateDelegate(Type, Object, MethodInfo, Boolean) CreateDelegate(Type, Object, MethodInfo, Boolean) CreateDelegate(Type, Object, MethodInfo, Boolean) 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.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument and the specified behavior on failure to bind.

CreateDelegate(Type, Object, String) CreateDelegate(Type, Object, String) CreateDelegate(Type, Object, String) 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.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

CreateDelegate(Type, Object, String, Boolean) CreateDelegate(Type, Object, String, Boolean) CreateDelegate(Type, Object, String, Boolean) 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.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance with the specified case-sensitivity.

CreateDelegate(Type, Object, String, Boolean, Boolean) CreateDelegate(Type, Object, String, Boolean, Boolean) CreateDelegate(Type, Object, String, Boolean, Boolean) 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.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance, with the specified case-sensitivity and the specified behavior on failure to bind.

CreateDelegate(Type, Type, String) CreateDelegate(Type, Type, String) CreateDelegate(Type, Type, String) CreateDelegate(Type, Type, String)

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada.Creates a delegate of the specified type that represents the specified static method of the specified class.

CreateDelegate(Type, Type, String, Boolean) CreateDelegate(Type, Type, String, Boolean) CreateDelegate(Type, Type, String, Boolean) 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.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity.

CreateDelegate(Type, Type, String, Boolean, Boolean) CreateDelegate(Type, Type, String, Boolean, Boolean) CreateDelegate(Type, Type, String, Boolean, Boolean) 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.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity and the specified behavior on failure to bind.

DynamicInvoke(Object[]) DynamicInvoke(Object[]) DynamicInvoke(Object[]) DynamicInvoke(Object[])

Invoca dinamicamente (associação tardia) o método representado pelo delegado atual.Dynamically invokes (late-bound) the method represented by the current delegate.

DynamicInvokeImpl(Object[]) DynamicInvokeImpl(Object[]) DynamicInvokeImpl(Object[]) DynamicInvokeImpl(Object[])

Invoca dinamicamente (associação tardia) o método representado pelo delegado atual.Dynamically invokes (late-bound) the method represented by the current delegate.

Equals(Object) Equals(Object) Equals(Object) 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.Determines whether the specified object and the current delegate are of the same type and share the same targets, methods, and invocation list.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retorna um código hash para o delegado.Returns a hash code for the delegate.

GetInvocationList() GetInvocationList() GetInvocationList() GetInvocationList()

Retorna a lista de invocação do delegado.Returns the invocation list of the delegate.

GetMethodImpl() GetMethodImpl() GetMethodImpl() GetMethodImpl()

Obtém o método estático representado pelo delegado atual.Gets the static method represented by the current delegate.

GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Sem suporte.Not supported.

GetType() GetType() GetType() GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
Remove(Delegate, Delegate) Remove(Delegate, Delegate) Remove(Delegate, Delegate) Remove(Delegate, Delegate)

Remove a última ocorrência da lista de invocação de um delegado da lista de invocação de outro delegado.Removes the last occurrence of the invocation list of a delegate from the invocation list of another delegate.

RemoveAll(Delegate, Delegate) RemoveAll(Delegate, Delegate) RemoveAll(Delegate, Delegate) RemoveAll(Delegate, Delegate)

Remove todas as ocorrências da lista de invocação de um delegado da lista de invocação de outro delegado.Removes all occurrences of the invocation list of a delegate from the invocation list of another delegate.

RemoveImpl(Delegate) RemoveImpl(Delegate) RemoveImpl(Delegate) RemoveImpl(Delegate)

Remove a lista de invocação de um delegado da lista de invocação de outro delegado.Removes the invocation list of a delegate from the invocation list of another delegate.

ToString() ToString() ToString() ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Inherited from Object)

Operadores

Equality(Delegate, Delegate) Equality(Delegate, Delegate) Equality(Delegate, Delegate) Equality(Delegate, Delegate)

Determina se os delegados especificados são iguais.Determines whether the specified delegates are equal.

Inequality(Delegate, Delegate) Inequality(Delegate, Delegate) Inequality(Delegate, Delegate) Inequality(Delegate, Delegate)

Determina se os delegados especificados não são iguais.Determines whether the specified delegates are not equal.

Métodos de Extensão

GetMethodInfo(Delegate) GetMethodInfo(Delegate) GetMethodInfo(Delegate) GetMethodInfo(Delegate)

Obtém um objeto que representa o método representado pelo delegado especificado.Gets an object that represents the method represented by the specified delegate.

Aplica-se a

Veja também