Por que o Dicionário não tem AddRange?

O título é básico o suficiente, por que não posso:

Dictionary<string, string> dic = new Dictionary<string, string>();
dic.AddRange(MethodThatReturnAnotherDic());

Um comentário à pergunta original resume isso muito bem:

porque ninguém jamais projetou, especificou, implementou, testou, documentou e enviou esse recurso. - @Gabe Moothart

Por quê? Bem, provavelmente porque o comportamento de mesclar dicionários não pode ser fundamentado de uma maneira que se encaixe nas diretrizes do Framework.

AddRangenão existe porque um intervalo não tem nenhum significado para um contêiner associativo, já que o intervalo de dados permite entradas duplicadas. Por exemplo, se você tinha uma IEnumerable<KeyValuePair<K,T>>coleção, isso não protege contra entradas duplicadas.

O comportamento de adicionar uma coleção de pares de valores-chave ou mesmo mesclar dois dicionários é direto. O comportamento de como lidar com várias entradas duplicadas, no entanto, não é.

Qual deve ser o comportamento do método ao lidar com uma duplicata?

Posso pensar em pelo menos três soluções:

1. lançar uma exceção para a primeira entrada que é uma duplicata
2. lançar uma exceção que contém todas as entradas duplicadas
3. Ignorar duplicatas

Quando uma exceção é lançada, qual deve ser o estado do dicionário original?

Addquase sempre é implementado como uma operação atômica: é bem-sucedido e atualiza o estado da coleção, ou falha, e o estado da coleção permanece inalterado. Como AddRangepode falhar devido a erros duplicados, a maneira de manter seu comportamento consistente com Addseria também torná-lo atômico, lançando uma exceção em qualquer duplicata, e deixar o estado do dicionário original inalterado.

Como um consumidor de API, seria tedioso ter que remover iterativamente os elementos duplicados, o que implica que o AddRangedeve lançar uma única exceção que contém todos os valores duplicados.

A escolha então se resume a:

1. Lance uma exceção com todas as duplicatas, deixando o dicionário original sozinho.
2. Ignore duplicatas e prossiga.

Existem argumentos para apoiar os dois casos de uso. Para fazer isso, você adiciona um IgnoreDuplicatessinalizador à assinatura?

O IgnoreDuplicatessinalizador (quando definido como verdadeiro) também forneceria uma velocidade significativa, pois a implementação subjacente ignoraria o código para verificação duplicada.

Agora, você tem um sinalizador que permite que o AddRangesuporte ambos os casos, mas tem um efeito colateral não documentado (que é algo que os designers do Framework trabalharam muito para evitar).

Resumo

Como não há um comportamento claro, consistente e esperado quando se trata de lidar com duplicatas, é mais fácil não lidar com todas elas juntas e não fornecer o método para começar.

Se você está continuamente tendo que mesclar dicionários, pode, é claro, escrever seu próprio método de extensão para mesclar dicionários, que se comportará de uma maneira que funcione para seu (s) aplicativo (s).

Eu tenho alguma solução:

Dictionary<string, string> mainDic = new Dictionary<string, string>() { 
    { "Key1", "Value1" },
    { "Key2", "Value2.1" },
};
Dictionary<string, string> additionalDic= new Dictionary<string, string>() { 
    { "Key2", "Value2.2" },
    { "Key3", "Value3" },
};
mainDic.AddRangeOverride(additionalDic); // Overrides all existing keys
// or
mainDic.AddRangeNewOnly(additionalDic); // Adds new keys only
// or
mainDic.AddRange(additionalDic); // Throws an error if keys already exist
// or
if (!mainDic.ContainsKeys(additionalDic.Keys)) // Checks if keys don't exist
{
    mainDic.AddRange(additionalDic);
}

...

namespace MyProject.Helper
{
  public static class CollectionHelper
  {
    public static void AddRangeOverride<TKey, TValue>(this IDictionary<TKey, TValue> dic, IDictionary<TKey, TValue> dicToAdd)
    {
        dicToAdd.ForEach(x => dic[x.Key] = x.Value);
    }

    public static void AddRangeNewOnly<TKey, TValue>(this IDictionary<TKey, TValue> dic, IDictionary<TKey, TValue> dicToAdd)
    {
        dicToAdd.ForEach(x => { if (!dic.ContainsKey(x.Key)) dic.Add(x.Key, x.Value); });
    }

    public static void AddRange<TKey, TValue>(this IDictionary<TKey, TValue> dic, IDictionary<TKey, TValue> dicToAdd)
    {
        dicToAdd.ForEach(x => dic.Add(x.Key, x.Value));
    }

    public static bool ContainsKeys<TKey, TValue>(this IDictionary<TKey, TValue> dic, IEnumerable<TKey> keys)
    {
        bool result = false;
        keys.ForEachOrBreak((x) => { result = dic.ContainsKey(x); return result; });
        return result;
    }

    public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
    {
        foreach (var item in source)
            action(item);
    }

    public static void ForEachOrBreak<T>(this IEnumerable<T> source, Func<T, bool> func)
    {
        foreach (var item in source)
        {
            bool result = func(item);
            if (result) break;
        }
    }
  }
}

Diverta-se.

Caso alguém se depare com esta questão como eu - é possível obter "AddRange" usando os métodos de extensão IEnumerable:

var combined =
    dict1.Union(dict2)
        .GroupBy(kvp => kvp.Key)
        .Select(grp => grp.First())
        .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

O principal truque ao combinar dicionários é lidar com as chaves duplicadas. No código acima é a parte .Select(grp => grp.First()). Nesse caso, ele simplesmente pega o primeiro elemento do grupo de duplicatas, mas você pode implementar uma lógica mais sofisticada lá, se necessário.

Meu palpite é a falta de saída adequada para o usuário quanto ao que aconteceu. Como você não pode ter chaves repetidas em um dicionário, como você lidaria com a fusão de dois dicionários onde algumas chaves se cruzam? Claro, você poderia dizer: "Não me importo", mas isso está quebrando a convenção de retornar false / lançar uma exceção para teclas repetidas.

Você poderia fazer isso

Dictionary<string, string> dic = new Dictionary<string, string>();
// dictionary other items already added.
MethodThatReturnAnotherDic(dic);

public void MethodThatReturnAnotherDic(Dictionary<string, string> dic)
{
    dic.Add(.., ..);
}

ou use uma lista para adicionar intervalo e / ou usando o padrão acima.

List<KeyValuePair<string, string>>

Se você estiver lidando com um novo Dicionário (e não tiver linhas existentes para perder), você sempre pode usar ToDictionary () de outra lista de objetos.

Então, no seu caso, você faria algo assim:

Dictionary<string, string> dic = new Dictionary<string, string>();
dic = SomeList.ToDictionary(x => x.Attribute1, x => x.Attribute2);

Se você sabe que não terá chaves duplicadas, pode fazer:

dic = dic.Union(MethodThatReturnAnotherDic()).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

Ele lançará uma exceção se houver um par de chave / valor duplicado.

Não sei por que isso não está na estrutura; deveria estar. Não há incerteza; apenas lance uma exceção. No caso desse código, ele lança uma exceção.

Sinta-se à vontade para usar o método de extensão como este:

public static Dictionary<T, U> AddRange<T, U>(this Dictionary<T, U> destination, Dictionary<T, U> source)
{
  if (destination == null) destination = new Dictionary<T, U>();
  foreach (var e in source)
    destination.Add(e.Key, e.Value);
  return destination;
}

Aqui está uma solução alternativa usando c # 7 ValueTuples (literais de tupla)

public static class DictionaryExtensions
{
    public static Dictionary<TKey, TValue> AddRange<TKey, TValue>(this Dictionary<TKey, TValue> source,  IEnumerable<ValueTuple<TKey, TValue>> kvps)
    {
        foreach (var kvp in kvps)
            source.Add(kvp.Item1, kvp.Item2);

        return source;
    }

    public static void AddTo<TKey, TValue>(this IEnumerable<ValueTuple<TKey, TValue>> source, Dictionary<TKey, TValue> target)
    {
        target.AddRange(source);
    }
}

Usado como

segments
    .Zip(values, (s, v) => (s.AsSpan().StartsWith("{") ? s.Trim('{', '}') : null, v))
    .Where(zip => zip.Item1 != null)
    .AddTo(queryParams);

Como outros mencionaram, o motivo pelo qual Dictionary<TKey,TVal>.AddRangenão foi implementado é porque existem várias maneiras de lidar com casos em que há duplicatas. Este é também o caso para Collectionou interfaces, tais como IDictionary<TKey,TVal>, ICollection<T>, etc.

Apenas o List<T>implementa, e você notará que a IList<T>interface não, pelos mesmos motivos: o esperado comportamento ao adicionar um intervalo de valores a uma coleção pode variar amplamente, dependendo do contexto.

O contexto de sua pergunta sugere que você não está preocupado com duplicatas e, nesse caso, você tem uma alternativa simples de uma linha, usando o Linq:

MethodThatReturnAnotherDic().ToList.ForEach(kvp => dic.Add(kvp.Key, kvp.Value));