Comprendre la covariance et les limitations ilist

La covariance est un principe de programmation où un type de référence peut être attribué à une variable d'une base ou d'une interface taper. Cependant, cela pose un dilemme en ce qui concerne les collections, en particulier lorsque nous considérons l'interface ILIST.

Ilist représente une collection avec un accès indexé, nous permettant de récupérer des éléments par leur index. Unfortunately, built-in .NET collections like List implement both the get and set indexers, which prevents them from being fully covariant.

Solutions for Covariant Collections with Indexed Access

Malgré cette limitation, il existe des moyens d'atteindre le comportement covariant tout en maintenant un accès indexé.

1. ReadonlyCollections (de .net 4.5 en arrière)

ireadonlyList et ireadonlycollection sont des interfaces covariantes introduites dans .net 4.5. Ils n'ont qu'un indexeur Get, ce qui les rend adaptés aux scénarios covariants. Liste et ReadOnlyCollection Implémentez les deux interfaces.

2. Wrapper personnalisé

Si vous avez besoin d'une collection covariante avec un accès indexé dans les versions antérieures de .net, vous pouvez créer une classe de wrapper. La classe wrapper résumerait un ILIST et exposerait uniquement les interfaces indexer et ienumerable .

Le code suivant démontre une classe de wrapper personnalisée nommée CovariantList qui fournit un accès covariant à une ilst :

public static class Covariance
{
    public static IIndexedEnumerable AsCovariant(this IList tail)
    {
        return new CovariantList(tail);
    }

    private class CovariantList : IIndexedEnumerable
    {
        private readonly IList tail;

        public CovariantList(IList tail)
        {
            this.tail = tail;
        }

        public T this[int index] { get { return tail[index]; } }
        public IEnumerator GetEnumerator() { return tail.GetEnumerator();}
        IEnumerator IEnumerable.GetEnumerator() { return tail.GetEnumerator(); }
        public int Count { get { return tail.Count; } }
    }
}

public interface IIndexedEnumerable : IEnumerable
{
    T this[int index] { get; }
    int Count { get; }
}