5

我有一个小问题要问你们。

我想这样做：

Type[] classes = new Type[]{ Class1, Class2 };

foreach(Type t in classes){   
  List<t> list = new List<t>(); 
}

有没有办法做到这一点？

4

5 回答 5

6

您不能在运行时强制转换为泛型类型，因为泛型中的类型需要在编译时解析。

您可以使用反射以动态方式创建泛型类型，但除非您对转换进行硬编码，否则您得到的只是一个对象。

我无法真正说出您想要什么，我必须同意评论这是一个XY 问题。我倾向于做出冒昧的陈述，即在某处试图解决设计问题，而不是直接解决设计问题，或者直接询问您要实现的目标。

您可以使用以下代码创建类型，然后该dynamic类型可用于在不知道/关心它是列表还是列表的情况下对各种成员进行回避：List<T>T

using System;
using System.Collections.Generic;

namespace ConsoleApplication61
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic o = CreateGeneric(typeof(List<>), typeof(int));
            o.Add(1);
            Console.WriteLine(o[0]);
            Console.Read();
        }

        public static object CreateGeneric(Type generic, Type innerType, params object[] args)
        {
            System.Type specificType = generic.MakeGenericType(new System.Type[] { innerType });
            return Activator.CreateInstance(specificType, args);
        }
    }
}

上面的示例鸭子类型的Add方法和索引器。DLR 在运行时进行类型处理和鸭子类型 - 例如，知道这1是一个int。

澄清一下，我可能不会在生产中使用此类代码（除非您的要求非常具体，需要此代码）并且任何类型不匹配的问题都会在运行时出现；因此，您要么需要非常准确地键入（有限的 IntelliSense），要么需要有良好的错误处理能力。

感谢这篇博文提供的CreateGeneric方法。

这假设 .NET 4 带有新的 CLR。正如@MartinLiversage 还指出的那样，这个特定的示例假设您正在以一种强类型的方式使用该列表。在我的示例中，我将 a 传递int给List<int>隐藏在 a 中的 a dynamic。

自从 .NET 4 发布以来，我们几乎一直在使用它。我们有一个带有更大代码库的大型应用程序。dynamic在应用程序中不使用一次，在测试代码库中仅使用几次。这并不是说“不要使用它”，而是说“大多数时候，你不需要它”。

于 2012-05-25T12:19:36.370 回答
5

你可以这样做：

foreach(Type t in classes)
{
   var listType = typeof(List<>).MakeGenericType(t);
   var instance = Activator.CreateInstance(listType);
}
于 2012-05-25T12:13:01.973 回答
2

这可以通过Type.MakeGenericType 方法实现

这是我发现对你有用的一个绝妙方法：CodeRef

public static object CreateGeneric(Type generic, Type innerType, params object[] args)
{
    System.Type specificType = generic.MakeGenericType(new System.Type[] { innerType });
    return Activator.CreateInstance(specificType, args);
}

并像这样使用它：

var o = CreateGeneric(typeof(List<>), t);

不幸的是，要添加项目，您必须这样做（其中 item 是您要添加的项目）。

MethodInfo addMethod = o.GetType().GetMethod("Add");
addMethod.Invoke(o, new object[] { item.ToType(t) });

或者使用Generic另一个答案中提到的类型。

于 2012-05-25T12:12:48.850 回答
1

你可以试试这个：

Type[] classes = new Type[] { typeof(A), typeof(B) };           
foreach (Type t in classes)
{
     Type genericType = typeof(List<>).MakeGenericType(t);
     var list = Activator.CreateInstance(genericType);
}
于 2012-05-25T12:21:14.057 回答
1

如果您想将对象保留在一个列表中，那么它们可能有一些共同点。

在这种情况下，我会争辩说，就像评论中提到的 LB 一样，你在这里问了一个错误的问题。

可能这是您遇到的设计问题。想想这些类型，看看它们有什么共同点，并考虑从一种基本类型派生，或者让两者实现相同的接口。在这种情况下，您将能够实例化基本类型/接口的对象列表并使用它们。

只是给你一个良好的开端：

    abstract class Vehicle {
        public int NumberOfWheels { get; set; }
    }

    class Car : Vehicle
    {
        public Car()
        {
            NumberOfWheels = 4;
        }
    }

    class Bicycle : Vehicle
    {
        public Bicycle()
        {
            NumberOfWheels = 2;
        }
    }

    static void Main(string[] args)
    {

        var v1 = new Car();
        var v2 = new Bicycle();

        var list = new List<Vehicle>();
        list.Add(v1);
        list.Add(v2);

        foreach (var v in list)
        {
            Console.WriteLine(v.NumberOfWheels);
        }

        Console.ReadKey();
    }
于 2012-05-25T12:39:33.523 回答