Delegate Classe

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à
Delegate
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. Le istanze di questo delegato vengono create per un metodo di istanza e un metodo statico della mySampleClass classe annidata.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 mySampleClassdi.The delegate for the instance method requires an instance of mySampleClass. L' mySampleClass istanza viene salvata in una variabile mySCdenominata.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 "".


Commenti

La 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 Delegate modo esplicito dalla MulticastDelegate classe o dalla classe.However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. Non è inoltre consentito derivare un nuovo tipo da un tipo delegato.It is also not permissible to derive a new type from a delegate type. La Delegate classe non è considerata un tipo delegato. si tratta di 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.

La maggior parte dei delegate linguaggi implementa una parola chiave e i compilatori per tali linguaggi possono derivare MulticastDelegate dalla classe; pertanto, gli delegate utenti devono usare la parola chiave fornita dal 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

Il Common Language Runtime fornisce un Invoke metodo per ogni tipo 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 da C#, Visual Basic o oggetto visivo C++, perché i compilatori lo 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 per la 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.

Il Common Language Runtime fornisce a ogni tipo BeginInvoke delegato i metodi e EndInvoke 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 ulteriori informazioni su questi metodi, vedere chiamata asincrona dei metodi sincroni.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 assegnabile a tale tipo.An instance method of a type and a target object assignable to that type.

  • Metodo di istanza di un tipo, con il parametro this nascosto 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 viene definito come delegato di istanza aperta.The delegate is said to be an open instance delegate.

  • Metodo statico.A static method.

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

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

Nota

Nelle versioni .NET Framework 1,0 e 1,1, un delegato può rappresentare un metodo solo se la firma del metodo corrisponde esattamente alla firma specificata dal tipo 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. Sono pertanto supportati solo il primo e il terzo elenco di punti elenco precedente e il primo Bullet richiede una corrispondenza esatta del tipo.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 sul primo argomento (il caso più comune), il delegato archivia un riferimento al punto di ingresso del metodo e un riferimento a un oggetto, denominato destinazione, che è di un tipo assegnabile al tipo che ha definito 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 aperto, 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 il this parametro hidden nell'elenco di parametri formali. in questo caso, il delegato non dispone di un riferimento a un oggetto di destinazione e un oggetto di destinazione deve essere fornito 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 sul primo argomento, il delegato archivia un riferimento al punto di ingresso del metodo e un riferimento a un oggetto di destinazione assegnabile 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 chiamate può contenere metodi duplicati.An invocation list can contain duplicate methods. Durante una chiamata, i metodi vengono richiamati nell'ordine in cui sono 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; i duplicati vengono richiamati una volta per ogni volta che vengono visualizzati nell'elenco chiamate.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 non sono modificabili; una volta creato, l'elenco chiamate di un delegato non cambia.Delegates are immutable; once created, the invocation list of a delegate does not change.

I delegati sono denominati multicast o combinabili, perché un delegato può richiamare uno o più metodi e può essere utilizzato nelle operazioni di combinazione.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 Combine combinazione di operazioni, ad Removeesempio e, non modifica i delegati esistenti.Combining operations, such as Combine and Remove, do not alter existing delegates. Al contrario, tale operazione restituisce un nuovo delegato che contiene i risultati dell'operazione, un delegato non modificato o null.Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. Un'operazione di combinazione null restituisce 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 non modificato quando l'operazione richiesta non ha alcun effetto.A combining operation returns an unchanged delegate when the requested operation has no effect.

Nota

I linguaggi gestiti usano Combine i Remove metodi e per implementare le operazioni del delegato.Managed languages use the Combine and Remove methods to implement delegate operations. Gli esempi includono AddHandler le RemoveHandler istruzioni e in Visual Basic e gli operatori + = e-= sui 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 da .NET Framework 4.NET Framework 4, i tipi delegati generici possono avere parametri di tipo Variant.Starting with the .NET Framework 4.NET Framework 4, generic delegate types can have variant type parameters. I 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 ai tipi delegati generici costruiti dalla stessa definizione di tipo generico di essere compatibili con l'assegnazione se i relativi argomenti di tipo sono tipi di riferimento con una relazione di ereditarietà, come illustrato in covarianza e 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

Delegati generici che sono compatibili con l'assegnazione perché la varianza non è necessariamente combinabile.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. Si supponga, ad esempio, che una Derived classe denominata derivi da una classe Basedenominata.For example, suppose that a class named Derived is derived from a class named Base. Un delegato di tipo Action<Base> (Action(Of Base) in Visual Basic) può essere assegnato a una variabile di tipo Action<Derived>, ma i due delegati non possono essere combinati 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, l'esecuzione del metodo viene arrestata, l'eccezione viene passata nuovamente al chiamante del delegato e i metodi rimanenti nell'elenco chiamate non vengono richiamati.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. Il rilevamento dell'eccezione nel chiamante non modifica 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 passato per riferimento, il valore finale del parametro è il risultato di ogni metodo nell'elenco chiamate eseguito in sequenza e di aggiornamento del 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 orientati agli oggetti e indipendenti dai tipi.Unlike function pointers, delegates are object oriented and type safe.

Costruttori

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)

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

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

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()

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

Combine(Delegate, Delegate)

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

Combine(Delegate[])

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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[])

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[])

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)

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()

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

GetInvocationList()

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

GetMethodImpl()

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

GetObjectData(SerializationInfo, StreamingContext)

Non supportato.Not supported.

GetType()

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

(Ereditato da Object)
MemberwiseClone()

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

(Ereditato da Object)
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)

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)

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()

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

(Ereditato da Object)

Operatori

Equality(Delegate, Delegate)

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

Inequality(Delegate, Delegate)

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

Metodi di estensione

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