Wie kann ich mit einer Allzweck-FromEvent-Methode auf jedes Ereignis eines beliebigen Typs warten?

Allzweck-FromEvent-Methode

Die ursprüngliche FromEvent-Methode erfordert die Erstellung separater Methoden für jedes Ereignis und jede Klasse, auf die Sie warten möchten. Um Boilerplate-Code zu eliminieren, suchten Entwickler nach einer allgemeineren Lösung.

Ein Ansatz besteht darin, Reflektion zu verwenden, um das Ereignis und seinen Delegatentyp abzurufen. Der Zugriff auf die Parameter des Delegaten und das Ändern von TaskCompletionSource stellten jedoch Herausforderungen dar.

Eine benutzerdefinierte Lösung

Hier ist eine benutzerdefinierte Lösung, die IL-Emissions- und Ereignishandler verwendet:

public static class ExtensionMethods
{
    public static Task<object[]> FromEvent<T>(this T obj, string eventName)
    {
        // Create a TaskCompletionSourceHolder to manage the TaskCompletionSource and event handler
        var tcsh = new TaskCompletionSourceHolder();

        // Get the event and its delegate type
        EventInfo eventInfo = obj.GetType().GetEvent(eventName);
        Type eventDelegateType = eventInfo.EventHandlerType;

        // Create a dynamic method to handle the event
        DynamicMethod handler = CreateEventHandler(eventDelegateType);

        // Add the event handler to the target object
        eventInfo.AddEventHandler(obj, handler.CreateDelegate(eventDelegateType, tcsh));

        // Return the Task from the TaskCompletionSourceHolder
        return tcsh.Task;
    }

    private static DynamicMethod CreateEventHandler(Type eventDelegateType)
    {
        // Get the parameter types of the event delegate
        var parameterTypes = GetDelegateParameterTypes(eventDelegateType);

        // Insert the TaskCompletionSourceHolder as the first parameter
        parameterTypes.Insert(0, typeof(TaskCompletionSourceHolder));

        // Create a new dynamic method and IL generator
        DynamicMethod handler = new DynamicMethod("EventHandler", typeof(void), parameterTypes, true);
        ILGenerator ilgen = handler.GetILGenerator();

        // Load the TaskCompletionSourceHolder and create an array to store the arguments
        ilgen.Emit(OpCodes.Ldarg_0);
        ilgen.Emit(OpCodes.Ldc_I4, parameterTypes.Count - 1);
        ilgen.Emit(OpCodes.Newarr, typeof(object));

        // Store each argument in the array
        for (int i = 1; i < parameterTypes.Count; i++)
        {
            ilgen.Emit(OpCodes.Ldloc_0);
            ilgen.Emit(OpCodes.Ldc_I4, i - 1);
            ilgen.Emit(OpCodes.Ldarg, i);
            ilgen.Emit(OpCodes.Stelem_Ref);
        }

        // Call the SetResult method on the TaskCompletionSourceHolder
        ilgen.Emit(OpCodes.Call, typeof(TaskCompletionSourceHolder).GetMethod("SetResult"));

        // Return from the method
        ilgen.Emit(OpCodes.Ret);

        return handler;
    }

    private static List<Type> GetDelegateParameterTypes(Type delegateType)
    {
        var parameters = delegateType.GetMethod("Invoke").GetParameters();
        var parameterTypes = parameters.Select(p => p.ParameterType).ToList();
        return parameterTypes;
    }
}

Mit dieser Methode können Sie jetzt auf jedes Ereignis warten Typ:

await new MyClass().FromEvent("MyEvent");

Vorteile dieser Lösung

• Unterstützt jeden Ereignistyp mit einer beliebigen Anzahl oder Typen von Parametern.
• Nicht erfordert die Umwandlung der Aufgabe in einen bestimmten Rückgabetyp.
• Beseitigt die Notwendigkeit, mehrere FromEvent-Methoden für verschiedene Typen zu erstellen und Veranstaltungen.

Das obige ist der detaillierte Inhalt vonWie kann ich mit einer Allzweck-FromEvent-Methode auf jedes Ereignis eines beliebigen Typs warten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!