AggiungiRange a una raccolta

Un collega mi ha chiesto oggi come aggiungere un intervallo a una raccolta. Ha una classe che eredita da Collection<T>. Esiste una proprietà di sola ricezione di quel tipo che contiene già alcuni elementi. Vuole aggiungere gli elementi in un'altra raccolta alla raccolta di proprietà. Come può farlo in modo compatibile con C # 3? (Notare il vincolo sulla proprietà get-only, che impedisce soluzioni come l'unione e la riassegnazione.)

Certo, un foreach con Property. Aggiungi funzionerà. Ma un List<T>AddRange in stile sarebbe molto più elegante.

È abbastanza facile scrivere un metodo di estensione:

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

Ma ho la sensazione di reinventare la ruota. Non ho trovato nulla di simile in System.Linqo morelinq .

Cattivo design? Basta chiamare Aggiungi? Manca l'ovvio?

No, questo sembra perfettamente ragionevole. Esiste un metodo List<T>.AddRange () che fondamentalmente fa proprio questo, ma richiede che la tua raccolta sia concreta List<T>.

Prova a trasmettere a List nel metodo di estensione prima di eseguire il ciclo. In questo modo puoi sfruttare le prestazioni di 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);
        }
    }
}

Dal momento che .NET4.5se vuoi una riga puoi usare System.Collections.GenericForEach.

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

o anche più breve come

source.ForEach(destination.Add);

Dal punto di vista delle prestazioni è lo stesso di ogni ciclo (zucchero sintattico).

Inoltre , non provare ad assegnarlo come

var x = source.ForEach(destination.Add) 

la causa ForEachè nulla.

Modifica: copiato dai commenti, l'opinione di Lipert su ForEach

Ricorda che ognuno Addcontrollerà la capacità della raccolta e la ridimensionerà ogni volta che sarà necessario (più lentamente). Con AddRangela raccolta verrà impostata la capacità e quindi aggiunti gli articoli (più velocemente). Questo metodo di estensione sarà estremamente lento, ma funzionerà.

Ecco una versione un po 'più avanzata / pronta per la produzione:

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

Le classi della libreria di raccolte generiche C5 supportano tutte il AddRangemetodo. C5 ha un'interfaccia molto più robusta che espone effettivamente tutte le caratteristiche delle sue implementazioni sottostanti ed è compatibile con le interfacce System.Collections.Generic ICollectione IList, il che significa che C5le raccolte di possono essere facilmente sostituite come implementazione sottostante.

Puoi aggiungere il tuo intervallo IEnumerable a un elenco, quindi impostare ICollection = nell'elenco.

        IEnumerable<T> source;

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

        ICollection<item> destination = list;

Oppure puoi semplicemente creare un'estensione ICollection come questa:

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

        return @this;
    }

Usarlo sarebbe proprio come usarlo in un elenco:

collectionA.AddRange(IEnumerable<object> items);