Search
Close this search box.
Illustration von C# Delegates in Aktion

C# Delegates - Eine Einführung in die Funktionszeiger

Delegates sind ein wichtiges Konzept in der Programmierung mit C#. Sie erlauben es, Methoden als Parameter zu übergeben oder als Rückgabewert zu nutzen. Dies ermöglicht eine höhere Flexibilität und Wiederverwendbarkeit von Code. In diesem Artikel werden wir uns genauer mit dem Konzept der Delegates beschäftigen. Wir werden besprechen, was Delegates sind, wie sie funktionieren und wie sie in der Programmierung verwendet werden.

Was sind C# Delegates? Ein Delegate ist ein Objekt, das auf eine Methode verweist. Es ermöglicht es, Methoden als Parameter zu übergeben oder als Rückgabewert zu nutzen. Mit anderen Worten: Ein Delegate ist ein Funktionszeiger, der es erlaubt, Methoden wie eine Variable zu behandeln. Ein Delegate kann Methoden referenzieren, die denselben Signaturtyp haben wie der Delegate selbst. Eine Signatur besteht aus dem Methodennamen, den Parametern und dem Rückgabetyp.

Wie funktionieren C# Delegates? In C# werden Delegates als Klassen implementiert. Ein Delegate ist eine Klasse, die eine Methode referenziert. Diese Methode muss denselben Signaturtyp haben wie der Delegate selbst. Wenn ein Delegate auf eine Methode verweist, kann er aufgerufen werden, als ob er die Methode selbst wäre. Delegates können auch kombiniert werden, um eine Liste von Methoden zu erstellen, die in einer bestimmten Reihenfolge ausgeführt werden.

Wie werden C# Delegates in der Programmierung verwendet? Delegates werden in der Programmierung verwendet, um Methoden als Parameter zu übergeben oder als Rückgabewert zu nutzen. Ein häufiges Beispiel ist die Verwendung von Delegates in Ereignissen. Wenn ein Ereignis ausgelöst wird, ruft das Ereignis die Methode auf, die vom Delegate referenziert wird. Delegates können auch dazu verwendet werden, Callback-Funktionen zu erstellen oder um Asynchronität zu implementieren.

Beispiele für C# Delegates könnten folgende sein:

  • Ein einfaches Beispiel für einen Delegate könnte wie folgt aussehen:
				
					public delegate void MeinDelegate(int x);

public class Beispielklasse
{
    public static void Methode1(int x)
    {
        Console.WriteLine("Methode 1: " + x);
    }

    public static void Methode2(int x)
    {
        Console.WriteLine("Methode 2: " + x);
    }

    public static void Main()
    {
        MeinDelegate del = new MeinDelegate(Methode1);
        del(42);
        del = Methode2;
        del(123);
    }
}

				
			

Dieses Beispiel definiert einen Delegate namens MeinDelegate, der eine Methode mit einem Parameter vom Typ int akzeptiert und keinen Rückgabewert hat. Dann werden zwei Methoden namens Methode1 und Methode2 definiert, die denselben Signaturtyp wie MeinDelegate haben. In der Main Methode wird der Delegate del zuerst auf Methode1 gesetzt und dann auf Methode2. Wenn der Delegate schließlich aufgerufen wird, wird die entsprechende Methode ausgeführt und der Parameter wird an die Methode übergeben.

  • Ein weiteres Beispiel könnte eine Klasse sein, die eine Methode definiert, die einen Delegate als Parameter akzeptiert und diesen verwendet, um eine andere Methode aufzurufen:
				
					public delegate int MathematischeOperation(int x, int y);

public class Mathematik
{
    public int Berechne(MathematischeOperation operation, int x, int y)
    {
        return operation(x, y);
    }
}

public class Beispielklasse
{
    public static int Addiere(int x, int y)
    {
        return x + y;
    }

    public static int Subtrahiere(int x, int y)
    {
        return x - y;
    }

    public static void Main()
    {
        Mathematik mathe = new Mathematik();

        int ergebnis = mathe.Berechne(new MathematischeOperation(Addiere), 3, 5);
        Console.WriteLine("3 + 5 = " + ergebnis);

        ergebnis = mathe.Berechne(new MathematischeOperation(Subtrahiere), 7, 2);
        Console.WriteLine("7 - 2 = " + ergebnis);
    }
}

				
			

In diesem Beispiel definiert die Klasse Mathematik eine Methode namens Berechne, die einen Delegate als Parameter akzeptiert und diesen verwendet, um eine andere Methode aufzurufen. Dann werden zwei Methoden namens Addiere und Subtrahiere definiert, die denselben Signaturtyp wie der Delegate haben. In der Main Methode wird eine Instanz der Klasse Mathematik erstellt und der Delegate wird zweimal aufgerufen, einmal mit Addiere und einmal mit Subtrahiere. Das Ergebnis der jeweiligen Berechnung wird ausgegeben.

Hier sind einige Code-Beispiele zum Thema C# Delegates und Callback-Funktionen:

Beispiel 1: Delegate als Parameter einer Methode

				
					public delegate void MeinDelegate(int x);

public class MeineKlasse
{
    public static void MethodeMitDelegate(MeinDelegate meinDelegate)
    {
        // Führe die übergebene Methode aus
        meinDelegate(42);
    }
}

public class Programm
{
    static void Main()
    {
        MeinDelegate meinDelegate = MeineMethode;
        MeineKlasse.MethodeMitDelegate(meinDelegate);
    }

    static void MeineMethode(int x)
    {
        Console.WriteLine("Die Zahl ist: " + x);
    }
}

				
			

In diesem Beispiel definieren wir einen Delegate-Typ namens MeinDelegate, der eine Methode mit einem int-Parameter und keinem Rückgabewert darstellt. Dann haben wir eine Klasse namens MeineKlasse, die eine Methode namens MethodeMitDelegate definiert, die ein MeinDelegate-Objekt als Parameter akzeptiert und die übergebene Methode mit dem Wert 42 ausführt. Schließlich haben wir die Main-Methode, die eine Methode namens MeineMethode definiert, die der MeinDelegate-Typ erfüllt, indem sie einen int-Parameter akzeptiert und keinen Rückgabewert hat. In der Main-Methode erstellen wir ein MeinDelegate-Objekt und übergeben es an die MethodeMitDelegate-Methode von MeineKlasse, die dann die MeineMethode-Methode mit dem Wert 42 aufruft.

Beispiel 2: Callback-Funktionen mit Delegates

				
					public delegate void MeinDelegate();

public class MeineKlasse
{
    public static void MethodeMitCallback(MeinDelegate callback)
    {
        // Führe die übergebene Methode aus
        callback();
    }
}

public class Programm
{
    static void Main()
    {
        MeinDelegate meinDelegate = MeineMethode;
        MeineKlasse.MethodeMitCallback(meinDelegate);
    }

    static void MeineMethode()
    {
        Console.WriteLine("Die Callback-Methode wurde aufgerufen!");
    }
}

				
			

In diesem Beispiel definieren wir einen Delegate-Typ namens MeinDelegate, der eine Methode ohne Parameter und ohne Rückgabewert darstellt. Dann haben wir eine Klasse namens MeineKlasse, die eine Methode namens MethodeMitCallback definiert, die ein MeinDelegate-Objekt als Parameter akzeptiert und die übergebene Methode ausführt. Schließlich haben wir die Main-Methode, die eine Methode namens MeineMethode definiert, die der MeinDelegate-Typ erfüllt, indem sie keine Parameter akzeptiert und keinen Rückgabewert hat. In der Main-Methode erstellen wir ein MeinDelegate-Objekt und übergeben es an die MethodeMitCallback-Methode von MeineKlasse, die dann die MeineMethode-Methode aufruft.

  • Verwendung von Delegates in Event-Handling

Delegates werden häufig in der Event-Verarbeitung in C# verwendet. Ein Delegate wird verwendet, um eine Methode zu verknüpfen, die ausgeführt wird, wenn das Ereignis ausgelöst wird. Hier ist ein Beispiel:

				
					public delegate void EventHandler(object sender, EventArgs e);

public class Button
{
    public event EventHandler Click;

    public void OnClick()
    {
        Click?.Invoke(this, EventArgs.Empty);
    }
}

public class Program
{
    static void Main(string[] args)
    {
        Button button = new Button();
        button.Click += new EventHandler(OnButtonClick);

        // Klickereignis auslösen
        button.OnClick();
    }

    static void OnButtonClick(object sender, EventArgs e)
    {
        Console.WriteLine("Button wurde geklickt!");
    }
}

				
			

In diesem Beispiel wird ein Delegate mit dem Namen „EventHandler“ definiert, der eine Methode mit dem Signatur „void MethodName(object sender, EventArgs e)“ repräsentiert. Die Klasse „Button“ hat ein Ereignis „Click“, das diesem Delegate-Typ entspricht. Die Methode „OnClick“ löst das Ereignis aus, indem sie das Delegate aufruft. Der EventHandler wird schließlich mit einer Methode namens „OnButtonClick“ verknüpft, die ausgeführt wird, wenn das Click-Ereignis ausgelöst wird.

  • Verwendung von Delegates in Linq-Abfragen

Delegates können auch in Linq-Abfragen verwendet werden, um die Abfrageergebnisse an eine spezifische Methode zu übergeben. Hier ist ein Beispiel:

				
					using System;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        int[] numbers = { 1, 2, 3, 4, 5 };

        // Verwendung eines Delegaten, um jedes Element in der Liste auszugeben
        Action<int> printNumber = x => Console.WriteLine(x);

        // Filtern der Zahlen, die größer als 3 sind, und Ausgabe mit Delegat
        var result = numbers.Where(x => x > 3);
        result.ToList().ForEach(printNumber);
    }
}

				
			

In diesem Beispiel wird ein Delegate vom Typ „Action<int>“ definiert, der eine Methode mit einem Parameter vom Typ „int“ repräsentiert. Der Delegate wird verwendet, um jedes Element in der Liste der Zahlen auszugeben, die größer als 3 sind.

  • Verwendung von Delegates in der Multithreading-Programmierung

Delegates können auch in der Multithreading-Programmierung verwendet werden, um die Ausführung von Methoden auf anderen Threads zu planen. Hier ist ein Beispiel:

				
					using System;
using System.Threading;

class Program
{
    static void Main(string[] args)
    {
        // Verwendung eines Delegaten, um eine Methode auf einem anderen Thread auszuführen
        Action printHello = () => Console.WriteLine("Hello from another thread!");

        // Starten eines neuen Threads und Ausführen der Methode über den Delegaten
        Thread thread = new Thread(new ThreadStart(printHello));
        thread.Start();

        Console.WriteLine("Hello from the main thread!");
    }
}

				
			

In diesem Beispiel wird ein Delegate vom Typ „Action“ verwendet, um eine Methode auf einem anderen Thread auszuführen.

Fazit: C# Delegates sind ein leistungsfähiges Konzept, das es ermöglicht, Methoden als Parameter zu übergeben oder als Rückgabewert zu nutzen. Sie erhöhen die Flexibilität und Wiederverwendbarkeit von Code und können in vielen Situation

Aufgabe:

Erstelle eine Methode, die zwei Parameter vom Typ int annimmt und sie addiert. Übergebe dann diese Methode als Delegate-Parameter an eine andere Methode, die den Delegate ausführt und das Ergebnis auf der Konsole ausgibt.

Um die Lösung anzuzeigen, fahre mit der Maus in die Mitte des darunterliegenden Fensters.

				
					public delegate int MeinDelegate(int a, int b);

public class Rechner
{
public static void AddierenUndAusgeben(MeinDelegate del, int a, int b)
{
    int ergebnis = del(a, b);
    Console.WriteLine("Das Ergebnis ist: " + ergebnis);
}
}

public class Programm
{
static void Main()
{
    MeinDelegate addieren = (x, y) => x + y;
    Rechner.AddierenUndAusgeben(addieren, 5, 7);
}
}
				
			

In diesem Beispiel wird ein Delegate vom Typ MeinDelegate erstellt, der zwei Parameter vom Typ int akzeptiert und einen int zurückgibt. Dann wird eine Methode namens AddierenUndAusgeben definiert, die diesen Delegate als Parameter akzeptiert sowie zwei int-Parameter. Die Methode führt den Delegate aus, indem sie ihm die beiden int-Parameter übergibt und das Ergebnis auf der Konsole ausgibt.

In der Main-Methode wird dann ein Delegate vom Typ MeinDelegate erstellt, der eine Lambda-Ausdrucksfunktion verwendet, um die Addition von zwei Zahlen durchzuführen. Anschließend wird die Methode AddierenUndAusgeben aufgerufen und das Delegate sowie die beiden Zahlen als Parameter übergeben. Das Ergebnis wird auf der Konsole ausgegeben.

Zurück zum vorherigen Teil des C# Kurses
Klicken Sie auf den Pfeil, um zum vorherigen Teil des Kurses zurückzukehren
Pfeil-Button zum nächsten Teil des Kurses
Klicken Sie auf den Pfeil, um zum nächsten Teil des Kurses zu gelangen