Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Delegate-Klasse

 

Veröffentlicht: Oktober 2016

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.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)


[SerializableAttribute]
[ClassInterfaceAttribute(ClassInterfaceType.AutoDual)]
[ComVisibleAttribute(true)]
public abstract class Delegate : ICloneable, ISerializable

NameBeschreibung
System_CAPS_protmethodDelegate(Object, String)

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

System_CAPS_protmethodDelegate(Type, String)

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

NameBeschreibung
System_CAPS_pubpropertyMethod

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

System_CAPS_pubpropertyTarget

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

NameBeschreibung
System_CAPS_pubmethodClone()

Erstellt eine flache Kopie des Delegaten.

System_CAPS_pubmethodSystem_CAPS_staticCombine(Delegate, Delegate)

Verkettet die Aufruflisten zweier Delegaten.

System_CAPS_pubmethodSystem_CAPS_staticCombine(Delegate[])

Verkettet die Aufruflisten eines Arrays von Delegaten.

System_CAPS_protmethodCombineImpl(Delegate)

Verkettet die Aufruflisten des angegebenen und des aktuellen Multicastdelegaten.

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(Type, MethodInfo)

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

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(Type, MethodInfo, Boolean)

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

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(Type, Object, MethodInfo)

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

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(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.

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(Type, Object, String)

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

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(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.

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(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.

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(Type, Type, String)

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

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(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.

System_CAPS_pubmethodSystem_CAPS_staticCreateDelegate(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.

System_CAPS_pubmethodDynamicInvoke(Object[])

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

System_CAPS_protmethodDynamicInvokeImpl(Object[])

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

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt und der aktuelle Delegat vom gleichen Typ sind und die gleichen Ziele, Methoden und Aufruflisten besitzen.(Überschreibt Object.Equals(Object).)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von „Object“.)

System_CAPS_pubmethodGetHashCode()

Gibt einen Hashcode für den Delegaten zurück.(Überschreibt Object.GetHashCode().)

System_CAPS_pubmethodGetInvocationList()

Gibt die Aufrufliste des Delegaten zurück.

System_CAPS_protmethodGetMethodImpl()

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

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Wird nicht unterstützt.

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticRemove(Delegate, Delegate)

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

System_CAPS_pubmethodSystem_CAPS_staticRemoveAll(Delegate, Delegate)

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

System_CAPS_protmethodRemoveImpl(Delegate)

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

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

NameBeschreibung
System_CAPS_puboperatorSystem_CAPS_staticEquality(Delegate, Delegate)

Bestimmt, ob die angegebenen Delegaten gleich sind.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Delegate, Delegate)

Bestimmt, ob die angegebenen Delegaten ungleich sind.

NameBeschreibung
System_CAPS_pubmethodGetMethodInfo()

Ruft ein Objekt, das durch den angegebenen Delegaten dargestellte Methode darstellt.(Definiert durch RuntimeReflectionExtensions.)

The T:System.Delegate class is the base class for delegate types. However, only the system and compilers can derive explicitly from the T:System.Delegate class or from the T:System.MulticastDelegate class. It is also not permissible to derive a new type from a delegate type. The T:System.Delegate class is not considered a delegate type; it is a class used to derive delegate types.

Most languages implement a delegate keyword, and compilers for those languages are able to derive from the T:System.MulticastDelegate class; therefore, users should use the delegate keyword provided by the language.

System_CAPS_noteHinweis

The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. The Invoke method is useful in reflection when you want to find the signature of the delegate type.

The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. For more information about these methods, see Calling Synchronous Methods Asynchronously.

The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. A delegate is an instance of a delegate type that has references to:

  • An instance method of a type and a target object assignable to that type.

  • An instance method of a type, with the hidden this parameter exposed in the formal parameter list. The delegate is said to be an open instance delegate.

  • A static method.

  • A static method and a target object assignable to the first parameter of the method. The delegate is said to be closed over its first argument.

For more information on delegate binding, see the M:System.Delegate.CreateDelegate(System.Type,System.Object,System.Reflection.MethodInfo,System.Boolean) method overload.

System_CAPS_noteHinweis

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. Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

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. When a delegate represents an open instance method, it stores a reference to the method's entry point. 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.

When a delegate represents a static method, the delegate stores a reference to the method's entry point. 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. When the delegate is invoked, the first argument of the static method receives the target object.

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. An invocation list can contain duplicate methods. During an invocation, methods are invoked in the order in which they appear in the invocation list. A delegate attempts to invoke every method in its invocation list; duplicates are invoked once for each time they appear in the invocation list. Delegates are immutable; once created, the invocation list of a delegate does not change.

Delegates are referred to as multicast, or combinable, because a delegate can invoke one or more methods and can be used in combining operations.

Combining operations, such as M:System.Delegate.Combine(System.Delegate,System.Delegate) and M:System.Delegate.Remove(System.Delegate,System.Delegate), do not alter existing delegates. Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. A combining operation returns an unchanged delegate when the requested operation has no effect.

System_CAPS_noteHinweis

Managed languages use the M:System.Delegate.Combine(System.Delegate,System.Delegate) and M:System.Delegate.Remove(System.Delegate,System.Delegate) methods to implement delegate operations. Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

Starting with the net_v40_long, generic delegate types can have variant type parameters. Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. 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 in Generics.

System_CAPS_noteHinweis

Generic delegates that are assignment-compatible because of variance are not necessarily combinable. To be combinable, the types must match exactly. For example, suppose that a class named Derived is derived from a class named Base. 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.

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. Catching the exception in the caller does not alter this behavior.

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

The closest equivalent of a delegate in C or C++ is a function pointer. A delegate can represent a static method or an instance method. 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. Unlike function pointers, delegates are object oriented and type safe.

The following example shows how to define a delegate named myMethodDelegate. Instances of this delegate are created for an instance method and a static method of the nested mySampleClass class. The delegate for the instance method requires an instance of mySampleClass. The mySampleClass instance is saved in a variable named mySC.

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

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: