Delegate Delegate Delegate Delegate Class

Definition

Stellt einen Delegaten dar. Hierbei handelt es sich um eine Datenstruktur, die auf eine statische Methode oder auf eine Klasseninstanz und eine Instanzenmethode dieser Klasse verweist.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
Vererbung
DelegateDelegateDelegateDelegate
Abgeleitet
Attribute
Implementiert

Beispiele

Das folgende Beispiel zeigt, wie Sie einen Delegaten, mit dem Namen definieren myMethodDelegate.The following example shows how to define a delegate named myMethodDelegate. Instanzen dieses Delegaten werden erstellt, für die eine Instanzmethode und eine statische Methode der geschachtelten mySampleClass Klasse.Instances of this delegate are created for an instance method and a static method of the nested mySampleClass class. Der Delegat für die Instanzmethode erfordert eine Instanz von mySampleClass.The delegate for the instance method requires an instance of mySampleClass. Die mySampleClass Instanz wird gespeichert, in einer Variablen namens 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 "".


Hinweise

Die Delegate Klasse ist die Basisklasse für Delegattypen.The Delegate class is the base class for delegate types. Jedoch nur das System und der Compiler können ableiten explizit die Delegate Klasse oder aus der MulticastDelegate Klasse.However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. Es ist auch nicht zulässig, einen neuen Typ von einem Delegattyp abzuleiten.It is also not permissible to derive a new type from a delegate type. Die Delegate Klasse gilt keinen Delegattyp aufweisen; es ist eine Klasse, die zum Ableiten von Delegattypen verwendet.The Delegate class is not considered a delegate type; it is a class used to derive delegate types.

Die meisten Sprachen implementieren eine delegate -Schlüsselwort und -Compiler für diese Sprachen sind in der Lage, abgeleitet der MulticastDelegate Klasse; daher sollten Benutzer verwenden die delegate -Schlüsselwort von der Sprache.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.

Hinweis

Die common Language Runtime stellt eine Invoke Methode für jeden Delegattyp, mit der gleichen Signatur wie der Delegat.The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. Sie müssen keinen zum Aufrufen dieser Methode explizit aus c#, Visual Basic oder Visual C++, da der Compiler sie automatisch aufrufen.You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. Die Invoke Methode eignet sich Reflektion Wenn Sie die Signatur des Delegattyps suchen möchten.The Invoke method is useful in reflection when you want to find the signature of the delegate type.

Die common Language Runtime stellt jedem Delegattyp BeginInvoke und EndInvoke Methoden, an den asynchronen Aufruf des Delegaten zu aktivieren.The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. Weitere Informationen zu diesen Methoden finden Sie unter Calling Synchronous Methods Asynchronously.For more information about these methods, see Calling Synchronous Methods Asynchronously.

Die Deklaration eines Delegattyps richtet einen Vertrag, der die Signatur der mindesten eine Methode angibt.The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. Ein Delegat ist eine Instanz einen Delegattyp aufweisen, die Verweise auf:A delegate is an instance of a delegate type that has references to:

  • Eine Instanzmethode einem Typ und einem Zielobjekt auf diesen Typ zugewiesen werden.An instance method of a type and a target object assignable to that type.

  • Eine Instanzmethode eines Typs, mit den hidden- this Parameter in der Liste der formalen Parameter verfügbar gemacht werden.An instance method of a type, with the hidden this parameter exposed in the formal parameter list. Der Delegat wird als eine offene Instanz Delegat.The delegate is said to be an open instance delegate.

  • Eine statische Methode.A static method.

  • Eine statische Methode und einem Zielobjekt, die auf den ersten Parameter der Methode zugewiesen werden.A static method and a target object assignable to the first parameter of the method. Der Delegat wird als über das erste Argument geschlossen werden.The delegate is said to be closed over its first argument.

Weitere Informationen zu Delegaten binden, finden Sie unter den CreateDelegate(Type, Object, MethodInfo, Boolean) -methodenüberladung.For more information on delegate binding, see the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload.

Hinweis

In der .NET Framework-Versionen 1.0 und 1.1 kann ein Delegat eine Methode darstellen, nur dann, wenn die Signatur der Methode genau die vom Typ Delegaten angegebene Signatur entspricht.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. Daher werden nur die ersten und dritten Aufzählungszeichen in der vorangehenden Liste unterstützt, und das erste Aufzählungszeichen erfordert eine genau übereinstimmen.Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

Wenn ein Delegat eine Instanzmethode geschlossene als erstes Argument (den meisten Fällen) darstellt, der Delegaten speichert einen Verweis auf den Einstiegspunkt der Methode und einem Verweis auf ein Objekt, das als Ziel bezeichnet, handelt es sich von einem Typ, der dem Typ zugewiesen werden, die definiert die -Methode.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. Wenn ein Delegat über eine offene Instanzmethode darstellt, speichert es einen Verweis auf den Einstiegspunkt der Methode.When a delegate represents an open instance method, it stores a reference to the method's entry point. Die Signatur des Delegaten muss die ausgeblendeten enthalten this Parameter in der formalen Parameterliste; in diesem Fall der Delegaten verfügt nicht über einen Verweis auf ein Zielobjekt und einem Zielobjekt muss bereitgestellt werden, wenn der Delegat aufgerufen wird.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.

Wenn ein Delegat eine statische Methode darstellt, speichert der Delegat einen Verweis auf den Einstiegspunkt der Methode.When a delegate represents a static method, the delegate stores a reference to the method's entry point. Wenn ein Delegat eine statische Methode, die als erstes Argument geschlossene darstellt, speichert der Delegat einen Verweis auf den Einstiegspunkt der Methode und einem Verweis auf ein Zielobjekt, das den Typ des ersten Arguments der Methode zugewiesen werden.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. Wenn der Delegat aufgerufen wird, erhält das erste Argument der statischen Methode das Zielobjekt.When the delegate is invoked, the first argument of the static method receives the target object.

Die Aufrufliste eines Delegaten ist eine geordnete Menge von Delegaten in denen jedes Element der Liste genau eine der Methoden, die durch den Delegaten dargestellte aufruft.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. Eine Aufrufliste kann es sich um doppelte Methoden enthalten.An invocation list can contain duplicate methods. Während eines Aufrufs werden Methoden in der Reihenfolge aufgerufen, in denen sie in der Aufrufliste angezeigt werden.During an invocation, methods are invoked in the order in which they appear in the invocation list. Ein Delegat versucht, jede Methode in der Aufrufliste zu aufzurufen; Duplikate werden aufgerufen, nachdem für jedes Mal, die sie in der Aufrufliste angezeigt werden.A delegate attempts to invoke every method in its invocation list; duplicates are invoked once for each time they appear in the invocation list. Delegaten sind unveränderlich. nach der Erstellung wird die Aufrufliste eines Delegaten nicht geändert werden.Delegates are immutable; once created, the invocation list of a delegate does not change.

Delegaten werden bezeichnet als Multicast- oder mit den flexibel kombinierbaren, da ein Delegat kann eine oder mehrere Methoden aufrufen, und kann in Kombination von Vorgängen verwendet werden.Delegates are referred to as multicast, or combinable, because a delegate can invoke one or more methods and can be used in combining operations.

Kombinieren die Vorgänge, z. B. Combine und Remove, vorhandene Delegaten nicht geändert.Combining operations, such as Combine and Remove, do not alter existing delegates. Stattdessen gibt einen neuen Delegat mit den Ergebnissen des Vorgangs einen Delegaten unverändert oder null.Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. Gibt eine Kombinationsoperation null Wenn das Ergebnis des Vorgangs ist ein Delegat, der nicht über mindestens eine Methode verweist.A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. Eine Operation zum Kombinieren gibt einen unveränderten Delegaten zurück, wenn der angeforderte Vorgang keine Auswirkungen hat.A combining operation returns an unchanged delegate when the requested operation has no effect.

Hinweis

Verwaltete Sprachen verwenden die Combine und Remove Methoden, Delegaten Vorgänge zu implementieren.Managed languages use the Combine and Remove methods to implement delegate operations. Beispiele hierfür sind die AddHandler und RemoveHandler Anweisungen in Visual Basic und die Operatoren "+=" und "=" auf Typen in c# zu delegieren.Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

Beginnend mit der .NET Framework 4.NET Framework 4, generischen Delegattypen können über Variante Typparameter verfügen.Starting with the .NET Framework 4.NET Framework 4, generic delegate types can have variant type parameters. Kontravariante Typparameter als Parametertypen des Delegaten verwendet werden können, und ein kovarianten Typparameter als Rückgabetyp verwendet werden kann.Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. Dieses Feature ermöglicht den generischen Delegaten Typen, die erstellt werden, aus der gleichen generischen Typdefinition zuweisungskompatibel, wenn ihre Typargumente Verweistypen mit einer vererbungsbeziehung sind sein, wie unter Kovarianz und Kontravarianz.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.

Hinweis

Generische Delegaten, die zuweisungskompatibel sind aufgrund der Varianz sind nicht unbedingt mit den flexibel kombinierbaren.Generic delegates that are assignment-compatible because of variance are not necessarily combinable. Um mit den flexibel kombinierbaren sein, müssen die Typen exakt übereinstimmen.To be combinable, the types must match exactly. Nehmen wir beispielsweise an, dass eine Klasse mit dem Namen Derived stammt aus einer Klasse namens Base.For example, suppose that a class named Derived is derived from a class named Base. Ein Delegat vom Typ Action<Base> (Action(Of Base) in Visual Basic) kann eine Variable des Typs zugewiesen werden Action<Derived>, aber die beiden Delegaten können nicht kombiniert werden, da die Typen nicht genau übereinstimmen.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.

Wenn eine aufgerufene Methode eine Ausnahme auslöst, beendet die Ausführung der Methode, die Ausnahme zurück an den Aufrufer des Delegaten übergeben wird und verbleibende Methoden in der Aufrufliste nicht aufgerufen werden.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. Die Ausnahme abfangen, im Aufrufer wird dieses Verhalten nicht geändert werden.Catching the exception in the caller does not alter this behavior.

Wenn die Signatur der Methoden aufgerufen, indem ein Delegat über einen Rückgabewert enthält, gibt den Delegaten den Rückgabewert des letzten Elements in der Aufrufliste zurück.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. Wenn die Signatur einen Parameter, der als Verweis übergeben wird enthält, ist der endgültige Wert des Parameters das Ergebnis jeder Methode in der Aufrufliste, die nacheinander ausgeführt, und aktualisieren den Wert des Parameters an.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.

Am nächsten entspricht einen Delegaten in C# einem Funktionszeiger.The closest equivalent of a delegate in C is a function pointer. Ein Delegat kann es sich um eine statische Methode oder Instanzmethode darstellen.A delegate can represent a static method or an instance method. Wenn der Delegat eine Instanzmethode darstellt, speichert der Delegaten nicht nur einen Verweis auf den Einstiegspunkt der Methode, sondern auch einen Verweis auf die Instanz der Klasse.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. Im Gegensatz zu Funktionszeigern sind Delegaten sind objektorientiert und typsicher.Unlike function pointers, delegates are object oriented and type safe.

Konstruktoren

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

Initialisiert einen Delegaten, der die angegebene Instanzenmethode für die angegebene Klasseninstanz aufruft.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)

Initialisiert einen Delegaten, der die angegebene statische Methode der angegebenen Klasse aufruft.Initializes a delegate that invokes the specified static method from the specified class.

Eigenschaften

Method Method Method Method

Ruft die Methode ab, die durch den Delegaten dargestellt wird.Gets the method represented by the delegate.

Target Target Target Target

Ruft die Klasseninstanz ab, für die der aktuelle Delegat die Instanzenmethode aufruft.Gets the class instance on which the current delegate invokes the instance method.

Methoden

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

Erstellt eine flache Kopie des Delegaten.Creates a shallow copy of the delegate.

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

Verkettet die Aufruflisten zweier Delegaten.Concatenates the invocation lists of two delegates.

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

Verkettet die Aufruflisten eines Arrays von Delegaten.Concatenates the invocation lists of an array of delegates.

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

Verkettet die Aufruflisten des angegebenen und des aktuellen Multicastdelegaten.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)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode darstellen soll.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)

Erstellt einen Delegaten vom angegeben Typ zum Darstellen der angegebenen statischen Methode mit dem angegebenen Verhalten bei Bindungsfehlern.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)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode mit dem angegebenen ersten Argument darstellt.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)

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll.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)

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

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt.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)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse mit der angegebenen Berücksichtigung von Groß- und Kleinschreibung darstellt.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)

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

Ruft die durch den aktuellen Delegaten dargestellte Methode dynamisch (mit später Bindung) auf.Dynamically invokes (late-bound) the method represented by the current delegate.

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

Ruft die durch den aktuellen Delegaten dargestellte Methode dynamisch (mit später Bindung) auf.Dynamically invokes (late-bound) the method represented by the current delegate.

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

Bestimmt, ob das angegebene Objekt und der aktuelle Delegat vom gleichen Typ sind und die gleichen Ziele, Methoden und Aufruflisten besitzen.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()

Gibt einen Hashcode für den Delegaten zurück.Returns a hash code for the delegate.

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

Gibt die Aufrufliste des Delegaten zurück.Returns the invocation list of the delegate.

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

Ruft die statische Methode ab, die durch den aktuellen Delegaten dargestellt wird.Gets the static method represented by the current delegate.

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

Wird nicht unterstützt.Not supported.

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

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

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

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

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

Entfernt das letzte Vorkommen der Aufrufliste eines Delegaten aus der Aufrufliste eines anderen Delegaten.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)

Entfernt alle Vorkommen der Aufrufliste eines Delegaten aus der Aufrufliste eines anderen Delegaten.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)

Entfernt die Aufrufliste eines Delegaten aus der Aufrufliste eines anderen Delegaten.Removes the invocation list of a delegate from the invocation list of another delegate.

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

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Operatoren

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

Bestimmt, ob die angegebenen Delegaten gleich sind.Determines whether the specified delegates are equal.

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

Bestimmt, ob die angegebenen Delegaten ungleich sind.Determines whether the specified delegates are not equal.

Extension Methods

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

Ruft ein Objekt, das die durch den angegebenen Delegaten dargestellte Methode darstellt.Gets an object that represents the method represented by the specified delegate.

Gilt für:

Siehe auch