Delegate Classe

Definizione

Rappresenta un delegato, ovvero una struttura dei dati che fa riferimento a un metodo statico o a un'istanza della classe, nonché a un metodo di istanza di tale classe.

public ref class Delegate abstract
public ref class Delegate abstract : ICloneable, System::Runtime::Serialization::ISerializable
public abstract class Delegate
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
type Delegate = class
type Delegate = class
    interface ICloneable
    interface ISerializable
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
type Delegate = class
    interface ICloneable
    interface ISerializable
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Delegate = class
    interface ICloneable
    interface ISerializable
Public MustInherit Class Delegate
Public MustInherit Class Delegate
Implements ICloneable, ISerializable
Ereditarietà
Delegate
Derivato
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrato come definire un delegato denominato myMethodDelegate. Le istanze di questo delegato vengono create per un metodo di istanza e un metodo statico della classe annidata mySampleClass . Il delegato per il metodo di istanza richiede un'istanza di mySampleClass. L'istanza mySampleClass viene salvata in una variabile denominata mySC.

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

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

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

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

      return ("zero");
   }


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

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

      return ("");
   }

};

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

/*
This code produces the following output:

5 is positive; use the sign "+".
-3 is negative; use the sign "-".
0 is zero; use the sign "".
*/
using System;
public class SamplesDelegate  {

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

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

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

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

   public static void Main()  {

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

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


/*
This code produces the following output:

5 is positive; use the sign "+".
-3 is negative; use the sign "-".
0 is zero; use the sign "".
*/
// Declares a delegate for a method that takes in an int and returns a string.
type MyMethodDelegate = delegate of int -> string

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

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

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

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

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

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

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

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

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

   Public Shared Sub Main()

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

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

   End Sub

End Class


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

Commenti

La Delegate classe è la classe di base per i tipi delegati. Tuttavia, solo i compilatori e di sistema possono derivare in modo esplicito dalla Delegate classe o dalla MulticastDelegate classe. Non è anche consentito derivare un nuovo tipo da un tipo delegato. La Delegate classe non viene considerata un tipo delegato. Si tratta di una classe usata per derivare i tipi delegati.

La maggior parte dei linguaggi implementa una delegate parola chiave e i compilatori per tali linguaggi sono in grado di derivare dalla MulticastDelegate classe. Pertanto, gli utenti devono usare la delegate parola chiave fornita dal linguaggio.

Nota

Common Language Runtime fornisce un Invoke metodo per ogni tipo di delegato, con la stessa firma del delegato. Non è necessario chiamare questo metodo in modo esplicito da C#, Visual Basic o Visual C++, perché i compilatori lo chiamano automaticamente. Il Invoke metodo è utile in reflection quando si vuole trovare la firma del tipo delegato.

Common Language Runtime fornisce ogni tipo di delegato con BeginInvoke e EndInvoke metodi, per abilitare la chiamata asincrona del delegato. Per altre informazioni su questi metodi, vedere Chiamata di metodi sincroni in modo asincrono.

La dichiarazione di un tipo delegato stabilisce un contratto che specifica la firma di uno o più metodi. Un delegato è un'istanza di un tipo delegato con riferimenti a:

  • Metodo di istanza di un tipo e un oggetto di destinazione assegnabile a tale tipo.

  • Metodo di istanza di un tipo, con il parametro nascosto this esposto nell'elenco dei parametri formali. Il delegato viene detto essere un delegato di istanza aperta.

  • Metodo statico.

  • Metodo statico e oggetto di destinazione assegnabile al primo parametro del metodo. Il delegato viene detto di essere chiuso sul primo argomento.

Per altre informazioni sull'associazione delegato, vedere l'overload del CreateDelegate(Type, Object, MethodInfo, Boolean) metodo.

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. Pertanto, solo i primi e i terzi punti elenco nell'elenco precedente sono supportati e il primo punto puntato richiede una corrispondenza esatta del tipo.

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 il metodo. Quando un delegato rappresenta un metodo di istanza aperta, archivia un riferimento al punto di ingresso del metodo. La firma delegato deve includere il parametro nascosto this nell'elenco dei parametri formali. In questo caso, il delegato non ha un riferimento a un oggetto di destinazione e un oggetto di destinazione deve essere fornito quando viene richiamato il delegato.

Quando un delegato rappresenta un metodo statico, il delegato archivia un riferimento al punto di ingresso del metodo. 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. Quando viene richiamato il delegato, il primo argomento del metodo statico riceve l'oggetto di destinazione. Questo primo argomento deve essere un tipo di riferimento.

L'elenco di chiamate di un delegato è un set ordinato di delegati in cui ogni elemento dell'elenco richiama esattamente uno dei metodi rappresentati dal delegato. Un elenco di chiamate può contenere metodi duplicati. Durante una chiamata, i metodi vengono richiamati nell'ordine in cui vengono visualizzati nell'elenco di chiamate. Un delegato tenta di richiamare ogni metodo nell'elenco di chiamate; i duplicati vengono richiamati una volta per ogni volta che vengono visualizzati nell'elenco di chiamate. I delegati sono non modificabili; una volta creato, l'elenco di chiamate di un delegato non cambia.

I delegati vengono definiti multicast o combinabili, perché un delegato può richiamare uno o più metodi e può essere usato nella combinazione di operazioni.

La combinazione di operazioni, ad esempio Combine e Remove, non modifica i delegati esistenti. Invece, tale operazione restituisce un nuovo delegato che contiene i risultati dell'operazione, un delegato non modificato o null. Un'operazione di combinazione restituisce null quando il risultato dell'operazione è un delegato che non fa riferimento almeno a un metodo. Un'operazione di combinazione restituisce un delegato invariato quando l'operazione richiesta non ha alcun effetto.

Nota

I linguaggi gestiti usano i Combine metodi e Remove per implementare le operazioni delegate. Gli esempi includono le AddHandler istruzioni e RemoveHandler in Visual Basic e gli operatori += e -= sui tipi di delegato in C#.

A partire dal .NET Framework 4, i tipi di delegato generici possono avere parametri di tipo varianti. I parametri di tipo contravariante possono essere usati come tipi di parametro del delegato e un parametro di tipo covariante può essere usato come tipo restituito. Questa funzionalità consente ai tipi di delegato generici creati dalla stessa definizione di tipo generico di essere compatibili con l'assegnazione se gli argomenti di tipo sono tipi di riferimento con una relazione di ereditarietà, come illustrato in Covariance e Contravarianza.

Nota

I delegati generici compatibili con l'assegnazione a causa della varianza non sono necessariamente combinabili. Per essere combinabili, i tipi devono corrispondere esattamente. Si supponga, ad esempio, che una classe denominata Derived sia derivata da una classe denominata 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.

Se un metodo richiamato genera un'eccezione, il metodo arresta l'esecuzione, l'eccezione viene passata al chiamante del delegato e i metodi rimanenti nell'elenco di chiamate non vengono richiamati. L'eccezione rilevata nel chiamante non modifica questo comportamento.

Quando la firma dei metodi richiamati da un delegato include un valore restituito, il delegato restituisce il valore restituito dell'ultimo elemento nell'elenco di chiamate. Quando la firma include un parametro passato da riferimento, il valore finale del parametro è il risultato di ogni metodo nell'elenco di chiamate che esegue in sequenza e aggiorna il valore del parametro.

L'equivalente più vicino di un delegato in C è un puntatore di funzione. Un delegato può rappresentare un metodo statico o un metodo di istanza. 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. A differenza dei puntatori alle funzioni, i delegati sono orientati a oggetti e tipi sicuri.

Costruttori

Delegate(Object, String)

Inizializza un delegato che richiama il metodo di istanza specificato nell'istanza di classe specificata.

Delegate(Type, String)

Inizializza un delegato tramite cui viene richiamato il metodo statico specificato dalla classe specificata.

Proprietà

Method

Ottiene il metodo rappresentato dal delegato.

Target

Ottiene l'istanza di classe sulla quale il metodo di istanza viene richiamato dal delegato corrente.

Metodi

Clone()

Crea una copia superficiale del delegato.

Combine(Delegate, Delegate)

Esegue la concatenazione degli elenchi chiamate di due delegati.

Combine(Delegate[])

Esegue la concatenazione degli elenchi chiamate di una matrice di delegati.

CombineImpl(Delegate)

Esegue la concatenazione degli elenchi chiamate dei delegati multicast o combinabili specificati e del delegato multicast o combinabile corrente.

CreateDelegate(Type, MethodInfo)

Crea un delegato del tipo specificato che rappresenta il metodo statico specificato.

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.

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.

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.

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.

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.

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.

CreateDelegate(Type, Type, String)

Crea un delegato del tipo specificato che rappresenta il metodo statico specificato della classe specificata.

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.

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.

DynamicInvoke(Object[])

Richiama dinamicamente, ovvero ad associazione tardiva, il metodo rappresentato dal delegato corrente.

DynamicInvokeImpl(Object[])

Richiama dinamicamente, ovvero ad associazione tardiva, il metodo rappresentato dal delegato corrente.

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.

GetHashCode()

Restituisce il codice hash per il delegato.

GetInvocationList()

Restituisce l'elenco chiamate del delegato.

GetMethodImpl()

Ottiene il metodo static rappresentato dal delegato corrente.

GetObjectData(SerializationInfo, StreamingContext)

Non supportata.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
Remove(Delegate, Delegate)

Rimuove l'ultima occorrenza dell'elenco chiamate di un delegato dall'elenco chiamate di un altro delegato.

RemoveAll(Delegate, Delegate)

Rimuove tutte le occorrenze dell'elenco chiamate di un delegato dall'elenco chiamate di un altro delegato.

RemoveImpl(Delegate)

Rimuove l'elenco chiamate di un delegato dall'elenco chiamate di un altro delegato.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Operatori

Equality(Delegate, Delegate)

Determina se i delegati specificati sono uguali.

Inequality(Delegate, Delegate)

Determina se i delegati specificati non sono uguali.

Metodi di estensione

GetMethodInfo(Delegate)

Ottiene un oggetto che rappresenta il metodo rappresentato dal delegato specificato.

Si applica a

Vedi anche