如何在C#中将以下代码转换为已编译表达式

本文关键字：转换 代码 表达式 编译 | 更新日期: 2023-09-27 18:27:25

我有一段代码，负责使用反射创建一个通用列表。

public static IList MakeList(Type listType)
{
    // checks to ensure listType is a generic list omitted...
    // gets the generic argument e.g. string for a List<string>
    var genericType = listType.GetGenericArguments()[0];
    return (IList)typeof(List<>)
        .MakeGenericType(genericType)
        .GetConstructor(Type.EmptyTypes)
        .Invoke(null);
}

我可以通过以下方式调用：

var stringList = MakeList(typeof(IList<string>));
var intList = MakeList(typeof(IList<int>));

或者例如来自PropertyInfo:

MekList(propInfo.PropertyType);

请注意，由于类型可能来自PrpertyInfo，例如，如果属性的类型为IList<string>，则使用Activator.CreateInstance(propType)会引发异常：Cannot create an instance of an interface.

如何将其转换为已编译的表达式以获得性能优势？

如何在C#中将以下代码转换为已编译表达式

您需要一个NewExpression。示例（我还没有测试）：

private static Dictionary<Type, Func<IList>> funcs;
public static IList MakeList(Type listType)
{
    Func<IList> f;
    // checks to ensure listType is a generic list omitted...
    if(!funcs.TryGetValue(listType, out f)) {
        // gets the generic argument e.g. string for a List<string>
        var genericType = listType.GetGenericArguments()[0];
        var ctor = typeof(List<>)
                   .MakeGenericType(genericType)
                   .GetConstructor(Type.EmptyTypes);
        f = Expression.Lambda<Func<IList>>(
            Expression.New(ctor, new Expression[]{})).Compile();
        funcs[listType] = f;
    }
    return f();
}

确保您测量了性能，以检查这是否真的比简单地使用Activator.CreateInstance.更快

如果你总是使用typeof(...)，你也可以使用这样的通用方法：

public static IList<T> MakeList<T>()
{
    return new List<T>();
}

你这样使用它：

var stringList = MakeList<string>();
var intList = MakeList<int>();

如果您在编译时不知道类型，则无法按照您想要的方式编写。您可以用Expression将相同的方法称为代码段，但它将是相同的。尝试使用Activator.CreateInstance(typeof(WhatEver))。

我测试了你的代码和Activator类CreateInstace方法10000个实例100次，结果是：

  1. 对于MakeList：1300毫秒
  2. 对于CreateInstance 0.8毫秒

多亏了Random832，我最终得到了：

public static class New
{
    public static readonly Func<Type, IList> MakeList = t => MakeListImpl(t)();
    private static readonly IDictionary<Type, Func<IList>> Cache = new Dictionary<Type, Func<IList>>();
    private static Func<IList> MakeListImpl(Type listType)
    {
        Func<IList> result;
        if (!Cache.TryGetValue(listType, out result))
        {
            Ensure.That(listType.IsGenericList());
            var genericArg = listType.GetGenericArguments()[0];
            var concreteType = typeof(List<>).MakeGenericType(genericArg);
            result = Expression.Lambda<Func<IList>>(Expression.New(concreteType)).Compile();
            Cache[listType] = result;
        }
        return result;
    }
}

基准（发布版本|平均运行1000次）

1,000,000
------------------------------------
Native:             00:00:00.0103980
ActivatorGeneric:   00:00:00.1274370
ActivatorType:      00:00:00.1115370
CompiledNew:        00:00:00.0261892
10,000,000
------------------------------------
Native:             00:00:00.1040899
ActivatorGeneric:   00:00:01.2864721
ActivatorType:      00:00:01.1627026
CompiledNew:        00:00:00.2432613

NewListNative           => list = new List<string>()
NewListActivatorGeneric => list = System.Activator.CreateInstance<List<string>>()
NewListActivatorType    => list = (List<string>) System.Activator.CreateInstance(typeof(List<string>))
CompiledNew             => list = (List<string>)New.MakeList(typeof(List<string>))
相关文章：