Bagaimanakah Saya Boleh Mencipta Kaedah FromEvent Tujuan Am untuk TaskCompletionSource dalam C#?

Kaedah Tujuan Umum DaripadaEvent

Masalah:

Mewujudkan TaskCompletionSource yang selesai apabila acara fires memerlukan kaedah FromEvent tersuai untuk setiap acara dalam setiap kelas. Ini menjadi menyusahkan dan berulang.

Penyelesaian yang Diingini:

Kaedah FromEvent tujuan umum yang boleh mengendalikan sebarang acara pada sebarang kejadian.

Kesukaran:

• Acara hanya boleh dilampirkan sebelah kiri ungkapan.
• Jenis perwakilan dan parameter untuk acara perlu ditentukan secara dinamik.
• Mengeluarkan kod IL untuk mengakses kejadian luaran dan menetapkan keputusan TaskCompletionSource adalah mencabar.

Penyelesaian:

Yang berikut kod menyediakan kaedah FromEvent tujuan umum yang mengatasi kesukaran ini:

internal class TaskCompletionSourceHolder
{
    private readonly TaskCompletionSource<object> m_tcs;

    internal object Target { get; set; }
    internal EventInfo EventInfo { get; set; }
    internal Delegate Delegate { get; set; }

    internal TaskCompletionSourceHolder(TaskCompletionSource<object> tsc)
    {
        m_tcs = tsc;
    }

    private void SetResult(params object[] args)
    {
        // this method will be called from emitted IL
        // so we can set result here, unsubscribe from the event
        // or do whatever we want.

        // object[] args will contain arguments
        // passed to the event handler
        m_tcs.SetResult(args);
        EventInfo.RemoveEventHandler(Target, Delegate);
    }
}

public static class ExtensionMethods
{
    private static Dictionary<type dynamicmethod> s_emittedHandlers =
        new Dictionary<type dynamicmethod>();

    private static void GetDelegateParameterAndReturnTypes(Type delegateType,
        out List<type> parameterTypes, out Type returnType)
    {
        if (delegateType.BaseType != typeof(MulticastDelegate))
            throw new ArgumentException("delegateType is not a delegate");

        MethodInfo invoke = delegateType.GetMethod("Invoke");
        if (invoke == null)
            throw new ArgumentException("delegateType is not a delegate.");

        ParameterInfo[] parameters = invoke.GetParameters();
        parameterTypes = new List<type>(parameters.Length);
        for (int i = 0; i  FromEvent<t>(this T obj, string eventName)
    {
        var tcs = new TaskCompletionSource<object>();
        var tcsh = new TaskCompletionSourceHolder(tcs);

        EventInfo eventInfo = obj.GetType().GetEvent(eventName);
        Type eventDelegateType = eventInfo.EventHandlerType;

        DynamicMethod handler;
        if (!s_emittedHandlers.TryGetValue(eventDelegateType, out handler))
        {
            Type returnType;
            List<type> parameterTypes;
            GetDelegateParameterAndReturnTypes(eventDelegateType,
                out parameterTypes, out returnType);

            if (returnType != typeof(void))
                throw new NotSupportedException();

            Type tcshType = tcsh.GetType();
            MethodInfo setResultMethodInfo = tcshType.GetMethod(
                "SetResult", BindingFlags.NonPublic | BindingFlags.Instance);

            // I'm going to create an instance-like method
            // so, first argument must an instance itself
            // i.e. TaskCompletionSourceHolder *this*
            parameterTypes.Insert(0, tcshType);
            Type[] parameterTypesAr = parameterTypes.ToArray();

            handler = new DynamicMethod("unnamed",
                returnType, parameterTypesAr, tcshType);

            ILGenerator ilgen = handler.GetILGenerator();

            // declare local variable of type object[]
            LocalBuilder arr = ilgen.DeclareLocal(typeof(object[]));
            // push array's size onto the stack 
            ilgen.Emit(OpCodes.Ldc_I4, parameterTypesAr.Length - 1);
            // create an object array of the given size
            ilgen.Emit(OpCodes.Newarr, typeof(object));
            // and store it in the local variable
            ilgen.Emit(OpCodes.Stloc, arr);

            // iterate thru all arguments except the zero one (i.e. *this*)
            // and store them to the array
            for (int i = 1; i <p><strong>Kelebihan Penyelesaian Ini:</strong></p>
<ul>
<li>Menyokong sebarang jenis perwakilan, menghapuskan perlu menentukan jenis tertentu.</li>
<li>Mengeluarkan kod IL pada masa jalan untuk mengendalikan perwakilan invocation dan tetapan hasil TaskCompletionSource, memberikan fleksibiliti dan prestasi.</li>
</ul></type></object></t></type></type></type></type></object></object>

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Mencipta Kaedah FromEvent Tujuan Am untuk TaskCompletionSource dalam C#?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!