Converter lista em dicionário usando linq e não se preocupar com duplicatas

Eu tenho uma lista de objetos Pessoa. Quero converter para um dicionário em que a chave seja o nome e o sobrenome (concatenados) e o valor seja o objeto Pessoa.

O problema é que eu tenho algumas pessoas duplicadas, então isso explode se eu usar este código:

private Dictionary<string, Person> _people = new Dictionary<string, Person>();

_people = personList.ToDictionary(
    e => e.FirstandLastName,
    StringComparer.OrdinalIgnoreCase);

Sei que parece estranho, mas não me preocupo com nomes duplicados por enquanto. Se houver vários nomes, eu só quero pegar um. Existe alguma maneira que eu possa escrever esse código acima, então ele pega um dos nomes e não explode em duplicatas?

Aqui está a solução óbvia e não linq:

foreach(var person in personList)
{
  if(!myDictionary.Keys.Contains(person.FirstAndLastName))
    myDictionary.Add(person.FirstAndLastName, person);
}

Solução LINQ:

// Use the first value in group
var _people = personList
    .GroupBy(p => p.FirstandLastName, StringComparer.OrdinalIgnoreCase)
    .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);

// Use the last value in group
var _people = personList
    .GroupBy(p => p.FirstandLastName, StringComparer.OrdinalIgnoreCase)
    .ToDictionary(g => g.Key, g => g.Last(), StringComparer.OrdinalIgnoreCase);

Se você preferir uma solução não-LINQ, poderá fazer algo assim:

// Use the first value in list
var _people = new Dictionary<string, Person>(StringComparer.OrdinalIgnoreCase);
foreach (var p in personList)
{
    if (!_people.ContainsKey(p.FirstandLastName))
        _people[p.FirstandLastName] = p;
}

// Use the last value in list
var _people = new Dictionary<string, Person>(StringComparer.OrdinalIgnoreCase);
foreach (var p in personList)
{
    _people[p.FirstandLastName] = p;
}

Uma solução Linq usando Distinct () e sem agrupamento é:

var _people = personList
    .Select(item => new { Key = item.Key, FirstAndLastName = item.FirstAndLastName })
    .Distinct()
    .ToDictionary(item => item.Key, item => item.FirstFirstAndLastName, StringComparer.OrdinalIgnoreCase);

Não sei se é melhor que a solução de LukeH, mas também funciona.

Isso deve funcionar com a expressão lambda:

personList.Distinct().ToDictionary(i => i.FirstandLastName, i => i);

Você também pode usar a ToLookupfunção LINQ, que você pode usar quase de forma intercambiável com um dicionário.

_people = personList
    .ToLookup(e => e.FirstandLastName, StringComparer.OrdinalIgnoreCase);
_people.ToDictionary(kl => kl.Key, kl => kl.First()); // Potentially unnecessary

Isso fará essencialmente o GroupBy na resposta de LukeH , mas fornecerá o hash que um Dicionário fornece. Portanto, você provavelmente não precisará convertê-lo em um dicionário, mas use a Firstfunção LINQ sempre que precisar acessar o valor da chave.

Você pode criar um método de extensão semelhante ao ToDictionary (), com a diferença de que ele permite duplicatas. Algo como:

    public static Dictionary<TKey, TElement> SafeToDictionary<TSource, TKey, TElement>(
        this IEnumerable<TSource> source, 
        Func<TSource, TKey> keySelector, 
        Func<TSource, TElement> elementSelector, 
        IEqualityComparer<TKey> comparer = null)
    {
        var dictionary = new Dictionary<TKey, TElement>(comparer);

        if (source == null)
        {
            return dictionary;
        }

        foreach (TSource element in source)
        {
            dictionary[keySelector(element)] = elementSelector(element);
        }

        return dictionary; 
    }

Nesse caso, se houver duplicatas, o último valor vence.

Para lidar com a eliminação de duplicatas, implemente uma IEqualityComparer<Person>que possa ser usada no Distinct()método e obter o seu dicionário será fácil. Dado:

class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.FirstAndLastName.Equals(y.FirstAndLastName, StringComparison.OrdinalIgnoreCase);
    }

    public int GetHashCode(Person obj)
    {
        return obj.FirstAndLastName.ToUpper().GetHashCode();
    }
}

class Person
{
    public string FirstAndLastName { get; set; }
}

Obtenha seu dicionário:

List<Person> people = new List<Person>()
{
    new Person() { FirstAndLastName = "Bob Sanders" },
    new Person() { FirstAndLastName = "Bob Sanders" },
    new Person() { FirstAndLastName = "Jane Thomas" }
};

Dictionary<string, Person> dictionary =
    people.Distinct(new PersonComparer()).ToDictionary(p => p.FirstAndLastName, p => p);

        DataTable DT = new DataTable();
        DT.Columns.Add("first", typeof(string));
        DT.Columns.Add("second", typeof(string));

        DT.Rows.Add("ss", "test1");
        DT.Rows.Add("sss", "test2");
        DT.Rows.Add("sys", "test3");
        DT.Rows.Add("ss", "test4");
        DT.Rows.Add("ss", "test5");
        DT.Rows.Add("sts", "test6");

        var dr = DT.AsEnumerable().GroupBy(S => S.Field<string>("first")).Select(S => S.First()).
            Select(S => new KeyValuePair<string, string>(S.Field<string>("first"), S.Field<string>("second"))).
           ToDictionary(S => S.Key, T => T.Value);

        foreach (var item in dr)
        {
            Console.WriteLine(item.Key + "-" + item.Value);
        }

Caso desejemos toda a Pessoa (em vez de apenas uma Pessoa) no dicionário retornado, poderíamos:

var _people = personList
.GroupBy(p => p.FirstandLastName)
.ToDictionary(g => g.Key, g => g.Select(x=>x));

O problema com a maioria das outras respostas é que elas usam Distinct, GroupByou ToLookup, o que cria um dicionário extra sob o capô. Igualmente, o ToUpper cria uma sequência extra. Foi o que fiz, que é uma cópia quase exata do código da Microsoft, exceto por uma alteração:

    public static Dictionary<TKey, TSource> ToDictionaryIgnoreDup<TSource, TKey>
        (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer = null) =>
        source.ToDictionaryIgnoreDup(keySelector, i => i, comparer);

    public static Dictionary<TKey, TElement> ToDictionaryIgnoreDup<TSource, TKey, TElement>
        (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer = null)
    {
        if (keySelector == null)
            throw new ArgumentNullException(nameof(keySelector));
        if (elementSelector == null)
            throw new ArgumentNullException(nameof(elementSelector));
        var d = new Dictionary<TKey, TElement>(comparer ?? EqualityComparer<TKey>.Default);
        foreach (var element in source)
            d[keySelector(element)] = elementSelector(element);
        return d;
    }

Como um conjunto no indexador faz com que ele adicione a chave, ele não será acionado e também fará apenas uma pesquisa de chave. Você também pode fornecer IEqualityComparer, por exemploStringComparer.OrdinalIgnoreCase

A partir da solução de Carra, você também pode escrevê-lo como:

foreach(var person in personList.Where(el => !myDictionary.ContainsKey(el.FirstAndLastName)))
{
    myDictionary.Add(person.FirstAndLastName, person);
}