Dela via

Generiska delegater (C# programmeringsguide)

Ett ombud kan definiera sina egna typparametrar. Kod som refererar till det allmänna ombudet kan ange typargumentet för att skapa en sluten konstruktionstyp, precis som när du instansierar en allmän klass eller anropar en generisk metod, som du ser i följande exempel:

public delegate void Del<T>(T item);
public static void Notify(int i) { }

Del<int> m1 = new Del<int>(Notify);

C# version 2.0 har en ny funktion som kallas metodgruppkonvertering, som gäller både för konkreta och generiska ombudstyper, och gör att du kan skriva föregående rad med den här förenklade syntaxen:

Del<int> m2 = Notify;

Delegeringar som definieras i en generisk klass kan använda den generiska klasstypens parametrar på samma sätt som klassmetoder gör.

class Stack<T>
{
    public delegate void StackDelegate(T[] items);
}

Kod som refererar till delegeringen måste ange typargumentet för den innehållande klassen enligt följande:

private static void DoWork(float[] items) { }

public static void TestStack()
{
    Stack<float> s = new Stack<float>();
    Stack<float>.StackDelegate d = DoWork;
}

Generiska delegater är särskilt användbara för att definiera händelser baserat på det typiska designmönstret eftersom avsändarargumentet kan vara starkt typade och inte längre behöver konverteras till och från Object.

delegate void StackEventHandler<T, U>(T sender, U eventArgs);

class Stack<T>
{
    public class StackEventArgs : System.EventArgs { }
    public event StackEventHandler<Stack<T>, StackEventArgs>? StackEvent;

    protected virtual void OnStackChanged(StackEventArgs a)
    {
        if (StackEvent is not null)
            StackEvent(this, a);
    }
}

class SampleClass
{
    public void HandleStackChange<T>(Stack<T> stack, Stack<T>.StackEventArgs args) { }
}

public static void Test()
{
    Stack<double> s = new Stack<double>();
    SampleClass o = new SampleClass();
    s.StackEvent += o.HandleStackChange;
}

Se även