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 = ; 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;

    }

}