架构设计中关于类型转换（object<--->List），会有什么损失。

[toploveall]

直接上代码

     //父类
    public class Base
    {
        public virtual object GetList()
        {
            return null;
        }
    }
    
    //子类A
    public class A : Base
    {
        public override object GetList()
        {
            //返回List<A>
            List<A> aList = new List<A>();
            return aList;//会不会自动转成Object类型
        }
    }
    //子类B
    public class B : Base
    {
        public override object GetList()
        {
            List<B> bList = new List<B>();
            return bList;//会不会转成Object类型
        }
    }

    //上下文
    public class Context
    {
        Base b;
        public Context(Base b)
        {
            this.b = b;
        }
        public object GetList()
        {
            return b.GetList();
        }
    }

   //客户端
    public class Client
    {
        public void Test()
        {
            Context ct = new Context(new A());
            List<A> aList = ct.GetList() as List<A>;//会不会有性能损失，数据会不会转出错了
            List<B> bList = new Context(new B()).GetList() as List<B>;
        }
    }

我的意图大家通过代码应该很清楚。
以上的代码，把object和List之间转来转去，会不会影响性能，数据会不会转丢掉。
如果哪位大侠有更好的建议，请指点。

[toploveall]

Base中的GetList方法类型能不能动态的反映出子类的类型，而不是用object。 之前我用List<Base>,在子类重写时返回的是List<A>或List<B> 结果编译不过，所以只能用object了。

[youzelin]

    public abstract class Base
    {
        public abstract IEnumerable<Base> GetList();
    }
    public class DerivedA : Base
    {
        public override IEnumerable<Base> GetList()
        {
            return new List<DerivedA>();
        }
    }
    public class DerivedB : Base
    {
        public override IEnumerable<Base> GetList()
        {
            return new List<DerivedB>();
        }
    }
    public class Context
    {
        Base b;
        public Context(Base b)
        {
            this.b = b;
        }
        public object GetList()
        {
            return b.GetList();
        }
    }
    public class Client
    {
        public void Test()
        {
            var aList = new Context(new DerivedA()).GetList();
            var bList = new Context(new DerivedB()).GetList();
        }
    }

[Andy__Huang]

子类父类和继续承关系的,转换后不会有丢失,放心就是了

[Regan-lin]

引用 3 楼 hdhai9451 的回复:

子类父类和继续承关系的,转换后不会有丢失,放心就是了

正解

[showjim]

性能损失肯定是有的，因为需要做类型判定。可以考虑使用泛型

        //父类
        public class Base<T>
        {
            public virtual List<T> GetList()
            {
                return null;
            }
        }

        //子类A
        public class A : Base<A>
        {
            public override List<A> GetList()
            {
                //返回List<A>
                List<A> aList = new List<A>();
                return aList;//会不会自动转成Object类型
            }
        }
        //子类B
        public class B : Base<B>
        {
            public override List<B> GetList()
            {
                List<B> bList = new List<B>();
                return bList;//会不会转成Object类型
            }
        }

        //上下文
        public class Context<T>
        {
            Base<T> b;
            public Context(Base<T> b)
            {
                this.b = b;
            }
            public List<T> GetList()
            {
                return b.GetList();
            }
        }

        //客户端
        public class Client
        {
            public void Test()
            {
                Context<A> ct = new Context<A>(new A());
                List<A> aList = ct.GetList();
                List<B> bList = new Context<B>(new B()).GetList();
            }
        }

[devmiao]

更改引用类型不会对对象本身造成任何改变。 好比你将你的笔记本电脑“视作”电脑，或者视作一个物体，它本身不会因此而有改变一样。

[秋小姐]

引用 3 楼 hdhai9451 的回复:

子类父类和继续承关系的,转换后不会有丢失,放心就是了

那我可能需要怀疑1个问题。 如果是在remoting，我们清楚List<T> 无法通过remoting传递，因为它不可序列化，但是如果转型为IEnumerable<T> 则能够发送，因此我认为，在必要的情况下，.NET仍会对其进行必要的转换与舍弃

[秋小姐]

引用 6 楼 devmiao 的回复:

更改引用类型不会对对象本身造成任何改变。 好比你将你的笔记本电脑“视作”电脑，或者视作一个物体，它本身不会因此而有改变一样。

求回复#7

[youzelin]

引用 8 楼 oQiuXiaoJie 的回复:

[quote=引用 6 楼 devmiao 的回复:] 更改引用类型不会对对象本身造成任何改变。 好比你将你的笔记本电脑“视作”电脑，或者视作一个物体，它本身不会因此而有改变一样。

求回复#7[/quote] 我给你的不是 IEnumberable<T> 的版本吗？这不就不需要考虑 Remoting 的问题了吗？