List<T> 中的T能否动态生成

Question

请问 List<T>中的T是不是一定要指明一种特定的类型 
比如 List<string> List<int>我遇到的问题是，需要用到List容器，但是类型可能得到运行时才能确定，比如运行时才通过参数知道需要用到的是string或是int类型的List容器
难道要用List<object> 来做转换?

Answer 1

可以考虑用ArrayList或是使用的类定义泛型，传递。

Answer 2

List<T> 使用时 当然需要知道类型，要不能 怎么实例化 成功？

Answer 3

public class Form1<T> : Form
{
    public List<T> unstandard = new List<T>();
}

Answer 4

如果你知道可能是哪几种类型，可以通过Switch语句来判断出该类型，再根据类型来实例化集合。

Answer 5

List<T>它本身是一个安全的泛型容器，之所以安全就是因为要指定类型，不会出现类型转换时的错误
既然不想指定类型当然没必要用List<T>。。
ArrayList放进去的Object，出来的时候你类型转换一下，比较适合你的需要吧。。

Answer 6

LZ说的完全可以实现，先用typeof得到一个泛型类的定义，然后用MakeGeneric来将类型值具体化，最后CreateInstance，完成动态创建一个泛型类的实例。
如下代码，动态创建两个int和string的List<T>，并加入相应数据。        static void Main()
        {
            List<int> intList = (List<int>)MakeList(typeof(int), 1, 2, 3);
            List<string> strList = (List<string>)MakeList(typeof(string), "sdfd", "fet");            foreach(int i in intList)
                Console.WriteLine(i);
        }        static object MakeList(Type t, params object[] items)
        {
            Type type = typeof(List<>).MakeGenericType(t);            object list = Activator.CreateInstance(type);
            System.Collections.IList ilist = list as System.Collections.IList;
            foreach (object o in items)
                ilist.Add(o);
            return list;
        }

Answer 7

List<T>本身T就是在实例化的时候才确定的

Answer 8

要是 我能在代码中写 List<int>的话 应该就不用动态创建List了吧

Answer 9

泛型从来不是因为要解决动态（运行时）确定变量类型这样的问题而出现的，泛型的出现是为了强类型化
集合参数，最大程度的提高编译时类型检查，同时增加代码的可读性，使程序更加清晰明确而存在的。我们平时运用泛型时，其所能够解决的问题，不用泛型一样能够解决。我们这样写    public class Main<T> where T: new()
    {
        public void work()
        {
            T t = new T();
            //string s = t.GetName();
        }
    }
//调用
Main<A> m = new Main<A>();
m.work();泛型同样要做编译时的类型检查，参数类型在编译时就已经确定了。
framework4.0之后可以用dynamic关键字，这是真正的编译时确定类型。在4.0之前，反射可以实现，但是代码稍显复杂，可能也违背了楼主的本意。

Answer 10

修正代码，有问题的话继续讨论
        static void Main()
        {
            object intList = MakeList(typeof(int), 1, 2, 3);
            object strList = MakeList(typeof(string), "sdfd", "fet");            //List<int>
            foreach(object obj in (System.Collections.IEnumerable)intList)
                Console.WriteLine(obj);            //List<string>
            foreach(object obj in (System.Collections.IEnumerable)strList)
                Console.WriteLine(obj);
        }        static object MakeList(Type t, params object[] items)
        {
            Type type = typeof(List<>).MakeGenericType(t);            object list = Activator.CreateInstance(type);
            System.Collections.IList ilist = list as System.Collections.IList;
            foreach (object o in items)
                ilist.Add(o);
            return list;
        }

Answer 11

对，可以用Dynamic，不过要.NET Framwork 4.0才可以

Answer 12

纠正一下错误，T是在编译时就确定的，如果T不指定，就会发生类型擦除，即编译后T被换成Object。

Answer 13

泛型是给编译器看的，一旦编译通过，泛型会被编译器拿掉
泛型，我个人觉得，它只是一个编译阶段的报错机制和使用时的自动类型转换机制。
比如，你将List的泛型写成String，只能保证，在编译时，你是不能往它里面装其他类型的，例：List<String> list  = new ArrayList<String>();
list.add("item1");   // 编译通过
list.add(new Date().toString()); // 编译通过
list.add(2);  // 不能通过编译。
但是，既然，我们知道，JAVA的泛型机制，区别于 C++, 它只是编译阶段的一种机制，编译之后的class是没有泛型信息的。
那么如果我用反射的方式去调用 add 方法，那就可以跳过泛型的限制咯，比如我的集合的泛型是String，在编译之前，你的程序里貌似肯定只能装String，但是一旦编译之后，你的String这个泛型就不存在了,所以我用反射的方式直接调用编译后的 add 方法，那么我就可以往这个集合里加一个Integer了。List<String> list  = new ArrayList<String>();
list.add("item1");   // 编译通过
list.add(new Date().toString()); // 编译通过Class clazz = list.getClass();
Method method = clazz.getMethod("add", );
Method method = clazz.getMethod("add", Object.class);
method.invoke(list, 1); // 通过反射的方法“翻墙”添加一个 Integer// 注意这儿只能用 Object 来定义
for (Object obj : list) {
   System.out.println(obj);
}

Answer 14

楼主的问题可以这样解决：
定义一个父类：
public abstract class SimpleDao<T> {}
子类传入实际泛型：
public class SimplDaoImpl extends SimpleDao<User user> {}

Answer 15

使用通配符<?>  例子:public class Test{}

Answer 16

如果楼主想的是遍历不同类型的集合  可以用这个例子:
public class Test{
public static void main(String args[]){
Test t=new Text();
List<String> lis=new ArrayList<String>();
lis.add("abc");
lis.add("efg");
t.overview(lis);
List<Integer> lii=new ArrayList<Integer>();
lii.add(1000);
lii.add(2000);
t.overview(lii);
}
public void overview(List<?> li){
for(Object o:li){
System.out.println(li);
}
}
}

Answer 17

看看c++ Primer上关于句柄的内容，会有你要的答案的。楼主用句柄封装你要的多态的效果