AddRange à une collection

Un collègue m'a demandé aujourd'hui comment ajouter une gamme à une collection. Il a une classe qui hérite de Collection<T>. Il existe une propriété get-only de ce type qui contient déjà certains éléments. Il souhaite ajouter les éléments d'une autre collection à la collection de propriétés. Comment peut-il le faire de manière conviviale C # 3? (Notez la contrainte concernant la propriété get-only, qui empêche des solutions telles que faire Union et réaffecter.)

Bien sûr, un foreach avec la propriété. L'ajout fonctionnera. Mais un List<T>style AddRange serait beaucoup plus élégant.

Il est assez facile d'écrire une méthode d'extension:

public static class CollectionHelpers
{
    public static void AddRange<T>(this ICollection<T> destination,
                                   IEnumerable<T> source)
    {
        foreach (T item in source)
        {
            destination.Add(item);
        }
    }
}

Mais j'ai le sentiment de réinventer la roue. Je n'ai rien trouvé de similaire dans System.Linqou morelinq .

Mauvaise conception? Appelez simplement Ajouter? Vous manquez l'évidence?

Non, cela semble parfaitement raisonnable. Il existe une méthode List<T>.AddRange () qui fait exactement cela, mais nécessite que votre collection soit un béton List<T>.

Essayez de lancer un cast en List dans la méthode d'extension avant d'exécuter la boucle. De cette façon, vous pouvez profiter des performances de List.AddRange.

public static void AddRange<T>(this ICollection<T> destination,
                               IEnumerable<T> source)
{
    List<T> list = destination as List<T>;

    if (list != null)
    {
        list.AddRange(source);
    }
    else
    {
        foreach (T item in source)
        {
            destination.Add(item);
        }
    }
}

Puisque .NET4.5si vous voulez une seule ligne, vous pouvez utiliser System.Collections.GenericForEach.

source.ForEach(o => destination.Add(o));

ou même plus court que

source.ForEach(destination.Add);

En termes de performances, c'est la même chose que pour chaque boucle (sucre syntaxique).

Aussi n'essayez d' affecter comme

var x = source.ForEach(destination.Add) 

la cause ForEachest nulle.

Edit: Copié à partir des commentaires, l'opinion de Lipert sur ForEach

N'oubliez pas que chacun Addvérifiera la capacité de la collection et la redimensionnera chaque fois que nécessaire (plus lentement). Avec AddRange, la collection sera définie la capacité, puis ajouté les éléments (plus rapide). Cette méthode d'extension sera extrêmement lente, mais fonctionnera.

Voici une version un peu plus avancée / prête pour la production:

    public static class CollectionExtensions
    {
        public static TCol AddRange<TCol, TItem>(this TCol destination, IEnumerable<TItem> source)
            where TCol : ICollection<TItem>
        {
            if(destination == null) throw new ArgumentNullException(nameof(destination));
            if(source == null) throw new ArgumentNullException(nameof(source));

            // don't cast to IList to prevent recursion
            if (destination is List<TItem> list)
            {
                list.AddRange(source);
                return destination;
            }

            foreach (var item in source)
            {
                destination.Add(item);
            }

            return destination;
        }
    }

Les classes de la bibliothèque de collections génériques C5 prennent toutes en charge la AddRangeméthode. C5 a une interface beaucoup plus robuste qui expose en fait toutes les fonctionnalités de ses implémentations sous-jacentes et est compatible avec les interfaces System.Collections.Generic ICollectionet IList, ce qui signifie que C5les collections de s peuvent être facilement remplacées comme implémentation sous-jacente.

Vous pouvez ajouter votre plage IEnumerable à une liste, puis définir ICollection = sur la liste.

        IEnumerable<T> source;

        List<item> list = new List<item>();
        list.AddRange(source);

        ICollection<item> destination = list;

Ou vous pouvez simplement créer une extension ICollection comme ceci:

 public static ICollection<T> AddRange<T>(this ICollection<T> @this, IEnumerable<T> items)
    {
        foreach(var item in items)
        {
            @this.Add(item);
        }

        return @this;
    }

L'utiliser serait comme l'utiliser sur une liste:

collectionA.AddRange(IEnumerable<object> items);