只是好奇:当然,我们都知道泛型类型推断的一般情况是不可判定的.所以C#根本不做任何类型的子类型:如果Foo <T>是泛型的,Foo <int>不是Foo <T>的子类型,或Foo <Object>或其他任何你可能的类型做饭.当然,我们都用丑陋的界面或抽象类定义来解决这个问题.

但是......如果你无法解决一般性问题,为什么不将解决方案限制在容易的情况下.例如,在上面的列表中,显然Foo <int>是Foo <T>的子类型,并且检查它是微不足道的.检查Foo <Object>是一样的.

如果他们只是说,那么还有其他一些深深的恐怖会从深渊蔓延出来,我们会尽我们所能吗？或者这只是微软语言人员的某种宗教纯洁？

更新:

这是一个非常古老的线程.这些天,C#有var,它解决了我抱怨的一半,然后使用Linq风格的匿名代表,有一个很好的表示法,不需要输入两次相同的东西.因此,我反对的每一个方面都已经通过最近对C#的更改得到了解决(或者我只是花了一些时间来了解我刚发布帖子时刚刚介绍的内容......)我使用这些新内容现在在Isis2系统中可靠的云计算功能(isis2.codeplex.com),我认为该库具有非常干净的外观和感觉.看看它,让我知道你的想法). - Ken Birman(2014年7月)

可能重复:
在C#中,为什么List <string>对象不能存储在List <object>变量中

我有以下代码.

   public class Manufacturer :  IHierarchicalEntity
    {
        public string ManufacturerName
        {
            get
            {
                return _manfuacturerName;
            }
            set
            {
                _manfuacturerName = value;
            }
        } private string _manfuacturerName;

        public List<Product> Products
        {
            get
            {
                return _products;
            }
        } private List<Product> _products;

        #region IHierarchicalEntity Members

        public List<IHierarchicalEntity> Children
        {
            get
            {
                return Products; //This is where I get the compiler error
            }
        }

        #endregion
    }

    public class Product :  IHierarchicalEntity{}

    public interface IHierarchicalEntity
    {
        List<IHierarchicalEntity> Children { get; } …

我有一个通用接口IConstrained,由通用的Constrained类实现.当我尝试执行下面的代码时,我得到一个无效的强制转换异常.

IConstrained<decimal> decimalLimit = new Constrained<decimal>(1);
IConstrained<IComparable> comparableLimit = (IConstrained<IComparable>) decimalLimit;

如果十进制实现IComparable,为什么不能这样做呢？这样做的正确方法是什么？谢谢.

我无法合并列表和列表？OOP说MyType2是MyType ......

using System;
using System.Collections.Generic;

namespace two_list_merge
{
    public class MyType
    {
        private int _attr1 = 0;

        public MyType(int i)
        {
            Attr1 = i;
        }

        public int Attr1
        {
            get { return _attr1; }
            set { _attr1 = value; }
        }
    }

    public class MyType2 : MyType
    {
        private int _attr2 = 0;

        public MyType2(int i, int j)
            : base(i)
        {
            Attr2 = j;
        }

        public int Attr2
        {
            get { return _attr2; }
            set { _attr2 = value; …

可能重复:
在C#中,为什么List <string>对象不能存储在List <object>变量中

我认为这可行:

private List<DateTime> _dateTimes = new List<DateTime>();
private List<String> _strings = new List<String>();

private List<List<Object>> _listOfLists = new List<List<Object>>();

_listOfLists.Add(_dateTimes);
_listOfLists.Add(_strings);

但是,我收到编译器错误,指出.Add方法有一些无效的参数......有人看到了原因吗？而且,具有通用列表列表的解决方案是什么？

我有以下问题(简化).

我有一个狗列表:

public List<Dog> dogs { get; set; }

我目前通过在视图中转换它作为json对象访问此列表:

@(new HtmlString(@Json.Encode(@ViewBag.dogs)))

然后我使用javascript迭代这个json对象并将其显示在页面上.

我想将汽车添加到此列表中.

但是,由于列表是强类型的,因为dogs我首先想到的列表是创建列表作为一件事dogs并cars具有共同点,它们都是对象.

当我试图将我的狗列表更改为列表时objects,我收到以下错误

Cannot implicitly convert type 'System.Collections.Generic.List<object>' to System.Collections.Generic.List<dog>

我对此进行了研究,发现这个问题对我没什么帮助,只是告诉我,我不能列出狗和车.然而,就我的目的而言,这并不合适.我需要我的列表包含狗和汽车,以便我可以在我的应用程序中访问它们.

我预计建议的一个解决方案是我有两个单独的列表,并且发出两个单独的ajax请求.但是,我需要按照特定的顺序混合汽车和狗(基于它们基本上创建的时间),因此解决方案并不理想.

简而言之,我想知道实现这一目标的最佳方法是什么.也许我完全走错了方向,所以如果有意义,我不反对做一些完全不同的事情.

一如既往地感谢您的帮助!

编辑:我已经尝试了演员,这是有效的.但是,我需要访问dog的属性(让我们称之为"fur")并且我似乎无法做到这一点(我是否需要再次投射？)

'object' does not contain a definition for 'fur'

我想我可以传递一个IList<ChildClass>作为IEnumerable<ParentClass>,因为显然在ChildType列表中的每个对象也是ParentType的实例.但是我没有得到编译器的喜爱.我错过了什么？

编辑:添加功能Foo3,它做我想要的.谢谢!

namespace StackOverflow
{
    public class ParentClass
    {
    }

    public class ChildClass : ParentClass
    {
    }

    public class Test
    {
        // works
        static void Foo(ParentClass bar2)
        {
        }

        // fails
        static void Foo2(IEnumerable<ParentClass> bar)
        {
        }

        // EDIT: here's the right answer, obtained from the 
        // Charlie Calvert blog post 
        static void Foo3<T>(IEnumerable<T> bar) where T : ParentClass
        {
        }

        public static void Main()
        {
            var childClassList = new List<ChildClass>();

            // this works as expected …

让我们假设我们有两个类A,B其中B来自A.

class A
{
}

class B : A
{
}

class C<T>
{
}

现在,C<B> 不获得从C<A>.

这让我有点困惑,因为我强调我用A做的"一切",我可以用B做.我确信我错过了一些东西,因为它似乎与OOP的基础相矛盾.

那有什么具体的理由和榜样吗？

编辑:

我读过许多类似的帖子: 在C#中,为什么List <string>对象不能存储在List <object>变量中

当值类型可以相互转换时,为什么我不能将一个值类型的字典转换为另一个值类型的字典？

从IEnumerable <Object>转换为IEnumerable <string>

但是在每个帖子中,答案都集中在特定的类/数据结构中,并使这个特定的代码工作,而不是为什么它一般不可能？

我有用户类列表,但现在我必须将其作为对象列表返回,我尝试转换它,但它给我错误.无法隐式转换.

我只是想知道为什么传递System.Collections.Generic.List<string>到这个功能test(ICollection<object> t)将无法正常工作,我为什么不能将它传递像传递string到test2(object t)？

对我来说没什么意义!