(0) exportieren Drucken
Alle erweitern

Delegate-Klasse

Aktualisiert: November 2007

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
/** @attribute SerializableAttribute */ 
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.AutoDual) */
/** @attribute ComVisibleAttribute(true) */
public abstract class Delegate implements ICloneable, 
	ISerializable
public abstract class Delegate implements ICloneable, ISerializable

Die Delegate-Klasse ist die Basisklasse für Delegatentypen. Nur das System oder Compiler können jedoch explizit von der Delegate-Klasse oder von der MulticastDelegate-Klasse ableiten. Es ist auch nicht zulässig, von einem Delegatentyp einen neuen Typ abzuleiten. Die Delegate-Klasse wird nicht als Delegatentyp betrachtet. Sie ist eine Klasse zum Ableiten von Delegatentypen.

Die meisten Programmiersprachen implementieren das Schlüsselwort delegate, und Compiler für diese Sprachen können von der MulticastDelegate-Klasse ableiten. Benutzer sollten daher das von der Sprache bereitgestellte Schlüsselwort delegate verwenden.

Zusätzlich zu geerbten Methoden stellt die Common Language Runtime zwei spezielle Methoden für Delegattypen bereit: BeginInvoke und EndInvoke. Weitere Informationen über diese Methoden finden Sie unter Asynchrones Aufrufen von synchronen Methoden.

Durch die Deklaration eines Delegatentyps wird ein Vertrag erstellt, der die Signatur einer oder mehrerer Methoden angibt. Ein Delegat ist eine Instanz eines Delegattyps, der auf Folgendes verweist:

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

  • Eine Instanzmethode eines Typs, mit dem ausgeblendeten this-Parameter, der in der formalen Parameterliste verfügbar gemacht wird. Der Delegat wird als ein offener Instanzdelegat bezeichnet.

  • Eine statische Methode.

  • Eine statische Methode und ein Zielobjekt, das dem ersten Parameter der Methode zugeordnet werden kann. Der Delegat gilt als über seinem ersten Argument geschlossen.

Weitere Informationen über die Delegatenbindung finden Sie unter Delegaten im allgemeinen Typsystem und CreateDelegate(Type, Object, MethodInfo, Boolean).

y22acf51.alert_note(de-de,VS.90).gifHinweis:

In .NET Framework, Version 1.0 und 1.1, kann ein Delegat eine Methode nur darstellen, wenn die Signatur der Methode genau mit der durch den Delegattyp angegebenen Signatur übereinstimmt. Daher werden nur die unter Punkt 1 und 3 in der vorhergehenden Liste beschriebenen Elemente unterstützt, und beim ersten Aufzählungspunkt ist eine genaue Typübereinstimmung erforderlich.

Wenn ein Delegat eine über seinem ersten Argument geschlossene Instanzmethode darstellt (der Normalfall), speichert der Delegat einen Verweis auf den Einstiegspunkt der Methode und einen Verweis auf ein Objekt, das als Ziel bezeichnet wird und von einem Typ ist, der dem durch die Methode definierten Typ zugeordnet werden kann. Wenn ein Delegat eine offene Instanzmethode darstellt, speichert er einen Verweis auf den Einstiegspunkt der Methode. Die Signatur des Delegaten muss in der formalen Parameterliste den ausgeblendeten this-Parameter enthalten. In diesem Fall verfügt der Delegat über keinen Verweis auf ein Zielobjekt, sodass das Zielobjekt beim Aufruf des Delegaten bereitgestellt werden muss.

Wenn ein Delegat eine statische Methode darstellt, wird im Delegaten ein Verweis auf den Einstiegspunkt der Methode gespeichert. Wenn ein Delegat eine über seinem ersten Element geschlossene statische Methode darstellt, speichert der Delegat einen Verweis auf den Einstiegspunkt der Methode und einen Verweis auf das Zielobjekt, das dem Typ des ersten Arguments der Methode zugeordnet werden kann. Beim Aufruf des Delegaten empfängt das erste Argument der statischen Methode das Zielobjekt.

Die Aufrufliste eines Delegaten ist eine geordnete Menge von Delegaten, bei der jedes Element der Liste genau eine der vom Delegaten dargestellten Methoden aufruft. Eine Aufrufliste kann Methoden mehrfach enthalten. Während eines Aufrufs werden die Methoden in der Reihenfolge der Aufrufliste aufgerufen. Ein Delegat versucht, jede Methode in seiner Aufrufliste aufzurufen. Duplikate werden einmal für jedes Vorkommen in der Aufrufliste aufgerufen. Delegaten sind unveränderlich. Die Aufrufliste eines Delegaten kann nach dem Erstellen nicht geändert werden.

Delegaten werden als Multicast- oder kombinierbare Delegaten bezeichnet, weil ein Delegat eine oder mehr Methoden aufrufen kann und in Kombinationsvorgängen verwendet werden kann.

Durch Kombinationsoperationen wie Combine und Remove werden vorhandene Delegaten nicht geändert. Eine Kombinationsoperation gibt stattdessen einen neuen Delegaten zurück, der die Ergebnisse der Operation, einen nicht geänderten Delegaten oder null enthält. Eine Kombinationsoperation gibt null zurück, wenn das Ergebnis der Operation ein Delegat ist, der nicht auf mindestens eine Methode verweist. Eine Kombinationsoperation gibt einen nicht geänderten Delegaten zurück, wenn die angeforderte Operation keine Auswirkungen hat.

Wenn die aufgerufene Methode eine Ausnahme auslöst, wird die Ausführung der Methode abgebrochen und die Ausnahme an den Aufrufer des Delegaten übergeben. Weitere Methoden in der Aufrufliste werden nicht aufgerufen. Wenn der Aufrufer die Ausnahme abfängt, ändert sich dieses Verhalten nicht.

Wenn die Signatur der vom Delegaten aufgerufenen Methoden einen Rückgabewert enthält, gibt der Delegat den Rückgabewert des letzten Elements der Aufrufliste zurück. Wenn die Signatur einen als Verweis übergebenen Parameter enthält, ist der Endwert des Parameters das Ergebnis der Ausführung aller Methoden in der Reihenfolge der Aufrufliste und der Aktualisierung des Parameterwerts.

Ein Funktionszeiger kommt einem Delegaten in C oder C++ am nächsten. Ein Delegat kann eine statische Methode oder eine Instanzmethode darstellen. Wenn der Delegat eine Instanzmethode darstellt, speichert dieser nicht nur einen Verweis auf den Einstiegspunkt der Methode, sondern außerdem einen Verweis auf die Klasseninstanz. Im Gegensatz zu Funktionszeigern sind Delegaten objektorientiert und typsicher.

Im folgenden Beispiel wird die Definition eines Delegaten mit dem Namen myMethodDelegate gezeigt. Instanzen dieses Delegaten werden für eine Instanzmethode und für eine statische Methode der geschachtelten mySampleClass-Klasse erstellt. Der Delegat für die Instanzmethode benötigt eine Instanz von mySampleClass. Die mySampleClass-Instanz wird in einer Variablen mit dem Namen mySC gespeichert.

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



import System.*;

public class SamplesDelegate
{
    /** @delegate 
     */
    // 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 static class MySampleClass
    {
        // Defines an instance method.
        public String MyStringMethod(int myInt)
        {
            if (myInt > 0)  {
                return "positive";
            }
            if (myInt < 0) {
                return "negative";
            }
            return "zero";
        } //myStringMethod

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

    public static void main(String[] args)
    {
        // Creates one delegate for each method. For the instance method,
        // an instance (mySC) must be supplied. For the static method,
        // only the class name is required.
        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}\".", 
            (Int32)(5), System.Convert.ToString(myD1.Invoke(5)), 
            System.Convert.ToString(myD2.Invoke(5)));
        Console.WriteLine("{0} is {1}; use the sign \"{2}\".",
            System.Convert.ToString(-3), System.Convert.ToString(myD1.Invoke(-3)),
            System.Convert.ToString(myD2.Invoke(-3)));
        Console.WriteLine("{0} is {1}; use the sign \"{2}\".", (Int32)(0),
            System.Convert.ToString(myD1.Invoke(0)), System.Convert.ToString(
            myD2.Invoke(0)));
    } //main
} //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 "".
*/



Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile für Smartphone, Windows Mobile für Pocket PC, Xbox 360

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 3.5, 2.0, 1.0

XNA Framework

Unterstützt in: 2.0, 1.0

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft