只读列表<T>视图和协方差

Question

我想创建一个列表的只读可索引"视图"，只读视图应该枚举到列表类型的接口。

interface IIndexable<out T> : IEnumerable<T>
{
   T this[int i] { get; }
   int Count { get; }
}

使用方案如下所示。

List<Dog> dogs = new List<Dog>[]{ dog1, dog2 }; // Dog implements IAnimal
IIndexable<IAnimal> animals = dogs.AsIIndexable<Dog, IAnimal>();
IAnimal first = animals[0];

我认为在协方差和类型约束的情况下这是可能的，但也许我在这里弄错了。我的第一次尝试看起来像这样，由于枚举器的类型而不起作用。

internal class ListIndexable<TC, T> : IIndexable<T> where TC : T
{
   private List<TC> list;
   public ListIndexable(List<TC> list) { this.list = list; }
   public T this[int i] { get { return list[i]; } }
   public IEnumerator<T> GetEnumerator()
   {
      return list.GetEnumerator(); // Computer says no.
   }
}

为什么我不能将IEnumerator<TC>作为IEnumerator<T>退回？类型是协变的，我用TC：T约束了它。 返回IEnumerator<TC>真的不安全，还是编译器的推理忽略了类型约束只是一个弱点？

我可以通过使用自定义枚举器来解决它，该枚举器包装IEnumerator<TC>并将其项目返回为 T 的，这当然是完全合法的，但我只是好奇为什么上述解决方案不起作用。

internal class ListIndexable<TC, T> : IIndexable<T> where TC : T
{
   private List<TC> list;
   public ListIndexable(List<TC> list) { this.list = list; }
   public T this[int i] { get { return list[i]; } }
   public IEnumerator<T> GetEnumerator()
   {
      return new Enumerator(list.GetEnumerator()); 
   }
   class Enumerator : IEnumerator<T>
   {
      private IEnumerator<TC> inner;
      internal Enumerator(IEnumerator<TC> inner) { this.inner = inner; }
      public bool MoveNext()
      {
         return inner.MoveNext();
      }
      public T Current
      {
         get { return inner.Current; }
      }
      // ...
   }
}

Answer 1

由于值类型的原因，原始代码不起作用。您不能执行以下操作：

IEnumerable<int> ints = new[] { 1, 2 };
IEnumerable<object> os = ints;

因此，编译器不会接受您的定义，因为它无法保证IEnumerable<TC>与一般IEnumerable<T>兼容。如果将class约束添加到T并TC则编译：

internal class ListIndexable<TC, T> : IIndexable<T> where TC : class, T where T : class
{
}

但是，可以仅使用一个类型参数而不是两个类型参数来定义ListIndexable。如果将定义更改为：

internal class ListIndexable<T> : IIndexable<T>
{
   private List<T> list;
   public ListIndexable(List<T> list) { this.list = list; }
   public T this[int i] { get { return list[i]; } }
   public IEnumerator<T> GetEnumerator()
   {
      return list.GetEnumerator();
   }
}

然后你可以做：

IIndexable<IAnimal> animals = dogs.AsIIndexable();

其中AsIndexable可以简单地定义为：

public static ListIndexable<T> AsIndexable<T>(this List<T> list)
{
    return new ListIndexable<T>(list);
}

Answer 2

如果你只需要创建一个只读集合，你可以使用ReadOnlyCollection来包装你的列表，例如：

var dogs = new List<Dog> {new Dog{Name="A"}, new Dog{Name="B"}, new Dog{Name="C"}};
var ro=new ReadOnlyCollection<Dog>(dogs);
IEnumerable<IAnimal> a = ro;