如何轮询泛型集合

Question

using   System; 
using   System.Collections; namespace   test 
{ 
        public   interface    IColumn 
        {                 object   Value 
                { 
                        get;
                } 
        }         public   class   IntColumn   :   IColumn
        { 
                int  value;
                public  object Value
                { 
                        get { return (object)this.value; }
                }                 public   IntColumn(int   value) 
                { 
                        this.value   =   value; 
                } 
        }         public   class   BoolColumn   :   IColumn
        { 
                bool  value;
                public  object Value
                { 
                        get { return (object)this.value; }
                }                 public   BoolColumn(bool   value) 
                { 
                        this.value   =   value; 
                } 
        }         public   class   StringColumn   :   IColumn
        { 
                string  value;
                public  object Value
                { 
                        get { return (object)this.value; }
                }                 public   StringColumn(string   value) 
                { 
                        this.value   =   value; 
                } 
        } 
        class   Program 
        { 
                static   void   Main(string[]   args) 
                { 
                        ArrayList   list   =   new   ArrayList(); 
                        list.Add(new   BoolColumn(true)); 
                        list.Add(new   IntColumn(123)); 
                        list.Add(new   StringColumn("abc"));                         foreach(object col     in   list)
                        {                                                                       
                                Console.WriteLine((col as IColumn).Value); 
                        } 
                } 
        }         
} 

Answer 1

2楼的方法我会，但我不想使用object，因为会增加对象转换成本，泛型就不会。
但不知道有没有这种轮询的方法。

Answer 2

using   System; 
using   System.Collections; namespace   test 
{ 
        public   class   Column <T> 
        { 
                private   T   value;                 public   T   Value 
                { 
                        get   {   return   this.value;   } 
                        set   {   this.value   =   value;   } 
                } 
                
                public override string ToString()
                {
                    return value.ToString();
                }
        }         public   class   IntColumn   :   Column <int> 
        { 
                public   IntColumn(int   value) 
                { 
                        this.Value   =   value; 
                } 
        }         public   class   BoolColumn   :   Column <bool> 
        { 
                public   BoolColumn(bool   value) 
                { 
                        this.Value   =   value; 
                } 
        }         public   class   StringColumn   :   Column <string> 
        { 
                public   StringColumn(string   value) 
                { 
                        this.Value   =   value; 
                } 
        } 
        class   Program 
        { 
                static   void   Main(string[]   args) 
                { 
                        ArrayList   list   =   new   ArrayList(); 
                        list.Add(new   BoolColumn(true)); 
                        list.Add(new   IntColumn(123)); 
                        list.Add(new   StringColumn("abc"));                         foreach(object   col   in   list) 
                        {                                                                       
                                Console.WriteLine(col); 
                        }                 } 
        }         
} 
/*
程序输出：
True
123
abc
*/

Answer 3

你那几个XXXXColumn的共同的祖先并不是Column<T>，可以给他们加上一个共同的祖先
public class ObjectColumn : Column<object>
    {
    }
    public class IntColumn :ObjectColumn
    {
        public IntColumn(int value)
        {
            this.Value = value;
        }
    }    public class BoolColumn : ObjectColumn
    {
        public BoolColumn(bool value)
        {
            this.Value = value;
        }
    }    public class StringColumn : ObjectColumn
    {
        public StringColumn(string value)
        {
            this.Value = value;
        }
    }。。foreach (ObjectColumn col in list)

Answer 4

6楼，这个输出是Console.WriteLine使用了Object的ToString（）来的，
但我Foreach里并不一定只访问ToString()

Answer 5

7楼，如果value不用object类型，怎么处理？
我说了用object会增加对象转换成本，如果小量用OK，但底层用要承载大量数据的话就不好。

Answer 6

按照需求来看，lz要求的范型编程方式，C#不支持。C#是强制类型系统，范型不过是类型模板，没有实例化是用不了的。建议lz在看看C#语言规范吧。

Answer 7

楼主真的应该再看看书，你那个ArrayList和foreach本身就用到了类型转换，为何就不允许别人用类型转换？

Answer 8

晕死~~~~======================================================================
0楼ArrayList list = new ArrayList();
list.Add(new BoolColumn(true));
list.Add(new IntColumn(0));
list.Add(new StringColumn("abc"));
4楼
2楼的方法我会，但我不想使用object，因为会增加对象转换成本，泛型就不会。
但不知道有没有这种轮询的方法。9楼
7楼，如果value不用object类型，怎么处理？
我说了用object会增加对象转换成本，如果小量用OK，但底层用要承载大量数据的话就不好。
======================================================================自己在用object，还不许别人用，典型的"只许州官放火，不许百姓点灯"啊！！！

Answer 9

你看清楚，那只是列集合在使用Object，Column的值并没有使用Object，因为列集合只是少数。
我并不是说都不用Object,ArrayList里面装的是什么我还是清楚的。

Answer 10

11楼说得对，不能用，只能判断col是不是泛型类型，访问不到它的属性值。因为不知道实例的类型。
我想过别的方法实现。

Answer 11

using   System; 
using   System.Collections; namespace   test 
{ 
        public   interface    IColumn 
        {                 object   Value 
                { 
                        get;
                } 
        }         public   class   IntColumn   :   IColumn
        { 
                int  value;
                public  object Value
                { 
                        get { return (object)this.value; }
                }                 public   IntColumn(int   value) 
                { 
                        this.value   =   value; 
                } 
        }         public   class   BoolColumn   :   IColumn
        { 
                bool  value;
                public  object Value
                { 
                        get { return (object)this.value; }
                }                 public   BoolColumn(bool   value) 
                { 
                        this.value   =   value; 
                } 
        }         public   class   StringColumn   :   IColumn
        { 
                string  value;
                public  object Value
                { 
                        get { return (object)this.value; }
                }                 public   StringColumn(string   value) 
                { 
                        this.value   =   value; 
                } 
        } 
        class   Program 
        { 
                static   void   Main(string[]   args) 
                { 
                        ArrayList   list   =   new   ArrayList(); 
                        list.Add(new   BoolColumn(true)); 
                        list.Add(new   IntColumn(123)); 
                        list.Add(new   StringColumn("abc"));                         foreach (IColumn col in list)
                        {                                                                       
                          Console.WriteLine(col.Value); 
                        } 
                } 
        }         
} foreach (IColumn col in list)不用 object ，这样可以了？

Answer 12

using System.Collections.Generic;class Program
{
  static void Main()
  {
    List<IColumn> list = new List<IColumn>();
    list.Add(new BoolColumn(true));
    list.Add(new IntColumn(-5123));
    list.Add(new StringColumn("abc"));    foreach (IColumn col in list)
    {
      Console.WriteLine(col.Value);
    }
  }
}其实应该用 System.Collections.Generic.List 而不是 System.Collections.ArrayList

Answer 13

楼主我这么跟你说吧，泛型不是OBJECT的完全替代方案，尽管微软一再说明他解决了装箱拆箱的性能问题。泛型的 T 是在代码中预先定义了一种类型，不可以理解为类，只能理解为类的模版。
所以Column<T> 是一个模版，而Column<int> Column<bool> Column<string>是其经过JIT编译时创建的三种不同的类型，其区别就如同int bool 和 string。你的问题相当于如何轮询 int bool 和 string混杂的集合。这个当然通过基类或基接口来实现。楼上的程序都是正解，否则你如何定义一个固定类型的变量接收从集合里取出的不同类型的变量?
你盲目的认定不合适，是中了微软的毒，认为泛型是取代object转换而存在的。实则是对泛型的认知误解。泛型只能在部分条件合适的情况下取代OBJECT转换，提高效率。而OBJECT仍然是兼容性非常高的，特殊的存在，即使推出了泛型，微软也没有能将数据库的基石DATATABLE改写成泛型版本的。这点你可以反编译DATATABLE源码看看。内部不论存什么元素，都是转OBJECT存的，也就是说你这个问题微软也遇到了（一行记录为一个集合，集合内包含多种后期使用时才定义的数据类型），微软都做不到，你用微软的产品哪里能做到？楼主要谦虚地感谢楼上回答问题的人，并认识到自己提了个可笑的问题，因为自己不知道这有多么可笑。

Answer 14

1、Column<int>、Column<bool>和Column<string>是三个类，它们除了一个共同的基类Object外，并没有一个基类。
楼上的定义IColumn或定义ObjectColumn的方法都是合适的方法。2、在很多时候，直接用一个类（如ObjectColumn）就够了，没有必要定义Column<int>、Column<bool>和Column<string>三个类。然后在ObjectColumn的object Value中保存int、bool或string数据。如果楼主真的不想用Object类型来保存Column中的Value，也可以考虑为IColumn或ObjectColumn定义一个string value来保存数据，再定义一个你自定义枚举类型(0-int, 1-bool, 2-string)的dataType属性来保存数据的类型。在输出栏目的时候利用dataType来格式化value。

Answer 15

lz需要补习一下基础了.lz根本没有理解泛型,拆\装箱,明显存在误区.ls已经解释的很清楚了,我只说一点:你已经定义了类来存放数据,然后你把这些类的实例放入和取出ArrayList是不存在拆装箱问题的.