Delegate

Eintrag zuletzt aktualisiert am: 11.10.2011

 Fachbücher zum Thema Delegate

deutsch: Delegaten (Funktionszeiger)

Delegaten (engl. Delegates) sind typsichere Zeiger auf Funktionen. Durch Delegaten kann der aufzurufende Code variabel gehalten werden. Sie kommen insbesondere zum Einsatz für die Ereignisbehandlung und für asynchrone Methodenaufrufe. Ein Delegat kann auf mehrere Funktionen zeigen (Multicast Delegate). Beim Aufruf des Delegaten werden alle an den Delegaten gebundenen Funktionen aufgerufen.

Delegaten kommen in .NET insbesondere zum Einsatz für die Ereignisbehandlung und asynchrone Methodenaufrufe.
Jeder deklarierte Delegat erhält automatisch die Methoden Invoke(), BeginInvoke() und EndInvoke().

Delegates in C#
Methodendeklaration :
public string HoleWert(long Parameter)

Deklaration eines Funktionszeigertyps:

public delegate string HoleWertDelegate(long Parameter);

Erstellung eines Zeigers auf die Funktion :
HoleWertDelegate del = new HoleWertDelegate(this.HoleWert);

Delegates in Visual Basic .NET
Visual Basic .NET unterstützt .NET-Funktionszeiger (alias Delegates) durch das Schlüsselwort Delegate.

Methodendeklaration:
Public Function HoleWert(ByVal Parameter As Long) As String

Definition eines Funktionszeigertypen:
Public Delegate Function HoleWertDelegate(ByVal Parameter As Long) As String

Erstellung eines Zeigers auf die Funktion:
Dim del As New HoleWertDelegate(AddressOf Me.HoleWert)

Beispiel 1
[Demo]
public class DelegateBeispiel1
{
// Eigener Delegate
public delegate string Begruessung(string name, string vorname);

static void Run()
{
string e;

// Verwendung eigener Delegate
Begruessung g = Hallo;

e = g("Schwichtenberg", "Holger");
Console.WriteLine€;
g = GutenTag;
e = g("Schwichtenberg", "Holger");
Console.WriteLine€;

// Verwendung vordefinierter Delegate
Action<string> start = Start;
start("test");

Console.ReadLine();
}

// Implementierng #1 Delegate Begruessung<T,T>
static public string Hallo(string name, string vorname)
{
return "Hallo " + vorname + " " + name + "!";
}

// Implementierng #2 Delegate Begruessung<T,T>
static public string GutenTag(string name, string vorname)
{
return "Guten Tag " + vorname + " " + name + "!";
}

// Implementierng Delegate Action<t>
static public void Start(string x)
{
Console.WriteLine("Starte: " + x);
}

}


Beispiel 2

Ein gutes Anwendungsbeispiel für Delegates ist der asynchrone Methodenaufruf. Für den asynchronen Methodenaufruf ist neben dem Funktionszeiger auch ein Rückrufroutine (Callback-Routine) und ein AsyncCallback-Objekt notwendig, das auf die Callback-Routine verweist und beim Aufruf von BeinInvoke() übergeben werden muss. In der Callback-Routine kann über EndInvoke() das Ergebnis abgerufen werden.

Public class DelegateBeispiel
{
// === Funktion
public string HoleWert(long Parameter)
{
Console.WriteLine("Methodenaufruf…");
return "Wert " + Parameter;
}
// === Definition eines Funktionszeigertyps
public delegate string HoleWertDelegate(long Parameter);
// === Hauptprogramm
public void Test()
{
// --- Synchroner Aufruf
Console.WriteLine("Asynchroner Aufruf…");
Console.WriteLine("Ergebnis: " + HoleWert(2));
// --- Asynchroner Aufruf
Console.WriteLine("Asynchroner Aufruf…");
HoleWertDelegate del = new HoleWertDelegate(this.HoleWert);
AsyncCallback Callback = new AsyncCallback(Fertig);
del.BeginInvoke(123, Callback, del);
// --- Warten
for (int a = 1; a <= 10; a++)
{
Console.Write("*");
System.Threading.Thread.Sleep(100);
}
Console.ReadLine();
}
// === Callback-Handler
public void Fertig(IAsyncResult CallbackResult)
{
Console.WriteLine("Aufruf fertig…");
HoleWertDelegate del = (HoleWertDelegate)CallbackResult.AsyncState;
string Ergebnis = del.EndInvoke(CallbackResult);
Console.WriteLine("Ergebnis: " + Ergebnis);
}