这是对BigJim的精彩回答的延伸。

在我的例子中，我有一个带有子字典的NodeBase类，我需要一种方法来从子字典中进行O(1)查询。我试图在Children的getter中返回一个私有字典字段，所以显然我想避免昂贵的复制/迭代。因此，我使用Bigjim的代码将Dictionary<whatever特定类型>转换为generic Dictionary<NodeBase>:

// Abstract parent class
public abstract class NodeBase
{
    public abstract IDictionary<string, NodeBase> Children { get; }
    ...
}

// Implementing child class
public class RealNode : NodeBase
{
    private Dictionary<string, RealNode> containedNodes;

    public override IDictionary<string, NodeBase> Children
    {
        // Using a modification of Bigjim's code to cast the Dictionary:
        return new IDictionary<string, NodeBase>().CastDictionary<string, RealNode, NodeBase>();
    }
    ...
}

这很有效。然而，我最终遇到了不相关的限制，并最终在基类中创建了一个抽象的FindChild()方法来代替它进行查找。事实证明，这从一开始就消除了对强制转换字典的需求。(出于我的目的，我可以用一个简单的IEnumerable替换它。)

所以你可能会问的问题(特别是当性能问题禁止你使用.Cast<>或.ConvertAll<>)是:

“我真的需要强制转换整个集合吗?或者我可以使用抽象方法来保存执行任务所需的特殊知识，从而避免直接访问集合吗?”

有时候最简单的解决方案就是最好的。

只能强制转换为只读列表。例如:

IEnumerable<A> enumOfA = new List<C>();//This works
IReadOnlyCollection<A> ro_colOfA = new List<C>();//This works
IReadOnlyList<A> ro_listOfA = new List<C>();//This works

对于支持保存元素的列表，不能这样做。原因是:

List<string> listString=new List<string>();
List<object> listObject=(List<object>)listString;//Assume that this is possible
listObject.Add(new object());

现在该做什么?记住listObject和listString实际上是同一个列表，所以listString现在有object元素，这应该是不可能的。

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

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

你也可以使用Linq:

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

我个人喜欢创建带有类扩展的类库

public static List<TTo> Cast<TFrom, TTo>(List<TFrom> fromlist)
  where TFrom : class 
  where TTo : class
{
  return fromlist.ConvertAll(x => x as TTo);
}

至于为什么它不起作用，理解协方差和逆变可能会有所帮助。

只是为了说明为什么这不能工作，这里是对您提供的代码的更改:

void DoesThisWork()
{
     List<C> DerivedList = new List<C>();
     List<A> BaseList = DerivedList;
     BaseList.Add(new B());

     C FirstItem = DerivedList.First();
}

这可行吗?列表中的第一个项是类型“B”，但派生列表项的类型是C。

现在，假设我们真的只想创建一个泛型函数，它对实现了a的某个类型的列表进行操作，但我们不关心它是什么类型:

void ThisWorks<T>(List<T> GenericList) where T:A
{

}

void Test()
{
     ThisWorks(new List<B>());
     ThisWorks(new List<C>());
}

你也可以使用System.Runtime.CompilerServices.Unsafe NuGet包来创建同一个列表的引用:

using System.Runtime.CompilerServices;
...
class Tool { }
class Hammer : Tool { }
...
var hammers = new List<Hammer>();
...
var tools = Unsafe.As<List<Tool>>(hammers);

对于上面的示例，您可以使用tools变量访问列表中现有的Hammer实例。将Tool实例添加到列表中会抛出ArrayTypeMismatchException异常，因为tools引用了与hammers相同的变量。