引用埃里克的伟大解释

会发生什么呢?你想在长颈鹿的名单中包含一只老虎吗?你想撞车吗?或者你希望编译器通过在第一时间使赋值非法来保护你不崩溃? 我们选择后者。

但是，如果希望选择运行时崩溃而不是编译错误，该怎么办呢?你通常会使用Cast<>或ConvertAll<>，但你会有两个问题:它会创建一个列表的副本。如果您在新列表中添加或删除某些内容，这将不会反映在原始列表中。其次，由于它用现有对象创建了一个新列表，因此会损失很大的性能和内存。

我也遇到了同样的问题，因此我创建了一个包装器类，它可以强制转换一个泛型列表，而无需创建一个全新的列表。

在原来的问题中，你可以用:

class Test
{
    static void Main(string[] args)
    {
        A a = new C(); // OK
        IList<A> listOfA = new List<C>().CastList<C,A>(); // now ok!
    }
}

这里是包装器类(+一个扩展方法CastList，便于使用)

public class CastedList<TTo, TFrom> : IList<TTo>
{
    public IList<TFrom> BaseList;

    public CastedList(IList<TFrom> baseList)
    {
        BaseList = baseList;
    }

    // IEnumerable
    IEnumerator IEnumerable.GetEnumerator() { return BaseList.GetEnumerator(); }

    // IEnumerable<>
    public IEnumerator<TTo> GetEnumerator() { return new CastedEnumerator<TTo, TFrom>(BaseList.GetEnumerator()); }

    // ICollection
    public int Count { get { return BaseList.Count; } }
    public bool IsReadOnly { get { return BaseList.IsReadOnly; } }
    public void Add(TTo item) { BaseList.Add((TFrom)(object)item); }
    public void Clear() { BaseList.Clear(); }
    public bool Contains(TTo item) { return BaseList.Contains((TFrom)(object)item); }
    public void CopyTo(TTo[] array, int arrayIndex) { BaseList.CopyTo((TFrom[])(object)array, arrayIndex); }
    public bool Remove(TTo item) { return BaseList.Remove((TFrom)(object)item); }

    // IList
    public TTo this[int index]
    {
        get { return (TTo)(object)BaseList[index]; }
        set { BaseList[index] = (TFrom)(object)value; }
    }

    public int IndexOf(TTo item) { return BaseList.IndexOf((TFrom)(object)item); }
    public void Insert(int index, TTo item) { BaseList.Insert(index, (TFrom)(object)item); }
    public void RemoveAt(int index) { BaseList.RemoveAt(index); }
}

public class CastedEnumerator<TTo, TFrom> : IEnumerator<TTo>
{
    public IEnumerator<TFrom> BaseEnumerator;

    public CastedEnumerator(IEnumerator<TFrom> baseEnumerator)
    {
        BaseEnumerator = baseEnumerator;
    }

    // IDisposable
    public void Dispose() { BaseEnumerator.Dispose(); }

    // IEnumerator
    object IEnumerator.Current { get { return BaseEnumerator.Current; } }
    public bool MoveNext() { return BaseEnumerator.MoveNext(); }
    public void Reset() { BaseEnumerator.Reset(); }

    // IEnumerator<>
    public TTo Current { get { return (TTo)(object)BaseEnumerator.Current; } }
}

public static class ListExtensions
{
    public static IList<TTo> CastList<TFrom, TTo>(this IList<TFrom> list)
    {
        return new CastedList<TTo, TFrom>(list);
    }
}

我已经阅读了整篇文章，我只是想指出对我来说似乎不一致的地方。

编译器阻止你对list执行赋值操作:

List<Tiger> myTigersList = new List<Tiger>() { new Tiger(), new Tiger(), new Tiger() };
List<Animal> myAnimalsList = myTigersList;    // Compiler error

但是编译器完全可以处理数组:

Tiger[] myTigersArray = new Tiger[3] { new Tiger(), new Tiger(), new Tiger() };
Animal[] myAnimalsArray = myTigersArray;    // No problem

关于任务是否安全的争论在这里站不住脚了。我对数组的赋值是不安全的。为了证明这一点，如果我继续这样做:

myAnimalsArray[1] = new Giraffe();

我得到一个运行时异常“ArrayTypeMismatchException”。如何解释这一点呢?如果编译器真的想阻止我做一些愚蠢的事情，它应该阻止我做数组赋值。

因为c#目前不允许这种类型的继承转换。

实现这种工作的方法是遍历列表并强制转换元素。这可以使用ConvertAll:

List<A> listOfA = new List<C>().ConvertAll(x => (A)x);

你也可以使用Linq:

List<A> listOfA = new List<C>().Cast<A>().ToList();

首先，停止使用难以理解的类名，如A, B, c，使用动物，哺乳动物，长颈鹿，或食物，水果，橙子或其他关系清楚的东西。

你的问题是"既然我可以把长颈鹿赋值给动物类型的变量，为什么我不能把长颈鹿的列表赋值给动物类型的变量?"

答案是:假设你可以。那么会出什么问题呢?

嗯，你可以在动物列表中添加一只老虎。假设我们允许您将一个长颈鹿列表放入一个包含动物列表的变量中。然后你试着在名单上加上一只老虎。会发生什么呢?你想在长颈鹿的名单中包含一只老虎吗?你想撞车吗?或者你希望编译器通过在第一时间使赋值非法来保护你不崩溃?

我们选择后者。

这种转换称为“协变”转换。在c# 4中，我们将允许您在接口和委托上进行协变转换，前提是这种转换总是安全的。详见我关于协方差和逆变的博客文章。(这周的周一和周四会有一个新的话题。)

如果你使用IEnumerable代替，它将工作(至少在c# 4.0中，我没有尝试过以前的版本)。这只是一个集合，当然，它仍然是一个列表。

而不是——

List<A> listOfA = new List<C>（）; // 编译器错误

在原代码的问题中，使用-

IEnumerable<A> listOfA = new List<C>();//编译错误-没有更多!：）