通过编译lambda表达式来创建实例（可在反射时候用，效率比反射高一些）

class Program
{
    static void Main(string[] args)
    {
        var type = typeof(List<int>);
        var ctor = type.GetConstructor(Type.EmptyTypes);

        //使用Activator
        var list1 = Activator.CreateInstance(type);

        //使用ObjectActivator
        var activator = GetActivator<List<int>>(ctor);
        var list = activator.Invoke();

        Console.ReadKey();
    }


    public delegate T ObjectActivator<out T>(params object[] args);

    public static ObjectActivator<T> GetActivator<T>(ConstructorInfo ctor)
    {
        ParameterInfo[] paramsInfo = ctor.GetParameters();

        //create a single param of type object[]
        ParameterExpression param = Expression.Parameter(typeof(object[]), "args");
        Expression[] argsExp = new Expression[paramsInfo.Length];

        //pick each arg from the params array 
        //and create a typed expression of them
        for (int i = 0; i < paramsInfo.Length; i++)
        {
            Expression index = Expression.Constant(i);
            Type paramType = paramsInfo[i].ParameterType;

            Expression paramAccessorExp = Expression.ArrayIndex(param, index);

            Expression paramCastExp = Expression.Convert(paramAccessorExp, paramType);

            argsExp[i] = paramCastExp;
        }

        //make a NewExpression that calls the
        //ctor with the args we just created
        NewExpression newExp = Expression.New(ctor, argsExp);

        //create a lambda with the New
        //Expression as body and our param object[] as arg
        LambdaExpression lambda = Expression.Lambda(typeof(ObjectActivator<T>), newExp, param);

        //compile it
        ObjectActivator<T> compiled = (ObjectActivator<T>)lambda.Compile();
        return compiled;
    }

}