Delegate-Klasse
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)
Syntax
'Declaration
<SerializableAttribute> _
<ClassInterfaceAttribute(ClassInterfaceType.AutoDual)> _
<ComVisibleAttribute(True)> _
Public MustInherit Class Delegate
Implements ICloneable, ISerializable
'Usage
Dim instance As Delegate
[SerializableAttribute]
[ClassInterfaceAttribute(ClassInterfaceType.AutoDual)]
[ComVisibleAttribute(true)]
public abstract class Delegate : ICloneable, ISerializable
[SerializableAttribute]
[ClassInterfaceAttribute(ClassInterfaceType::AutoDual)]
[ComVisibleAttribute(true)]
public ref class Delegate abstract : ICloneable, ISerializable
/** @attribute SerializableAttribute() */
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.AutoDual) */
/** @attribute ComVisibleAttribute(true) */
public abstract class Delegate implements ICloneable, ISerializable
SerializableAttribute
ClassInterfaceAttribute(ClassInterfaceType.AutoDual)
ComVisibleAttribute(true)
public abstract class Delegate implements ICloneable, ISerializable
Hinweise
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.
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).
Hinweis
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 (Nothing in Visual Basic) enthält. Eine Kombinationsoperation gibt NULL (Nothing in Visual Basic) 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.
Compiler stellen zwei zusätzliche Methoden für den Delegaten bereit: BeginInvoke und EndInvoke. Weitere Informationen über diese Methoden finden Sie in der Asynchrones Aufrufen von synchronen Methoden.
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.
Beispiel
Im folgenden Beispiel wird die Definition eines Standarddelegaten gezeigt.
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.
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 "".
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.
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 "".
*/
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.
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 "".
*/
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.
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 "".
*/
Vererbungshierarchie
System.Object
System.Delegate
System.MulticastDelegate
Threadsicherheit
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0
Siehe auch
Referenz
Delegate-Member
System-Namespace
MulticastDelegate