Delegate Delegate Delegate Delegate Class

Definizione

Rappresenta un delegato, ossia la struttura di dati che fa riferimento a un metodo static o a un'istanza di classe e un metodo di istanza di quella 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
Ereditarietà
DelegateDelegateDelegateDelegate
Derivato
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato come definire un delegato denominato myMethodDelegate.The following example shows how to define a delegate named myMethodDelegate. Vengono create istanze di questo delegato per un metodo di istanza e un metodo statico di annidata mySampleClass classe.Instances of this delegate are created for an instance method and a static method of the nested mySampleClass class. Il delegato per il metodo di istanza richiede un'istanza di mySampleClass.The delegate for the instance method requires an instance of mySampleClass. Il mySampleClass istanza viene salvata in una variabile denominata 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 "".


Commenti

Il Delegate classe è la classe base per i tipi delegati.The Delegate class is the base class for delegate types. Tuttavia, solo il sistema e i compilatori possono derivare in modo esplicito il Delegate classe o dal MulticastDelegate classe.However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. Non è inoltre possibile derivare un nuovo tipo da un tipo delegato.It is also not permissible to derive a new type from a delegate type. Il Delegate classe non viene considerata un tipo delegato, ovvero una classe utilizzata per derivare i tipi delegati.The Delegate class is not considered a delegate type; it is a class used to derive delegate types.

Implementano la maggior parte dei linguaggi una delegate parola chiave e i compilatori di tali linguaggi sono in grado di derivare dal MulticastDelegate classe; pertanto, gli utenti devono usare il delegate parola chiave del linguaggio.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.

Nota

Common language runtime fornisce un Invoke metodo per ogni tipo di delegato, con la stessa firma del delegato.The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. Non è necessario chiamare questo metodo in modo esplicito dal codice C#, Visual Basic o Visual C++, perché i compilatori chiamano automaticamente.You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. Il Invoke metodo è utile negli reflection quando si desidera trovare la firma del tipo delegato.The Invoke method is useful in reflection when you want to find the signature of the delegate type.

Common language runtime fornisce ogni tipo di delegato con BeginInvoke e EndInvoke nei metodi per abilitare la chiamata asincrona del delegato.The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. Per altre informazioni su questi metodi, vedere Calling Synchronous Methods Asynchronously.For more information about these methods, see Calling Synchronous Methods Asynchronously.

La dichiarazione di un tipo delegato stabilisce un contratto che specifica la firma di uno o più metodi.The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. Un delegato è un'istanza di un tipo delegato che contiene riferimenti a:A delegate is an instance of a delegate type that has references to:

  • Un metodo di istanza di un tipo e un oggetto di destinazione può essere assegnato a tale tipo.An instance method of a type and a target object assignable to that type.

  • Un metodo di istanza di un tipo, con nascosto this parametro esposto nell'elenco di parametri formali.An instance method of a type, with the hidden this parameter exposed in the formal parameter list. Il delegato è associato a un'istanza aperta di delegato.The delegate is said to be an open instance delegate.

  • Un metodo statico.A static method.

  • Un metodo statico e un oggetto di destinazione può essere assegnato al primo parametro del metodo.A static method and a target object assignable to the first parameter of the method. Il delegato per essere chiuso al primo argomento.The delegate is said to be closed over its first argument.

Per ulteriori informazioni sull'associazione di delegati, vedere il CreateDelegate(Type, Object, MethodInfo, Boolean) overload del metodo.For more information on delegate binding, see the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload.

Nota

Nelle versioni 1.0 e 1.1 di .NET Framework, un delegato può rappresentare un metodo solo se la firma del metodo corrisponde esattamente alla firma specificata dal tipo di delegato.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. Di conseguenza, è supportato solo il primo e il terzo punto dell'elenco precedente, e al primo punto richiede una corrispondenza di tipo esatto.Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

Quando un delegato rappresenta un metodo di istanza chiuso al primo argomento (il caso più comune), viene archiviato un riferimento al punto di ingresso del metodo e un riferimento a un oggetto, denominato destinazione, che è un tipo assegnabile al tipo di cui è definito il metodo.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 un delegato rappresenta un metodo di istanza aperta, archivia un riferimento al punto di ingresso del metodo.When a delegate represents an open instance method, it stores a reference to the method's entry point. La firma del delegato deve includere nascosto this parametro nel relativo elenco di parametri formali; in questo caso, il delegato non è un riferimento a un oggetto di destinazione, e un oggetto di destinazione deve essere specificato quando viene richiamato il delegato.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 un delegato rappresenta un metodo statico, il delegato archivia un riferimento al punto di ingresso del metodo.When a delegate represents a static method, the delegate stores a reference to the method's entry point. Quando un delegato rappresenta un metodo statico chiuso al primo argomento, il delegato archivia un riferimento al punto di ingresso del metodo e un riferimento a un oggetto di destinazione può essere assegnato al tipo del primo argomento del metodo.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 il delegato viene richiamato, il primo argomento del metodo statico riceve l'oggetto di destinazione.When the delegate is invoked, the first argument of the static method receives the target object.

L'elenco chiamate di un delegato è un set ordinato di delegati in cui ogni elemento dell'elenco richiama esattamente uno dei metodi rappresentati dal delegato.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. Un elenco di chiamate può contenere metodi duplicati.An invocation list can contain duplicate methods. Durante una chiamata, i metodi vengono richiamati nell'ordine in cui vengono visualizzati nell'elenco chiamate.During an invocation, methods are invoked in the order in which they appear in the invocation list. Un delegato tenta di richiamare ogni metodo nell'elenco chiamate; una volta per ogni volta che vengono visualizzati nell'elenco chiamate, vengono richiamati i duplicati.A delegate attempts to invoke every method in its invocation list; duplicates are invoked once for each time they appear in the invocation list. I delegati sono immutabili. una volta creato, non modifica l'elenco chiamate di un delegato.Delegates are immutable; once created, the invocation list of a delegate does not change.

I delegati vengono definiti come multicast o combinabile, perché un delegato può richiamare uno o più metodi e può essere usato in combinazione di operazioni.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 combinazione di operazioni, ad esempio Combine e Remove, delegati esistenti non verranno modificati.Combining operations, such as Combine and Remove, do not alter existing delegates. Al contrario, questa operazione restituisce un nuovo delegato che contiene i risultati dell'operazione, un delegato invariato o null.Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. Restituisce un'operazione di combinazione null quando il risultato dell'operazione è un delegato che non fa riferimento ad almeno un metodo.A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. Un'operazione di combinazione restituisce un delegato invariato durante l'operazione richiesta non ha alcun effetto.A combining operation returns an unchanged delegate when the requested operation has no effect.

Nota

Linguaggi gestiti utilizzano le Combine e Remove metodi per implementare le operazioni di delegato.Managed languages use the Combine and Remove methods to implement delegate operations. Gli esempi includono la AddHandler e RemoveHandler istruzioni in Visual Basic e gli operatori + = e -= in tipi delegati in C#.Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

A partire dal .NET Framework 4.NET Framework 4, tipi delegati generici possono avere parametri di tipo variante.Starting with the .NET Framework 4.NET Framework 4, generic delegate types can have variant type parameters. Parametri di tipo controvariante possono essere utilizzati come tipi di parametro del delegato e un parametro di tipo covariante può essere utilizzato come tipo restituito.Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. Questa funzionalità consente di delegato generico tipi costruiti dalla stessa definizione di tipo generico per essere compatibili con l'assegnazione se i relativi argomenti di tipo sono tipi di riferimento con una relazione di ereditarietà, come spiegato in covarianza e La controvarianza.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.

Nota

I delegati generici che sono compatibili con l'assegnazione a causa della varianza non sono necessariamente combinabili.Generic delegates that are assignment-compatible because of variance are not necessarily combinable. Per essere combinabili, i tipi devono corrispondere esattamente.To be combinable, the types must match exactly. Ad esempio, si supponga che una classe denominata Derived deriva da una classe denominata Base.For example, suppose that a class named Derived is derived from a class named Base. Un delegato del tipo Action<Base> (Action(Of Base) in Visual Basic) può essere assegnato a una variabile di tipo Action<Derived>, ma non è possibile combinare le due delegati perché i tipi non corrispondono esattamente.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 un metodo richiamato genera un'eccezione, il metodo viene arrestata l'esecuzione, l'eccezione viene passata al chiamante del delegato e non vengono richiamati i metodi rimanenti nell'elenco chiamate.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. Rilevare l'eccezione nel chiamante non modificare questo comportamento.Catching the exception in the caller does not alter this behavior.

Quando la firma dei metodi richiamati da un delegato include un valore restituito, il delegato restituisce il valore restituito dell'ultimo elemento nell'elenco chiamate.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 la firma include un parametro che viene passato per riferimento, il valore finale del parametro è il risultato di ogni metodo nell'elenco chiamate in esecuzione in modo sequenziale e aggiornare il valore del parametro.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'equivalente più vicino di un delegato in C è un puntatore a funzione.The closest equivalent of a delegate in C is a function pointer. Un delegato può rappresentare un metodo statico o un metodo di istanza.A delegate can represent a static method or an instance method. Quando il delegato rappresenta un metodo di istanza, il delegato archivia non solo un riferimento al punto di ingresso del metodo, ma anche un riferimento all'istanza della 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. A differenza dei puntatori a funzione, i delegati sono orientate a oggetti e indipendente dai tipi.Unlike function pointers, delegates are object oriented and type safe.

Costruttori

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

Inizializza un delegato che richiama il metodo di istanza specificato nell'istanza di classe specificata.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)

Inizializza un delegato tramite cui viene richiamato il metodo statico specificato dalla classe specificata.Initializes a delegate that invokes the specified static method from the specified class.

Proprietà

Method Method Method Method

Ottiene il metodo rappresentato dal delegato.Gets the method represented by the delegate.

Target Target Target Target

Ottiene l'istanza di classe sulla quale il metodo di istanza viene richiamato dal delegato corrente.Gets the class instance on which the current delegate invokes the instance method.

Metodi

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

Crea una copia superficiale del delegato.Creates a shallow copy of the delegate.

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

Esegue la concatenazione degli elenchi chiamate di due delegati.Concatenates the invocation lists of two delegates.

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

Esegue la concatenazione degli elenchi chiamate di una matrice di delegati.Concatenates the invocation lists of an array of delegates.

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

Esegue la concatenazione degli elenchi chiamate dei delegati multicast o combinabili specificati e del delegato multicast o combinabile corrente.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)

Crea un delegato del tipo specificato che rappresenta il metodo statico specificato.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)

Crea un delegato del tipo indicato per rappresentare il metodo statico specificato, in cui viene indicato anche il funzionamento in caso di errore di associazione.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)

Crea un delegato del tipo specificato che rappresenta il metodo statico o il metodo di istanza indicato, con il primo argomento specificato.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)

Crea un delegato del tipo specificato che rappresenta il metodo statico o il metodo di istanza indicato, con il primo argomento specificato e il funzionamento indicato in caso di errore di associazione.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)

Crea un delegato del tipo specificato che rappresenta il metodo di istanza specificato per il richiamo dell'istanza di classe specificata.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)

Crea un delegato del tipo specificato che rappresenta il metodo di istanza specificato, per il richiamo dell'istanza di classe specificata, con la distinzione tra maiuscole e minuscole specificata.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)

Crea un delegato del tipo specificato che rappresenta il metodo di istanza specificato, per il richiamo dell'istanza di classe specificata, con la distinzione tra maiuscole e minuscole specificata e il funzionamento specificato in caso di errore di associazione.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)

Crea un delegato del tipo specificato che rappresenta il metodo statico specificato della classe specificata.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)

Crea un delegato del tipo indicato che rappresenta il metodo statico specificato della classe indicata, con la distinzione tra maiuscole e minuscole specificata.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)

Crea un delegato del tipo specificato che rappresenta il metodo statico indicato della classe specificata, con la distinzione tra maiuscole e minuscole indicata e il funzionamento specificato in caso di errore di associazione.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[])

Richiama dinamicamente, ovvero ad associazione tardiva, il metodo rappresentato dal delegato corrente.Dynamically invokes (late-bound) the method represented by the current delegate.

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

Richiama dinamicamente, ovvero ad associazione tardiva, il metodo rappresentato dal delegato corrente.Dynamically invokes (late-bound) the method represented by the current delegate.

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

Determina se l'oggetto specificato e il delegato corrente sono dello stesso tipo e condividono gli stessi metodi e destinazioni e lo stesso elenco chiamate.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()

Restituisce il codice hash per il delegato.Returns a hash code for the delegate.

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

Restituisce l'elenco chiamate del delegato.Returns the invocation list of the delegate.

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

Ottiene il metodo static rappresentato dal delegato corrente.Gets the static method represented by the current delegate.

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

Non supportato.Not supported.

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

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

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

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

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

Consente di rimuovere l'ultima occorrenza dell'elenco chiamate di un delegato dall'elenco chiamate di un altro delegato.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)

Consente di rimuovere tutte le occorrenze dell'elenco chiamate di un delegato dall'elenco chiamate di un altro delegato.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)

Rimuove l'elenco chiamate di un delegato dall'elenco chiamate di un altro delegato.Removes the invocation list of a delegate from the invocation list of another delegate.

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

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Operatori

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

Determina se i delegati specificati sono uguali.Determines whether the specified delegates are equal.

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

Determina se i delegati specificati non sono uguali.Determines whether the specified delegates are not equal.

Extension Methods

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

Ottiene un oggetto che rappresenta il metodo rappresentato dal delegato specificato.Gets an object that represents the method represented by the specified delegate.

Si applica a

Vedi anche