使用 linq 将列表转换为字典，而不用担心重复

Question

我有一个 Person 对象列表。我想转换为字典，其中键是名字和姓氏（串联），值是 Person 对象。

问题是我有一些重复的人，所以如果我使用这段代码就会爆炸：

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

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

我知道这听起来很奇怪，但我现在并不真正关心重复名称。如果有多个名字，我只想抓住一个。无论如何我可以在上面编写这段代码，所以它只需要其中一个名称并且不会因重复而爆炸？

Answer 1

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

如果您更喜欢非 LINQ 解决方案，那么您可以这样做：

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

Answer 2

这是显而易见的非 linq 解决方案：

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

如果你不介意总是添加最后一个，你可以避免这样的双重查找：

foreach(var person in personList)
{
    myDictionary[person.FirstAndLastName] = person;
}

Answer 3

使用 Distinct() 且没有分组的 Linq 解决方案是：

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

我不知道它是否比 LukeH 的解决方案更好，但它也很有效。

Answer 4

这应该适用于 lambda 表达式：

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

Answer 5

您还可以使用ToLookup LINQ 函数，然后您几乎可以将其与字典互换使用。

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

这实际上将在LukeH's answer 中执行 GroupBy，但会提供 Dictionary 提供的散列。因此，您可能不需要将其转换为字典，只需在需要访问键值时使用 LINQ First 函数即可。

Answer 6

您可以创建类似于 ToDictionary() 的扩展方法，不同之处在于它允许重复。比如：

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

在这种情况下，如果有重复，则最后一个值获胜。

Answer 7

要处理消除重复，实现一个IEqualityComparer<Person> 可以在Distinct() 方法中使用，然后获取您的字典将很容易。 给定：

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

获取你的字典：

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

Answer 8

如果我们想要返回字典中的所有 Person（而不是只有一个 Person），我们可以：

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

Answer 9

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

Answer 10

大多数其他答案的问题是他们使用Distinct、GroupBy 或ToLookup，这会在后台创建一个额外的字典。同样 ToUpper 创建额外的字符串。 这就是我所做的，除了一个更改之外，它几乎是 Microsoft 代码的完全相同的副本：

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

因为索引器上的一个集合导致它添加键，它不会抛出，并且也只会进行一次键查找。你也可以给它一个IEqualityComparer，例如StringComparer.OrdinalIgnoreCase

Answer 11

使用 LINQ 的 foldLeft 等效功能

persons.Aggregate(new Dictionary<string,Person>(StringComparer.OrdinalIgnoreCase),
  (acc, current) => { 
    acc[current.FirstAndLastName] = current; 
    return acc; 
  }); 

Answer 12

从 Carra 的解决方案开始，你也可以这样写：

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