Comment puis-je obtenir un comportement covariant avec un accès indexé dans les collections .NET ?

Comprendre la covariance et les limitations d'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 lorsqu'il s'agit de collections, notamment lorsque l'on considère 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. Malheureusement, les collections .NET intégrées telles que List implémentez à la fois les indexeurs get et set, ce qui les empêche d'être entièrement covariants.

Solutions pour les collections covariantes avec accès indexé

Malgré cette limitation, il existe des moyens d'y parvenir comportement covariant tout en conservant un accès indexé.

1. ReadOnlyCollections (à partir de .NET 4.5)

IReadOnlyList et IReadOnlyCollection sont des interfaces covariantes introduites dans .NET 4.5. Ils ne disposent que d'un indexeur get, ce qui les rend adaptés aux scénarios covariants. Liste et ReadOnlyCollection implémenter les deux interfaces.

2. Wrapper personnalisé

Si vous avez besoin d'une collection covariante avec accès indexé dans les versions antérieures de .NET, vous pouvez créer une classe wrapper. La classe wrapper encapsulerait un IList et exposez uniquement l'indexeur get et IEnumerable interfaces.

Le code suivant illustre une classe wrapper personnalisée nommée CovariantList qui fournit un accès covariant à un IList :

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; }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!