Delegate Klasse

Definition

Stellt einen Delegaten dar, der eine Datenstruktur ist, die auf eine statische Methode oder eine Klasseninstanz und eine Instanzmethode dieser Klasse verweist.

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
Vererbung
Delegate
Abgeleitet
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird gezeigt, wie Sie einen Stellvertretungsnamen myMethodDelegatedefinieren. Instanzen dieser Stellvertretung werden für eine Instanzmethode und eine statische Methode der geschachtelten mySampleClass Klasse erstellt. Der Stellvertretung für die Instanzmethode erfordert eine Instanz von mySampleClass. Die mySampleClass Instanz wird in einer Variablen mit dem Namen mySCgespeichert.

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

Hinweise

Die Delegate Klasse ist die Basisklasse für Stellvertretungstypen. Allerdings können nur die System- und Compiler explizit aus der Klasse oder aus der Delegate MulticastDelegate Klasse abgeleitet werden. Es ist auch nicht zulässig, einen neuen Typ von einem Stellvertretungstyp abzuleiten. Die Delegate Klasse gilt nicht als Stellvertretungstyp; es ist eine Klasse, die zum Abgeleitet von Stellvertretungstypen verwendet wird.

Die meisten Sprachen implementieren ein delegate Schlüsselwort, und Compiler für diese Sprachen können aus der Klasse abgeleitet werden. Daher sollten Benutzer das schlüsselwort verwenden, das delegate von der MulticastDelegate Sprache bereitgestellt wird.

Hinweis

Die allgemeine Sprachlaufzeit bietet eine Invoke Methode für jeden Stellvertretungstyp mit derselben Signatur wie der Stellvertretung. Sie müssen diese Methode nicht explizit aus C#, Visual Basic oder Visual C++aufrufen, da die Compiler sie automatisch aufrufen. Die Invoke Methode ist nützlich, wenn Sie die Signatur des Stellvertretungstyps finden möchten.

Die allgemeine Sprachlaufzeit stellt jeden Stellvertretungstyp mit BeginInvoke und EndInvoke Methoden bereit, um asynchrone Aufrufe des Stellvertretungsstellvertretungs zu ermöglichen. Weitere Informationen zu diesen Methoden finden Sie unter Aufrufen synchroner Methoden asynchron.

Die Deklaration eines Stellvertretungstyps legt einen Vertrag fest, der die Signatur einer oder mehrerer Methoden angibt. Ein Stellvertretung ist eine Instanz eines Stellvertretungstyps, der Verweise auf Folgendes aufweist:

  • Eine Instanzmethode eines Typs und ein Zielobjekt, das diesem Typ zugewiesen werden kann.

  • Eine Instanzmethode eines Typs mit dem ausgeblendeten this Parameter, der in der formalen Parameterliste verfügbar gemacht wird. Der Stellvertretung ist als offene Instanzstellvertretung angegeben.

  • Eine statische Methode.

  • Eine statische Methode und ein Zielobjekt, das dem ersten Parameter der Methode zuzuweisen ist. Der Stellvertretung soll über das erste Argument geschlossen werden.

Weitere Informationen zur Stellvertretungsbindung finden Sie in der CreateDelegate(Type, Object, MethodInfo, Boolean) Methodenüberladung.

Hinweis

In den .NET Framework Versionen 1.0 und 1.1 kann ein Stellvertretung nur eine Methode darstellen, wenn die Signatur der Methode genau mit der vom Stellvertretungstyp angegebenen Signatur übereinstimmt. Daher werden nur die ersten und dritten Aufzählungszeichen in der vorherigen Liste unterstützt, und das erste Aufzählungszeichen erfordert eine genaue Typgleichung.

Wenn ein Stellvertretung eine Instanzmethode darstellt, die über das erste Argument geschlossen ist (der häufigste Fall), speichert der Stellvertretung einen Verweis auf den Einstiegspunkt der Methode und einen Verweis auf ein Objekt, das als Ziel bezeichnet wird, das dem Typ zugeordnet ist, der die Methode definiert hat. Wenn ein Stellvertretung eine offene Instanzmethode darstellt, speichert er einen Verweis auf den Einstiegspunkt der Methode. Die Stellvertretungssignatur muss den ausgeblendeten this Parameter in der formalen Parameterliste enthalten. In diesem Fall hat der Stellvertretung keinen Verweis auf ein Zielobjekt, und ein Zielobjekt muss angegeben werden, wenn der Stellvertretung aufgerufen wird.

Wenn ein Stellvertretung eine statische Methode darstellt, speichert der Stellvertretung einen Verweis auf den Einstiegspunkt der Methode. Wenn ein Stellvertretung eine statische Methode darstellt, die über das erste Argument geschlossen ist, speichert der Stellvertretung einen Verweis auf den Einstiegspunkt der Methode und einen Verweis auf ein Zielobjekt, das dem ersten Argument der Methode zugewiesen ist. Wenn der Stellvertretung aufgerufen wird, erhält das erste Argument der statischen Methode das Zielobjekt. Dieses erste Argument muss ein Referenztyp sein.

Die Aufrufliste einer Stellvertretung ist eine sortierte Gruppe von Stellvertretungen, in der jedes Element der Liste genau eine der Methoden aufruft, die durch den Stellvertretung dargestellt werden. Eine Aufrufliste kann doppelte Methoden enthalten. Während eines Aufrufs werden Methoden in der Reihenfolge aufgerufen, in der sie in der Aufrufliste angezeigt werden. Ein Stellvertretung versucht, jede Methode in der Aufrufliste aufzurufen; Duplikate werden für jedes Mal aufgerufen, wenn sie in der Aufrufliste angezeigt werden. Stellvertretungen sind unveränderlich; sobald sie erstellt wurde, ändert sich die Anrufliste eines Stellvertretungsstellvertretungs nicht.

Stellvertretungen werden als Multicast bezeichnet oder kombiniert, da ein Stellvertretung eine oder mehrere Methoden aufrufen kann und in Kombinationsvorgängen verwendet werden kann.

Das Kombinieren von Vorgängen, z Combine . B. und Remove, ändern keine vorhandenen Stellvertretungen. Stattdessen gibt ein solcher Vorgang eine neue Stellvertretung zurück, die die Ergebnisse des Vorgangs, eine unveränderte Stellvertretung oder nullenthält. Ein Kombinationsvorgang gibt null zurück, wenn das Ergebnis des Vorgangs ein Stellvertretung ist, der nicht auf mindestens eine Methode verweist. Ein Kombinationsvorgang gibt einen unveränderten Stellvertretung zurück, wenn der angeforderte Vorgang keine Auswirkung hat.

Hinweis

Verwaltete Sprachen verwenden die Combine Remove und Methoden zum Implementieren von Stellvertretungsvorgängen. Beispiele umfassen die AddHandler und RemoveHandler Anweisungen in Visual Basic und den Operatoren += und -= auf Stellvertretungstypen in C#.

Ab dem .NET Framework 4 können generische Stellvertretungstypen Variantentypparameter aufweisen. Kontravariant-Typparameter können als Parametertypen des Stellvertretungstyps verwendet werden, und ein kovarianter Typparameter kann als Rückgabetyp verwendet werden. Dieses Feature ermöglicht generische Stellvertretungstypen, die aus derselben generischen Typdefinition erstellt werden, eine Zuordnungskompatibilität zu sein, wenn ihre Typargumente Referenztypen mit einer Vererbungsbeziehung sind, wie in Covariance und Contravariance erläutert.

Hinweis

Generische Stellvertretungen, die aufgrund von Varianz zuweisungskompatible sind, sind nicht unbedingt kombiniert. Um kombinieren zu können, muss die Typen genau übereinstimmen. Angenommen, eine Klasse namens wird von einer Klasse mit dem Derived Namen Base". Ein Stellvertretung von Typ (Action(Of Base) in Visual Basic) kann einer Variablen des Typs Action<Base> Action<Derived>zugewiesen werden, aber die beiden Stellvertretungen können nicht kombiniert werden, da die Typen nicht genau übereinstimmen.

Wenn eine aufgerufene Methode eine Ausnahme auslöst, wird die Methode nicht mehr ausgeführt, die Ausnahme wird an den Aufrufer des Stellvertretungs übergeben, und die verbleibenden Methoden in der Anrufliste werden nicht aufgerufen. Das Erfassen der Ausnahme im Anrufer ändert dieses Verhalten nicht.

Wenn die Signatur der von einem Stellvertretung aufgerufenen Methoden einen Rückgabewert enthält, gibt der Stellvertretung den Rückgabewert des letzten Elements in der Aufrufliste zurück. Wenn die Signatur einen Parameter enthält, der durch Verweis übergeben wird, ist der endgültige Wert des Parameters das Ergebnis jeder Methode in der Aufrufliste, die sequenziell ausgeführt wird und den Wert des Parameters aktualisiert.

Das nächstgelegene Äquivalent eines Stellvertretungs in C ist ein Funktionszeiger. Ein Stellvertretung kann eine statische Methode oder eine Instanzmethode darstellen. Wenn der Stellvertretung eine Instanzmethode darstellt, speichert der Stellvertretung nicht nur einen Verweis auf den Einstiegspunkt der Methode, sondern auch einen Verweis auf die Klasseninstanz. Im Gegensatz zu Funktionszeigern sind Stellvertretungen objektorientiert und typsicher.

Konstruktoren

Delegate(Object, String)

Initialisiert einen Delegaten, der die angegebene Instanzenmethode für die angegebene Klasseninstanz aufruft.

Delegate(Type, String)

Initialisiert einen Delegaten, der die angegebene statische Methode der angegebenen Klasse aufruft.

Eigenschaften

Method

Ruft die Methode ab, die durch den Delegaten dargestellt wird.

Target

Ruft die Klasseninstanz ab, für die der aktuelle Delegat die Instanzenmethode aufruft.

Methoden

Clone()

Erstellt eine flache Kopie des Delegaten.

Combine(Delegate, Delegate)

Verkettet die Aufruflisten zweier Delegaten.

Combine(Delegate[])

Verkettet die Aufruflisten eines Arrays von Delegaten.

CombineImpl(Delegate)

Verkettet die Aufruflisten des angegebenen und des aktuellen Multicastdelegaten.

CreateDelegate(Type, MethodInfo)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode darstellen soll.

CreateDelegate(Type, MethodInfo, Boolean)

Erstellt einen Delegaten vom angegeben Typ zum Darstellen der angegebenen statischen Methode mit dem angegebenen Verhalten bei Bindungsfehlern.

CreateDelegate(Type, Object, MethodInfo)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode mit dem angegebenen ersten Argument darstellt.

CreateDelegate(Type, Object, MethodInfo, Boolean)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode mit dem angegebenen ersten Argument und dem angegebenen Verhalten bei Bindungsfehlern darstellt.

CreateDelegate(Type, Object, String)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll.

CreateDelegate(Type, Object, String, Boolean)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll, wobei die Groß- und Kleinschreibung den Angaben entsprechend berücksichtigt bzw. nicht berücksichtigt wird.

CreateDelegate(Type, Object, String, Boolean, Boolean)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll, wobei die Groß- und Kleinschreibung und das Verhalten bei Bindungsfehlern den Angaben entsprechend berücksichtigt bzw. nicht berücksichtigt wird.

CreateDelegate(Type, Type, String)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt.

CreateDelegate(Type, Type, String, Boolean)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse mit der angegebenen Berücksichtigung von Groß- und Kleinschreibung darstellt.

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt, wobei die Groß- und Kleinschreibung und das Verhalten bei Bindungsfehlern den Angaben entsprechend berücksichtigt bzw. nicht berücksichtigt wird.

DynamicInvoke(Object[])

Ruft die durch den aktuellen Delegaten dargestellte Methode dynamisch (mit später Bindung) auf.

DynamicInvokeImpl(Object[])

Ruft die durch den aktuellen Delegaten dargestellte Methode dynamisch (mit später Bindung) auf.

Equals(Object)

Bestimmt, ob das angegebene Objekt und der aktuelle Delegat vom gleichen Typ sind und die gleichen Ziele, Methoden und Aufruflisten besitzen.

GetHashCode()

Gibt einen Hashcode für den Delegaten zurück.

GetInvocationList()

Gibt die Aufrufliste des Delegaten zurück.

GetMethodImpl()

Ruft die statische Methode ab, die durch den aktuellen Delegaten dargestellt wird.

GetObjectData(SerializationInfo, StreamingContext)

Wird nicht unterstützt.

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
Remove(Delegate, Delegate)

Entfernt das letzte Vorkommen der Aufrufliste eines Delegaten aus der Aufrufliste eines anderen Delegaten.

RemoveAll(Delegate, Delegate)

Entfernt alle Vorkommen der Aufrufliste eines Delegaten aus der Aufrufliste eines anderen Delegaten.

RemoveImpl(Delegate)

Entfernt die Aufrufliste eines Delegaten aus der Aufrufliste eines anderen Delegaten.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Operatoren

Equality(Delegate, Delegate)

Bestimmt, ob die angegebenen Delegaten gleich sind.

Inequality(Delegate, Delegate)

Bestimmt, ob die angegebenen Delegaten ungleich sind.

Erweiterungsmethoden

GetMethodInfo(Delegate)

Ruft ein Objekt ab, das die Methode darstellt, die vom angegebenen Delegaten dargestellt wird.

Gilt für:

Siehe auch