Delegate Delegate Delegate Delegate Class

Définition

Représente un délégué qui est une structure de données référençant une méthode statique ou une instance de classe et une méthode d'instance de cette 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
Héritage
DelegateDelegateDelegateDelegate
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant montre comment définir un délégué nommé myMethodDelegate.The following example shows how to define a delegate named myMethodDelegate. Les instances de ce délégué sont créées pour une méthode d’instance et une méthode statique de la mySampleClass classe imbriquée.Instances of this delegate are created for an instance method and a static method of the nested mySampleClass class. Le délégué de la méthode d’instance requiert une instance mySampleClassde.The delegate for the instance method requires an instance of mySampleClass. L' mySampleClass instance est enregistrée dans une variable nommée 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 "".
*/ 

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 "".


Remarques

La Delegate classe est la classe de base pour les types délégués.The Delegate class is the base class for delegate types. Toutefois, seuls le système et les compilateurs peuvent dériver explicitement à Delegate partir de la classe MulticastDelegate ou de la classe.However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. Il n’est pas non plus possible de dériver un nouveau type à partir d’un type délégué.It is also not permissible to derive a new type from a delegate type. La Delegate classe n’est pas considérée comme un type délégué ; il s’agit d’une classe utilisée pour dériver des types délégués.The Delegate class is not considered a delegate type; it is a class used to derive delegate types.

La plupart des langages implémentent un delegate mot clé, et les compilateurs pour ces langages peuvent dériver de la MulticastDelegate classe ; par delegate conséquent, les utilisateurs doivent utiliser le mot clé fourni par le langage.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.

Notes

L’Common Language Runtime fournit une Invoke méthode pour chaque type délégué, avec la même signature que le délégué.The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. Vous n’avez pas à appeler cette méthode explicitement à C#partir de, Visual Basic ou C++visuel, car les compilateurs l’appellent automatiquement.You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. La Invoke méthode est utile dans la réflexion lorsque vous souhaitez rechercher la signature du type délégué.The Invoke method is useful in reflection when you want to find the signature of the delegate type.

L’Common Language Runtime fournit chaque type délégué avec BeginInvoke les EndInvoke méthodes et, afin d’activer l’appel asynchrone du délégué.The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. Pour plus d’informations sur ces méthodes, consultez appel de méthodes synchrones de façon asynchrone.For more information about these methods, see Calling Synchronous Methods Asynchronously.

La déclaration d’un type délégué établit un contrat qui spécifie la signature d’une ou plusieurs méthodes.The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. Un délégué est une instance d’un type délégué qui a des références à :A delegate is an instance of a delegate type that has references to:

  • Une méthode d’instance d’un type et un objet cible pouvant être assigné à ce type.An instance method of a type and a target object assignable to that type.

  • Méthode d’instance d’un type, avec le paramètre this Hidden exposé dans la liste de paramètres formels.An instance method of a type, with the hidden this parameter exposed in the formal parameter list. Le délégué est considéré comme un délégué d’instance ouvert.The delegate is said to be an open instance delegate.

  • Méthode statique.A static method.

  • Une méthode statique et un objet cible assignables au premier paramètre de la méthode.A static method and a target object assignable to the first parameter of the method. On dit que le délégué est fermé sur son premier argument.The delegate is said to be closed over its first argument.

Pour plus d’informations sur la liaison de délégués CreateDelegate(Type, Object, MethodInfo, Boolean) , consultez la surcharge de méthode.For more information on delegate binding, see the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload.

Notes

Dans les versions 1,0 et 1,1 du .NET Framework, un délégué peut représenter une méthode uniquement si la signature de la méthode correspond exactement à la signature spécifiée par le type délégué.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. Ainsi, seules les première et troisième puces de la liste précédente sont prises en charge, et la première puce requiert une correspondance exacte de type.Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

Lorsqu’un délégué représente une méthode d’instance fermée sur son premier argument (le cas le plus courant), le délégué stocke une référence au point d’entrée de la méthode et une référence à un objet, appelée la cible, qui est un type pouvant être assigné au type qui a défini le méthode.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. Lorsqu’un délégué représente une méthode d’instance ouverte, il stocke une référence au point d’entrée de la méthode.When a delegate represents an open instance method, it stores a reference to the method's entry point. La signature du délégué doit inclure le this paramètre Hidden dans sa liste de paramètres formels. dans ce cas, le délégué n’a pas de référence à un objet cible et un objet cible doit être fourni lorsque le délégué est appelé.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.

Lorsqu’un délégué représente une méthode statique, le délégué stocke une référence au point d’entrée de la méthode.When a delegate represents a static method, the delegate stores a reference to the method's entry point. Lorsqu’un délégué représente une méthode statique fermée sur son premier argument, le délégué stocke une référence au point d’entrée de la méthode et une référence à un objet cible qui est assignée au type du premier argument de la méthode.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. Lorsque le délégué est appelé, le premier argument de la méthode statique reçoit l’objet cible.When the delegate is invoked, the first argument of the static method receives the target object.

La liste d’appel d’un délégué est un ensemble ordonné de délégués dans lequel chaque élément de la liste appelle exactement l’une des méthodes représentées par le délégué.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. Une liste d’appel peut contenir des méthodes dupliquées.An invocation list can contain duplicate methods. Pendant un appel, les méthodes sont appelées dans l’ordre dans lequel elles apparaissent dans la liste d’appel.During an invocation, methods are invoked in the order in which they appear in the invocation list. Un délégué tente d’appeler chaque méthode dans sa liste d’appel ; les doublons sont appelés une fois pour chaque fois qu’ils apparaissent dans la liste d’appel.A delegate attempts to invoke every method in its invocation list; duplicates are invoked once for each time they appear in the invocation list. Les délégués sont immuables ; une fois créé, la liste d’appel d’un délégué ne change pas.Delegates are immutable; once created, the invocation list of a delegate does not change.

Les délégués sont appelés multidiffusion ou combinable, car un délégué peut appeler une ou plusieurs méthodes et peut être utilisé pour combiner des opérations.Delegates are referred to as multicast, or combinable, because a delegate can invoke one or more methods and can be used in combining operations.

La combinaison d’opérations, Combine telles Removeque et, ne modifie pas les délégués existants.Combining operations, such as Combine and Remove, do not alter existing delegates. Au lieu de cela, une telle opération retourne un nouveau délégué qui contient les résultats de l’opération, un délégué inchangé nullou.Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. Une opération d’association null retourne lorsque le résultat de l’opération est un délégué qui ne fait pas référence à au moins une méthode.A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. Une opération d’association retourne un délégué non modifié lorsque l’opération demandée n’a aucun effet.A combining operation returns an unchanged delegate when the requested operation has no effect.

Notes

Les langages managés Remove utilisent les Combine méthodes et pour implémenter des opérations de délégué.Managed languages use the Combine and Remove methods to implement delegate operations. Les exemples incluent AddHandler les RemoveHandler instructions et dans Visual Basic et les opérateurs + = et-= sur les types C#délégués dans.Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

À compter de .NET Framework 4.NET Framework 4, les types délégués génériques peuvent avoir des paramètres de type Variant.Starting with the .NET Framework 4.NET Framework 4, generic delegate types can have variant type parameters. Les paramètres de type contravariant peuvent être utilisés comme types de paramètres du délégué, et un paramètre de type covariant peut être utilisé comme type de retour.Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. Cette fonctionnalité permet aux types délégués génériques qui sont construits à partir de la même définition de type générique d’être compatibles avec l’assignation si leurs arguments de type sont des types référence avec une relation d’héritage, comme expliqué dans covariance et contravariance. .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.

Notes

Les délégués génériques qui sont compatibles avec l’assignation en raison de la variance ne sont pas nécessairement combinables.Generic delegates that are assignment-compatible because of variance are not necessarily combinable. Pour être combinable, les types doivent correspondre exactement.To be combinable, the types must match exactly. Par exemple, supposons qu’une classe Derived nommée est dérivée d’une Baseclasse nommée.For example, suppose that a class named Derived is derived from a class named Base. Un délégué de type Action<Base> (Action(Of Base) dans Visual Basic) peut être assigné à une variable de type Action<Derived>, mais les deux délégués ne peuvent pas être combinés, car les types ne correspondent pas exactement.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.

Si une méthode appelée lève une exception, la méthode cesse de s’exécuter, l’exception est repassée à l’appelant du délégué, et les méthodes restantes de la liste d’appel ne sont pas appelées.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. L’interception de l’exception dans l’appelant ne modifie pas ce comportement.Catching the exception in the caller does not alter this behavior.

Lorsque la signature des méthodes appelées par un délégué comprend une valeur de retour, le délégué retourne la valeur de retour du dernier élément de la liste d’appel.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. Lorsque la signature comprend un paramètre passé par référence, la valeur finale du paramètre est le résultat de chaque méthode de la liste d’appel qui s’exécute de manière séquentielle et met à jour la valeur du paramètre.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.

L’équivalent le plus proche d’un délégué en C est un pointeur de fonction.The closest equivalent of a delegate in C is a function pointer. Un délégué peut représenter une méthode statique ou une méthode d’instance.A delegate can represent a static method or an instance method. Lorsque le délégué représente une méthode d’instance, le délégué stocke non seulement une référence au point d’entrée de la méthode, mais également une référence à l’instance de 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. Contrairement aux pointeurs de fonction, les délégués sont orientés objet et de type sécurisé.Unlike function pointers, delegates are object oriented and type safe.

Constructeurs

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

Initialise un délégué qui appelle la méthode d'instance spécifiée sur l'instance de classe spécifiée.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)

Initialise un délégué qui appelle la méthode statique spécifiée à partir de la classe spécifiée.Initializes a delegate that invokes the specified static method from the specified class.

Propriétés

Method Method Method Method

Obtient la méthode représentée par le délégué.Gets the method represented by the delegate.

Target Target Target Target

Obtient l'instance de classe sur laquelle le délégué en cours appelle la méthode d'instance.Gets the class instance on which the current delegate invokes the instance method.

Méthodes

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

Crée une copie superficielle du délégué.Creates a shallow copy of the delegate.

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

Concatène les listes d'appel de deux délégués.Concatenates the invocation lists of two delegates.

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

Concatène les listes d'appel d'un tableau de délégués.Concatenates the invocation lists of an array of delegates.

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

Concatène les listes d'appel du délégué multicast (pouvant être combiné) spécifié et du délégué multicast (pouvant être combiné) en cours.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)

Crée un délégué du type spécifié pour représenter la méthode statique spécifiée.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)

Crée un délégué du type spécifié pour représenter la méthode statique spécifiée, avec le comportement spécifié en cas d'échec de la liaison.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)

Crée un délégué du type spécifié qui représente la méthode statique ou méthode d'instance spécifiée, avec le premier argument spécifié.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)

Crée un délégué du type spécifié qui représente la méthode statique ou d'instance spécifiée, avec le premier argument spécifié et le comportement spécifié en cas d'échec de la liaison.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)

Crée un délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée.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)

Crée un délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée, avec le respect de la casse spécifié.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)

Crée un délégué du type spécifié qui représente la méthode d'instance spécifiée à appeler sur l'instance de classe spécifiée, avec le respect de la casse spécifié et le comportement spécifié en cas d'échec de la liaison.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)

Crée un délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée.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)

Crée un délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée, avec le respect de la casse spécifié.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)

Crée un délégué du type spécifié qui représente la méthode statique spécifiée de la classe spécifiée, avec le respect de la casse spécifié et le comportement spécifié en cas d'échec de la liaison.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[])

Appelle de manière dynamique (à liaison tardive) la méthode représentée par le délégué en cours.Dynamically invokes (late-bound) the method represented by the current delegate.

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

Appelle de manière dynamique (à liaison tardive) la méthode représentée par le délégué en cours.Dynamically invokes (late-bound) the method represented by the current delegate.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié et le délégué actuel sont du même type et partagent les mêmes cibles, méthodes et liste d'appel.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()

Retourne un code de hachage pour le délégué.Returns a hash code for the delegate.

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

Retourne la liste d'appel du délégué.Returns the invocation list of the delegate.

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

Obtient la méthode statique représentée par le délégué en cours.Gets the static method represented by the current delegate.

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

Non pris en charge.Not supported.

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

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

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

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

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

Supprime la dernière occurrence de la liste d'appel d'un délégué de la liste d'appel d'un autre délégué.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)

Supprime toutes les occurrences de la liste d'appel d'un délégué de la liste d'appel d'un autre délégué.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)

Supprime la liste d'appel d'un délégué de la liste d'appel d'un autre délégué.Removes the invocation list of a delegate from the invocation list of another delegate.

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

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

Opérateurs

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

Détermine si les délégués spécifiés sont égaux.Determines whether the specified delegates are equal.

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

Détermine si les délégués spécifiés ne sont pas égaux.Determines whether the specified delegates are not equal.

Méthodes d’extension

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

Obtient un objet qui représente la méthode représentée par le délégué spécifié.Gets an object that represents the method represented by the specified delegate.

S’applique à

Voir aussi