Comment puis-je obtenir une covariance avec l'accès aux index dans les collections .NET ?

Exploiter Covariance avec la prise en charge de l'accès aux index dans .NET

Covariance permet aux programmeurs de traiter les classes dérivées comme classes de base sans conversion de type explicite. Cependant, dans .NET, il existe une limitation avec les collections covariantes qui ne prennent pas en charge l'accès aux index. Ce problème survient lorsque vous tentez de convertir une collection de types spécifiques (par exemple, une liste contenant des objets Dog) en une collection de leur type de base (par exemple, Animal).

Comprendre le problème sous-jacent

Le problème vient du fait que List implémente ICollection, qui comprend une méthode Add. La diffusion vers une IList basée sur les animaux permettrait l'ajout sans discernement de tout type d'animal, violant les contraintes de type de la collection d'origine.

Collections covariantes avec prise en charge d'index

Dans .NET 4.5 et plus tard :

• IReadOnlyList et IReadOnlyCollection sont tous deux covariants.
• List implémentez ces interfaces, en fournissant un indexeur en lecture seule capable de récupérer des éléments sans violer les principes de covariance.

Pour les versions antérieures de .NET :

• Covariance avec prise en charge des index n'est pas disponible nativement dans les versions antérieures de .NET.
• Wrapper personnalisé Approche : Une solution consiste à envelopper la collection d'origine dans une classe personnalisée qui expose uniquement les interfaces IEnumerable et get indexer. Cette approche garantit la covariance tout en conservant la fonctionnalité d'accès à l'index.

Mise en œuvre :

Le code C# suivant illustre l'approche du wrapper personnalisé à l'aide de la méthode d'extension Covariance :

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

Cette méthode d'extension vous permet de créer une collection covariante avec prise en charge des index, comme le montre ce qui suit exemple :

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

IIndexedEnumerable<Animal> animals = dogs.AsCovariant();

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!