Fatal编程技术网
  • csharp/
  • 我如何转变动作<；T>；通过在C#中生成IL来创建编译表达式或动态方法？

我如何转变动作<；T>；通过在C#中生成IL来创建编译表达式或动态方法？

c# .net

我如何转变动作<；T>；通过在C#中生成IL来创建编译表达式或动态方法？,c#,.net,expression-trees,dynamicmethod,C#,.net,Expression Trees,Dynamicmethod,我必须维护一个库，它允许用户针对它注册一个通用处理程序（Action），然后一旦它接收到一个事件，它就会遍历每个注册的处理程序并将事件传递给它们。为了简短起见，让我们跳过这样做的原因 由于这种设计，我们必须在传递每个事件时调用DynamicInvoke；事实证明，这相当缓慢，因此需要将委托转换为编译表达式或使用IL生成的动态方法。我已经看到了为PropertyGetters（）实现此功能的各种示例，但我无法将其用于操作，其中T既可以是值类型，也可以是引用类型 下面是一个当前（缓慢）的工作示例（为

我必须维护一个库，它允许用户针对它注册一个通用处理程序（
Action
），然后一旦它接收到一个事件，它就会遍历每个注册的处理程序并将事件传递给它们。为了简短起见，让我们跳过这样做的原因

由于这种设计，我们必须在传递每个事件时调用
DynamicInvoke
；事实证明，这相当缓慢，因此需要将委托转换为编译表达式或使用IL生成的动态方法。我已经看到了为PropertyGetters（）实现此功能的各种示例，但我无法将其用于
操作
，其中
T
既可以是值类型，也可以是引用类型

下面是一个当前（缓慢）的工作示例（为简洁起见，进行了简化）：

void Main（）
{
var producer=new FancyEventProduder（）；
var fancy=新FancyHandler（制作人）；
fancy.Register（x=>Console.WriteLine（x））；
producer.Publish（new Child（））；
}
公共密封级幻想操纵器
{
私有只读列表\u处理程序；
公众幻想操纵者（幻想开发者）
{
_handlers=新列表（）；
produer.OnMessge+=OnMessage；
}
公共无效寄存器（操作处理程序）=>\u handlers.Add（处理程序）；
private void OnMessage（对象发送方、对象负载）
{
类型payloadType=payload.GetType（）；
foreach（处理程序中的委托处理程序）
{
//这可以在注册时缓存，但具有可忽略的影响
类型delegParamType=handler.Method.GetParameters（）[0].ParameterType；
if（delegParamType.IsAssignableFrom（payloadType））
{
handler.DynamicInvoke（有效载荷）；
}           
}
}
}
公共密封类FancyEventProduder
{
公共事件事件处理程序onMessage；
public void Publish（对象负载）=>OnMessge？.Invoke（这个，负载）；
}
公共类基类{}
公共密封类子级：基{}
不确定这是否是个好主意：

public sealed class FancyHandler
{
    private readonly List<Tuple<Delegate, Type, Action<object>>> _handlers = new List<Tuple<Delegate, Type, Action<object>>>();

    public FancyHandler(FancyEventProduder produer)
    {
        produer.OnMessge += OnMessage;
    }

    public void Register<T>(Action<T> handler)
    {
        _handlers.Add(Tuple.Create((Delegate)handler, typeof(T), BuildExpression(handler)));
    }

    private static Action<object> BuildExpression<T>(Action<T> handler)
    {
        var par = Expression.Parameter(typeof(object));
        var casted = Expression.Convert(par, typeof(T));
        var call = Expression.Call(Expression.Constant(handler.Target), handler.Method, casted);
        var exp = Expression.Lambda<Action<object>>(call, par);
        return exp.Compile();
    }

    private void OnMessage(object sender, object payload)
    {
        Type payloadType = payload.GetType();

        foreach (var handlerDelegate in _handlers)
        {
            // this could be cached at the time of registration but has negligable impact
            Type delegParamType = handlerDelegate.Item2;
                
            if (delegParamType.IsAssignableFrom(payloadType))
            {
                handlerDelegate.Item3(payload);
            }
        }
    }
}
完整表达式树（类型检查在表达式树中移动，在表达式树中执行
as
，而不是
IsAssignableFrom
）

第三个版本基于@BorisB的思想，该版本禁止使用
表达式
，并直接使用委托。它应该有一个较短的预热时间（无需编译
表达式
树）。仍然存在一个小的反射问题，但幸运的是，这个问题只在添加新处理程序时出现（有一条注释对此进行了解释）


公共密封类FancyHandler
{
私有只读列表_handlers=new List（）；
公众幻想操纵者（幻想开发者）
{
produer.OnMessge+=OnMessage；
}
公共无效寄存器（操作处理程序）
{
if（类型（T）.IsValueType）
{
_Add（BuildExpressionValueType（handler））；
}
其他的
{
//这里必须使用反射，因为as运算符需要T is类
//通过使用反射绕过此检查
_Add（（Action）u buildExpressionReferenceTypeT.MakeGenericMethod（typeof（T））.Invoke（null，new[]{handler}））；
}
}
私有静态操作BuildExpressionValueType（操作处理程序）
{
//我们删除了值类型的可空部分
类型类型=可空。GetUnderlineType（类型（T））？？类型（T）；
if（type==typeof（T））
{
//不可为空
返回（对象par）=>
{
如果（par为T）
{
处理人（（T）par）；
}
};
}
//可空类型
返回（对象par）=>
{
如果（PAR=＝No.P.Par为T）
{
处理人（（T）par）；
}
};
}
私有静态只读方法info _buildExpressionReferenceTypeT=typeof（FancyHandler）.GetMethod（nameof（BuildExpressionReferenceType），bindingsflags.static | bindingsflags.NonPublic）；
私有静态操作BuildExpressionReferenceType（操作处理程序），其中T:class
{
if（typeof（T）=typeof（object））
{
返回（操作）（委托）处理程序；
}
返回（对象par）=>
{
如果（par==null）
{
处理人（（T）par）；
}
其他的
{
T局部= PAR为T；
如果（本地！=null）
{
经办人（本地）；
}
}
};
}
private void OnMessage（对象发送方、对象负载）
{
foreach（处理程序中的var handlerregate）
{
handlerDelegate（有效载荷）；
}
}
}

如果（delegParamType.IsAssignableFrom（payload.GetType（）））handler.DynamicInvoke（payload），您无法真正从
中逃脱，所以我不认为你能做真正花哨的表演，所以？我仍然可以在注册时编译表达式，并选择不在if语句中调用它，否？要生成什么表达式？目前还不清楚。表达式就像是在运行时编写的一段代码，但这段动态代码仍然遵循类似于C#的规则（技术上类似于IL语言，但C#是IL的良好代理）。在这个表达式中仍然有严格的参数类型检查，比如C#。如果你看一看Matt的文章或Jon Skeet的博客文章，它解释了我在这里试图实现的目标。总之，目标是使DynamicVoke更快。好的。。。我们可以试试。。。我认为这是一个坏主意，它不会优化任何东西。。。但是我们可以试试。太好了！我处理500万个事件的基准从3秒下降到50毫秒@玛雅新版本，完整

public sealed class FancyHandler
{
    private readonly List<Tuple<Delegate, Type, Action<object>>> _handlers = new List<Tuple<Delegate, Type, Action<object>>>();

    public FancyHandler(FancyEventProduder produer)
    {
        produer.OnMessge += OnMessage;
    }

    public void Register<T>(Action<T> handler)
    {
        _handlers.Add(Tuple.Create((Delegate)handler, typeof(T), BuildExpression(handler)));
    }

    private static Action<object> BuildExpression<T>(Action<T> handler)
    {
        var par = Expression.Parameter(typeof(object));
        var casted = Expression.Convert(par, typeof(T));
        var call = Expression.Call(Expression.Constant(handler.Target), handler.Method, casted);
        var exp = Expression.Lambda<Action<object>>(call, par);
        return exp.Compile();
    }

    private void OnMessage(object sender, object payload)
    {
        Type payloadType = payload.GetType();

        foreach (var handlerDelegate in _handlers)
        {
            // this could be cached at the time of registration but has negligable impact
            Type delegParamType = handlerDelegate.Item2;
                
            if (delegParamType.IsAssignableFrom(payloadType))
            {
                handlerDelegate.Item3(payload);
            }
        }
    }
}



fancy.Register<Base>(x => Console.WriteLine($"Base: {x}"));
fancy.Register<Child>(x => Console.WriteLine($"Child: {x}"));
fancy.Register<object>(x => Console.WriteLine($"object: {x}"));
fancy.Register<long>(x => Console.WriteLine($"long: {x}"));
fancy.Register<long?>(x => Console.WriteLine($"long?: {x}"));
fancy.Register<int>(x => Console.WriteLine($"int: {x}"));
fancy.Register<int?>(x => Console.WriteLine($"int?: {x}"));

producer.Publish(new Base());
producer.Publish(new Child());
producer.Publish(5);



public sealed class FancyHandler
{
    private readonly List<Action<object>> _handlers = new List<Action<object>>();

    public FancyHandler(FancyEventProduder produer)
    {
        produer.OnMessge += OnMessage;
    }

    public void Register<T>(Action<T> handler)
    {
        _handlers.Add(BuildExpression(handler));
    }

    private static Action<object> BuildExpression<T>(Action<T> handler)
    {
        if (typeof(T) == typeof(object))
        {
            return (Action<object>)(Delegate)handler;
        }

        var par = Expression.Parameter(typeof(object));

        Expression body;

        if (typeof(T).IsValueType)
        {
            // We remove the nullable part of value types
            Type type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);

            var unbox = Expression.Unbox(par, typeof(T));
            body = Expression.IfThen(Expression.TypeEqual(par, type), Expression.Call(Expression.Constant(handler.Target), handler.Method, unbox));

            if (type != typeof(T))
            {
                // Nullable type
                // null with methods that accept nullable type: call the method
                body = Expression.IfThenElse(Expression.Equal(par, Expression.Constant(null)), Expression.Call(Expression.Constant(handler.Target), handler.Method, Expression.Constant(null, typeof(T))), body);
            }
        }
        else
        {
            // Imagine the resulting code will be:

            // (object par) => 
            // {
            //     if (par == null)
            //     {
            //         handler(null);
            //     }
            //     else
            //     {
            //         T local;
            //         local = par as T;
            //         if (local != null)
            //         {
            //             handler(local);
            //         }
            //     }
            // }

            var local = Expression.Variable(typeof(T));
                
            var typeAs = Expression.Assign(local, Expression.TypeAs(par, typeof(T)));

            var block = Expression.Block(new[]
            {
                local,
            },
            new Expression[]
            {
                typeAs,
                Expression.IfThen(Expression.NotEqual(typeAs, Expression.Constant(null)), Expression.Call(Expression.Constant(handler.Target), handler.Method, typeAs))
            });

            // Handling case par == null, call the method
            body = Expression.IfThenElse(Expression.Equal(par, Expression.Constant(null)), Expression.Call(Expression.Constant(handler.Target), handler.Method, Expression.Constant(null, typeof(T))), block);
        }

        var exp = Expression.Lambda<Action<object>>(body, par);
        return exp.Compile();
    }

    private void OnMessage(object sender, object payload)
    {
        foreach (var handlerDelegate in _handlers)
        {
            handlerDelegate(payload);
        }
    }
}



producer.Publish(null);



public sealed class FancyHandler
{
    private readonly List<Action<object>> _handlers = new List<Action<object>>();

    public FancyHandler(FancyEventProduder produer)
    {
        produer.OnMessge += OnMessage;
    }

    public void Register<T>(Action<T> handler)
    {
        if (typeof(T).IsValueType)
        {
            _handlers.Add(BuildExpressionValueType(handler));
        }
        else
        {
            // Have to use reflection here because the as operator requires a T is class
            // this check is bypassed by using reflection
            _handlers.Add((Action<object>)_buildExpressionReferenceTypeT.MakeGenericMethod(typeof(T)).Invoke(null, new[] { handler }));
        }
    }

    private static Action<object> BuildExpressionValueType<T>(Action<T> handler)
    {
        // We remove the nullable part of value types
        Type type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);

        if (type == typeof(T))
        {
            // Non nullable
            return (object par) =>
            {
                if (par is T)
                {
                    handler((T)par);
                }
            };
        }

        // Nullable type
        return (object par) =>
        {
            if (par == null || par is T)
            {
                handler((T)par);
            }
        };
    }

    private static readonly MethodInfo _buildExpressionReferenceTypeT = typeof(FancyHandler).GetMethod(nameof(BuildExpressionReferenceType), BindingFlags.Static | BindingFlags.NonPublic);

    private static Action<object> BuildExpressionReferenceType<T>(Action<T> handler) where T : class
    {
        if (typeof(T) == typeof(object))
        {
            return (Action<object>)(Delegate)handler;
        }

        return (object par) =>
        {
            if (par == null)
            {
                handler((T)par);
            }
            else
            {
                T local = par as T;

                if (local != null)
                {
                    handler(local);
                }
            }
        };
    }

    private void OnMessage(object sender, object payload)
    {
        foreach (var handlerDelegate in _handlers)
        {
            handlerDelegate(payload);
        }
    }
}