如何定义一个List<>来接收多种List<>

Question

C#List

Answer 1

如果有继承关系可以加到方法的泛型约束里
List<T> GetResult<T>() where T : 你的抽象类或者接口

Answer 2

public object aaa(object o)
{}各种反射什么的 可以实现么?

Answer 3

就是集合撒！ List<T>.add(list);

Answer 4

不知道你要怎么使用返回值，接收的话dynamic，IList……之类的

Answer 5

 public List<T> Data
        {
            get;
            set;
        }

Answer 6

最后一句话没得好懂。前面两行的意思可以用List<T>这搞定。
但是后面这个要看情况了。

Answer 7

那就定义一个dynamic变量去接收吧

Answer 8

“无法将类型System.Collections.Generic.List<Class1> 转换为System.Collections.Generic.List<dynamic>”

Answer 9

我贴代码吧，这样应该更直观switch(typeid)
{
    case 1:
             myList = Method1.GetList();//返回值为List<Class1>
             break;
    case 2:
             myList = Method2.GetList();//返回值为List<Class2>
             break;
    case 3:
             myList = Method3.GetList();//返回值为List<Class3>
             break;
}
如何定义这个myList呢？  

Answer 10

dynamic myList; 或者  IList myList;  看具体需求

Answer 11

List<Class1>跟List<Class2>根本就是毫无关系的两个类型，无法“定义”。只有装箱传给 object 变量。

Answer 12

只有装箱传给 object 变量   -->    只有装箱传给 IList、IEnumerable  等类型的变量
这里，不是为了编程而编程。可能跟你说了你也不明白，这是一个设计原则问题。你都不知道要得到什么类型的集合，干么偏要给它们纠结在一个 switch-case 里边呢？这在系统分析和设计上肯定存在着“推卸设计责任、浑水摸鱼”的习惯。

Answer 13

Object myList ;
switch(typeid)
{
    case 1:
             myList = Method1.GetList();//返回值为List<Class1>
             break;
    case 2:
             myList = Method2.GetList();//返回值为List<Class2>
             break;
    case 3:
             myList = Method3.GetList();//返回值为List<Class3>
             break;
}
功能能实现，不过这种做法比较奇葩

Answer 14

看了下帖子...发现撸主想要的功能可能是:传递一个参数过来,比如class=testclass这样
根据这个class的值不同,调用LIST<testclass>这样..

Answer 15

楼主的设计肯定是有问题的.
首先你要归纳出这三种返回值的关系.
如果没有关系,那这里的switch又是个什么意思呢?如果不想大改,那只能使用object了.

Answer 16

好像不是欸，比如我要去果园采果子，里面有苹果、梨子、橘子，不同的水果一般是用不同的篮子装(别在意这些细节)，现在情况是在进果园前我并不知道要采哪种果子， 那除了我同时准备三个篮子进去（实际只有一个篮子用的上）外，有没其他方法
苹果篮、梨子篮、橘子篮 如果都是派生于水果篮，那可以用List<水果篮>来接收 List<苹果篮>、List<梨子篮>、List<橘子篮>，可能要涉及逆变和谐变。
如果这几个篮子完全没有关系，那就是设计问题了，即使放到一个list里，也没有人能知道放了什么，能怎么用，最后就是反射来反射去，越弄越复杂。

Answer 17

    public List<T> GetList<T>(int type)
        {
            T myList;
            switch (type)
            {
                case 1:
                    myList = Method1.GetList();//返回值为List<Class1>
                    break;
                case 2:
                    myList = Method2.GetList();//返回值为List<Class2>
                    break;
                case 3:
                    myList = Method3.GetList();//返回值为List<Class3>
                    break;
            }
        }这样也行避免装箱什么的

Answer 18

好像不是欸，比如我要去果园采果子，里面有苹果、梨子、橘子，不同的水果一般是用不同的篮子装(别在意这些细节)，现在情况是在进果园前我并不知道要采哪种果子， 那除了我同时准备三个篮子进去（实际只有一个篮子用的上）外，有没其他方法
苹果篮、梨子篮、橘子篮 如果都是派生于水果篮，那可以用List<水果篮>来接收 List<苹果篮>、List<梨子篮>、List<橘子篮>，可能要涉及逆变和谐变。
如果这几个篮子完全没有关系，那就是设计问题了，即使放到一个list里，也没有人能知道放了什么，能怎么用，最后就是反射来反射去，越弄越复杂。
嗯，现在的设计是这三个篮子没有关系，我想的是如果能放到一个List里了， 那么是否就能够用类似拆箱的方式得到他原来的类型呢

Answer 19

“无法将类型System.Collections.Generic.List<Class> 转换为T”

Answer 20

好像不是欸，比如我要去果园采果子，里面有苹果、梨子、橘子，不同的水果一般是用不同的篮子装(别在意这些细节)，现在情况是在进果园前我并不知道要采哪种果子， 那除了我同时准备三个篮子进去（实际只有一个篮子用的上）外，有没其他方法
苹果篮、梨子篮、橘子篮 如果都是派生于水果篮，那可以用List<水果篮>来接收 List<苹果篮>、List<梨子篮>、List<橘子篮>，可能要涉及逆变和谐变。
如果这几个篮子完全没有关系，那就是设计问题了，即使放到一个list里，也没有人能知道放了什么，能怎么用，最后就是反射来反射去，越弄越复杂。
嗯，现在的设计是这三个篮子没有关系，我想的是如果能放到一个List里了， 那么是否就能够用类似拆箱的方式得到他原来的类型呢装箱拆箱和这个一点关系都没有，那是值类型和引用类型的转换，不要认为出现object就是拆箱，完全不搭嘎的事情。
如果你作为类库开发者，那么可以用泛型，不用纠结具体是什么类型，作为类库开发者只要知道有一种类型的数据进来了，你要处理的只是和类型无关的算法。
如果你是作为最终的胶水程序员，那你应该知道放进去是什么类型，用objecct集合，取出来的时候强制转换就可以了，思考一下你的代码，下一步是写什么，假如放进去以后，你打算怎么写处理这个不知道存放什么的集合的代码？

Answer 21

public class A
{
public string id{get;set;}
public string name{get;set;}
}
public class B
{
public string id{get;set;}
public string name{get;set;}
}
public class C
{
public string id{get;set;}
public string name{get;set;}
}
public class List
{
  public List<A> listA{get;set;}
  public List<B> listB{get;set;}
  public List<C> listC{get;set;}
}

Answer 22

好像不是欸，比如我要去果园采果子，里面有苹果、梨子、橘子，不同的水果一般是用不同的篮子装(别在意这些细节)，现在情况是在进果园前我并不知道要采哪种果子， 那除了我同时准备三个篮子进去（实际只有一个篮子用的上）外，有没其他方法
苹果篮、梨子篮、橘子篮 如果都是派生于水果篮，那可以用List<水果篮>来接收 List<苹果篮>、List<梨子篮>、List<橘子篮>，可能要涉及逆变和谐变。
如果这几个篮子完全没有关系，那就是设计问题了，即使放到一个list里，也没有人能知道放了什么，能怎么用，最后就是反射来反射去，越弄越复杂。
嗯，现在的设计是这三个篮子没有关系，我想的是如果能放到一个List里了， 那么是否就能够用类似拆箱的方式得到他原来的类型呢装箱拆箱和这个一点关系都没有，那是值类型和引用类型的转换，不要认为出现object就是拆箱，完全不搭嘎的事情。
如果你作为类库开发者，那么可以用泛型，不用纠结具体是什么类型，作为类库开发者只要知道有一种类型的数据进来了，你要处理的只是和类型无关的算法。
如果你是作为最终的胶水程序员，那你应该知道放进去是什么类型，用objecct集合，取出来的时候强制转换就可以了，思考一下你的代码，下一步是写什么，假如放进去以后，你打算怎么写处理这个不知道存放什么的集合的代码？用List<T>和List<Object>都不行啊， 要是能放进去了就很简单的，循环该集合，每项转换成原来的类型再取它的字段值就好了，

Answer 23

好像不是欸，比如我要去果园采果子，里面有苹果、梨子、橘子，不同的水果一般是用不同的篮子装(别在意这些细节)，现在情况是在进果园前我并不知道要采哪种果子， 那除了我同时准备三个篮子进去（实际只有一个篮子用的上）外，有没其他方法
苹果篮、梨子篮、橘子篮 如果都是派生于水果篮，那可以用List<水果篮>来接收 List<苹果篮>、List<梨子篮>、List<橘子篮>，可能要涉及逆变和谐变。
如果这几个篮子完全没有关系，那就是设计问题了，即使放到一个list里，也没有人能知道放了什么，能怎么用，最后就是反射来反射去，越弄越复杂。
嗯，现在的设计是这三个篮子没有关系，我想的是如果能放到一个List里了， 那么是否就能够用类似拆箱的方式得到他原来的类型呢装箱拆箱和这个一点关系都没有，那是值类型和引用类型的转换，不要认为出现object就是拆箱，完全不搭嘎的事情。
如果你作为类库开发者，那么可以用泛型，不用纠结具体是什么类型，作为类库开发者只要知道有一种类型的数据进来了，你要处理的只是和类型无关的算法。
如果你是作为最终的胶水程序员，那你应该知道放进去是什么类型，用objecct集合，取出来的时候强制转换就可以了，思考一下你的代码，下一步是写什么，假如放进去以后，你打算怎么写处理这个不知道存放什么的集合的代码？用List<T>和List<Object>都不行啊， 要是能放进去了就很简单的，循环该集合，每项转换成原来的类型再取它的字段值就好了，
你还是没明白，放进去容易，拿出来难，你都不知道放进去什么，循环的时候你怎么用？只能使用object的那几个方法 tostring什么的，自己定义的是不能用的，转换？转换成什么？List<Object>是逆变谐变，要修改代码的，list不行，数组默认就可以，比如
            object[] d;
            d = new A[5];
            d = new B[5];
            d = new C[5];
object的数组可以存放A数组B数组等。List<T>是泛型，不是你要的

Answer 24

好像不是欸，比如我要去果园采果子，里面有苹果、梨子、橘子，不同的水果一般是用不同的篮子装(别在意这些细节)，现在情况是在进果园前我并不知道要采哪种果子， 那除了我同时准备三个篮子进去（实际只有一个篮子用的上）外，有没其他方法这个前提是他们有一个共同的父类水果。。如果你那三个list也是继承自同一个父类就好解决了

Answer 25

好像不是欸，比如我要去果园采果子，里面有苹果、梨子、橘子，不同的水果一般是用不同的篮子装(别在意这些细节)，现在情况是在进果园前我并不知道要采哪种果子， 那除了我同时准备三个篮子进去（实际只有一个篮子用的上）外，有没其他方法
苹果篮、梨子篮、橘子篮 如果都是派生于水果篮，那可以用List<水果篮>来接收 List<苹果篮>、List<梨子篮>、List<橘子篮>，可能要涉及逆变和谐变。
如果这几个篮子完全没有关系，那就是设计问题了，即使放到一个list里，也没有人能知道放了什么，能怎么用，最后就是反射来反射去，越弄越复杂。
嗯，现在的设计是这三个篮子没有关系，我想的是如果能放到一个List里了， 那么是否就能够用类似拆箱的方式得到他原来的类型呢装箱拆箱和这个一点关系都没有，那是值类型和引用类型的转换，不要认为出现object就是拆箱，完全不搭嘎的事情。
如果你作为类库开发者，那么可以用泛型，不用纠结具体是什么类型，作为类库开发者只要知道有一种类型的数据进来了，你要处理的只是和类型无关的算法。
如果你是作为最终的胶水程序员，那你应该知道放进去是什么类型，用objecct集合，取出来的时候强制转换就可以了，思考一下你的代码，下一步是写什么，假如放进去以后，你打算怎么写处理这个不知道存放什么的集合的代码？用List<T>和List<Object>都不行啊， 要是能放进去了就很简单的，循环该集合，每项转换成原来的类型再取它的字段值就好了，
你还是没明白，放进去容易，拿出来难，你都不知道放进去什么，循环的时候你怎么用？只能使用object的那几个方法 tostring什么的，自己定义的是不能用的，转换？转换成什么？List<Object>是逆变谐变，要修改代码的，list不行，数组默认就可以，比如
            object[] d;
            d = new A[5];
            d = new B[5];
            d = new C[5];
object的数组可以存放A数组B数组等。List<T>是泛型，不是你要的不是啊， 我当然知道装进去的是什么， 因为我是根据不同参数去调用不同方法的啊。
嗯，我刚查了下逆变协变， 发现还是需要在设计上去修改那三个水果之间的关系，至少让他们继承自同一个基类，这样应该就好办了吧

Answer 26

好像不是欸，比如我要去果园采果子，里面有苹果、梨子、橘子，不同的水果一般是用不同的篮子装(别在意这些细节)，现在情况是在进果园前我并不知道要采哪种果子， 那除了我同时准备三个篮子进去（实际只有一个篮子用的上）外，有没其他方法
苹果篮、梨子篮、橘子篮 如果都是派生于水果篮，那可以用List<水果篮>来接收 List<苹果篮>、List<梨子篮>、List<橘子篮>，可能要涉及逆变和谐变。
如果这几个篮子完全没有关系，那就是设计问题了，即使放到一个list里，也没有人能知道放了什么，能怎么用，最后就是反射来反射去，越弄越复杂。
嗯，现在的设计是这三个篮子没有关系，我想的是如果能放到一个List里了， 那么是否就能够用类似拆箱的方式得到他原来的类型呢装箱拆箱和这个一点关系都没有，那是值类型和引用类型的转换，不要认为出现object就是拆箱，完全不搭嘎的事情。
如果你作为类库开发者，那么可以用泛型，不用纠结具体是什么类型，作为类库开发者只要知道有一种类型的数据进来了，你要处理的只是和类型无关的算法。
如果你是作为最终的胶水程序员，那你应该知道放进去是什么类型，用objecct集合，取出来的时候强制转换就可以了，思考一下你的代码，下一步是写什么，假如放进去以后，你打算怎么写处理这个不知道存放什么的集合的代码？用List<T>和List<Object>都不行啊， 要是能放进去了就很简单的，循环该集合，每项转换成原来的类型再取它的字段值就好了，
你还是没明白，放进去容易，拿出来难，你都不知道放进去什么，循环的时候你怎么用？只能使用object的那几个方法 tostring什么的，自己定义的是不能用的，转换？转换成什么？List<Object>是逆变谐变，要修改代码的，list不行，数组默认就可以，比如
            object[] d;
            d = new A[5];
            d = new B[5];
            d = new C[5];
object的数组可以存放A数组B数组等。List<T>是泛型，不是你要的不是啊， 我当然知道装进去的是什么， 因为我是根据不同参数去调用不同方法的啊。
嗯，我刚查了下逆变协变， 发现还是需要在设计上去修改那三个水果之间的关系，至少让他们继承自同一个基类，这样应该就好办了吧然后又根据typeid写一个是switch ？