Sie sind hier: Startseite | Wissen

Was ist 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);
  }

Beratung & Support:

Schulungen zu diesem Thema:

 Anfrage für eine individuelle Schulung zum Thema Delegate  Gesamter Schulungsthemenkatalog