AddRange a uma coleção

Um colega de trabalho me perguntou hoje como adicionar um intervalo a uma coleção. Ele tem uma classe que herda Collection<T>. Há uma propriedade get-only desse tipo que já contém alguns itens. Ele deseja adicionar os itens de outra coleção à coleção de propriedades. Como ele pode fazer isso de uma forma amigável com C # 3? (Observe a restrição sobre a propriedade get-only, que impede soluções como fazer Union e reatribuir.)

Claro, um foreach com Property. Adicionar funcionará. Mas um List<T>AddRange no estilo seria muito mais elegante.

É fácil escrever um método de extensão:

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

Mas tenho a sensação de que estou reinventando a roda. Não encontrei nada semelhante em System.Linqou morelinq .

Design ruim? Basta ligar para adicionar? Perdendo o óbvio?

Não, isso parece perfeitamente razoável. Existe um método List<T>.AddRange () que basicamente faz exatamente isso, mas requer que sua coleção seja concreta List<T>.

Tente lançar em List no método de extensão antes de executar o loop. Dessa forma, você pode aproveitar o desempenho 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);
        }
    }
}

Já que .NET4.5se você quiser uma linha, você pode usar System.Collections.GenericForEach.

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

ou ainda mais curto como

source.ForEach(destination.Add);

Em termos de desempenho, é o mesmo que para cada loop (açúcar sintático).

Também não tente atribuí-lo como

var x = source.ForEach(destination.Add) 

a causa ForEaché nula.

Edit: Copiado de comentários, opinião de Lipert sobre ForEach

Lembre-se de que cada Addum verificará a capacidade da coleção e a redimensionará sempre que necessário (mais lento). Com AddRange, a coleção será definida a capacidade e, em seguida, adicionados os itens (mais rápido). Este método de extensão será extremamente lento, mas funcionará.

Aqui está uma versão um pouco mais avançada / pronta para produção:

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

Todas as classes C5 Generic Collections Library suportam o AddRangemétodo. C5 tem uma interface muito mais robusta que realmente expõe todos os recursos de suas implementações subjacentes e é compatível com as interfaces System.Collections.Generic ICollectione IList, o que significa que C5as coleções podem ser facilmente substituídas como a implementação subjacente.

Você pode adicionar seu intervalo IEnumerable a uma lista e definir ICollection = para a lista.

        IEnumerable<T> source;

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

        ICollection<item> destination = list;

Ou você pode apenas fazer uma extensão ICollection como esta:

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

        return @this;
    }

Usá-lo seria como usá-lo em uma lista:

collectionA.AddRange(IEnumerable<object> items);