协变和IList

Question

我想要一个Covariant集合，其中的项目可以通过索引检索。 IEnumerable是我知道的唯一一个.net集合，它是Covariant，但它没有这个索引支持。

具体来说，我想这样做：

List<Dog> dogs = new List<Dog>(); 

IEnumerable<Animal> animals = dogs; 
IList<Animal> animalList = dogs; // This line does not compile 

现在，我知道为什么这是一个问题。列表实现了具有Add方法的ICollection。通过向上铸造动物的IList，它将允许随后的代码添加在“真实”List<Dog>集合中不允许的任何类型的动物。

那么是否有人知道支持索引查找的集合也是协变的？我想不创造我自己的。

Answer 1

更新：从.NET 4.5起，有IReadOnlyList<out T>和IReadOnlyCollection<out T>它们都是协变的;后者基本上是IEnumerable<out T>加Count;前者增加T this[int index] {get;}。还应该注意的是，从.NET 4.0起，IEnumerable<out T>是协变的。

List<T>和ReadOnlyCollection<T>（通过List<T>.AsReadOnly()）实现这两个。

---

，如果它只有一个get索引它只能被协变，即

public T this[int index] { get; } 

但所有主要收藏有{get;set;}，这使得这种尴尬的。我不知道有任何这就够了那里，但你可以包它，即编写扩展方法：

var covariant = list.AsCovariant(); 

这是一个IList<T>周围的包装，只有公开IEnumerable<T>和get索引。 ..？应该只有几分钟的工作...

public static class Covariance 
{ 
    public static IIndexedEnumerable<T> AsCovariant<T>(this IList<T> tail) 
    { 
     return new CovariantList<T>(tail); 
    } 
    private class CovariantList<T> : IIndexedEnumerable<T> 
    { 
     private readonly IList<T> tail; 
     public CovariantList(IList<T> tail) 
     { 
      this.tail = tail; 
     } 
     public T this[int index] { get { return tail[index]; } } 
     public IEnumerator<T> GetEnumerator() { return tail.GetEnumerator();} 
     IEnumerator IEnumerable.GetEnumerator() { return tail.GetEnumerator(); } 
     public int Count { get { return tail.Count; } } 
    } 
} 
public interface IIndexedEnumerable<out T> : IEnumerable<T> 
{ 
    T this[int index] { get; } 
    int Count { get; } 
} 

Answer 2

从技术上讲，这是数组集合。它的差异有点不一样，但它确实符合你的要求。

IList<Animal> animals; 
List<Dog> dogs = new List<Dog>(); 
animals = dogs.ToArray(); 

你会的，当然，炸毁而壮观地在运行时，如果你试图把阵列中的任何地方Tiger。

Answer 3

这里有一类我写来解决这样的情景：

public class CovariantIListAdapter<TBase, TDerived> : IList<TBase> 
    where TDerived : TBase 
{ 
    private IList<TDerived> source; 

    public CovariantIListAdapter(IList<TDerived> source) 
    { 
     this.source = source; 
    } 

    public IEnumerator<TBase> GetEnumerator() 
    { 
     foreach (var item in source) 
      yield return item; 
    } 

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

    public void Add(TBase item) 
    { 
     source.Add((TDerived) item); 
    } 

    public void Clear() 
    { 
     source.Clear(); 
    } 

    public bool Contains(TBase item) 
    { 
     return source.Contains((TDerived) item); 
    } 

    public void CopyTo(TBase[] array, int arrayIndex) 
    { 
     foreach (var item in source) 
      array[arrayIndex++] = item; 
    } 

    public bool Remove(TBase item) 
    { 
     return source.Remove((TDerived) item); 
    } 

    public int Count 
    { 
     get { return source.Count; } 
    } 

    public bool IsReadOnly 
    { 
     get { return source.IsReadOnly; } 
    } 

    public int IndexOf(TBase item) 
    { 
     return source.IndexOf((TDerived) item); 
    } 

    public void Insert(int index, TBase item) 
    { 
     source.Insert(index, (TDerived) item); 
    } 

    public void RemoveAt(int index) 
    { 
     source.RemoveAt(index); 
    } 

    public TBase this[int index] 
    { 
     get { return source[index]; } 
     set { source[index] = (TDerived) value; } 
    } 
} 

现在你可以这样写代码：

List<Dog> dogs = new List<Dog>(); 
dogs.Add(new Dog { Name = "Spot", MaximumBarkDecibals = 110 }); 

IEnumerable<Animal> animals = dogs; 
IList<Animal> animalList = new CovariantIListAdapter<Animal, Dog>(dogs); 

animalList.Add(new Dog { Name = "Fluffy", MaximumBarkDecibals = 120 }); 

的变化是两个列表中可见，因为没什么仍然只有1名单。适配器类仅传递通话，根据需要投射项目以实现所需的IList<TBase>界面。

很明显，如果你添加了除狗之外的任何东西到animalList，它会抛出一个异常，但这符合我的需求。

Answer 4

从.NET Framework 4.5开始，存在一个接口IReadOnlyList，它是协变的。它与Mark Gravell的答案中的IIndexedEnumerable接口基本相同。

IReadOnlyList实现这样的：

/// <summary> 
    /// Represents a read-only collection of elements that can be accessed by index. 
    /// </summary> 
    /// <typeparam name="T">The type of elements in the read-only list. This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics.</typeparam> 
    public interface IReadOnlyList<out T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable 
     { 
     /// <summary> 
     /// Gets the element at the specified index in the read-only list. 
     /// </summary> 
     /// 
     /// <returns> 
     /// The element at the specified index in the read-only list. 
     /// </returns> 
     /// <param name="index">The zero-based index of the element to get. </param> 
     T this[int index] { get; } 
     }