Chuyển đổi danh sách sang từ điển bằng linq và không lo lắng về các bản sao

Tôi có một danh sách các đối tượng Person. Tôi muốn chuyển đổi thành Từ điển trong đó khóa là tên và họ (được nối) và giá trị là đối tượng Person.

Vấn đề là tôi có một số người trùng lặp, vì vậy điều này sẽ nổ tung nếu tôi sử dụng mã này:

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

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

Tôi biết điều này nghe có vẻ kỳ lạ nhưng hiện tại tôi không thực sự quan tâm đến các tên trùng lặp. Nếu có nhiều tên tôi chỉ muốn lấy một cái. Có cách nào tôi có thể viết mã này ở trên để nó chỉ lấy một trong các tên và không nổ tung trên các bản sao không?

Đây là giải pháp rõ ràng, không linq:

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

Giải pháp 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);

Nếu bạn thích một giải pháp không phải LINQ thì bạn có thể làm một cái gì đó như thế này:

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

Một giải pháp Linq sử dụng Phân biệt () và không có nhóm là:

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

Tôi không biết liệu nó có đẹp hơn giải pháp của LukeH hay không nhưng nó cũng hoạt động.

Điều này sẽ làm việc với biểu thức lambda:

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

Bạn cũng có thể sử dụng ToLookupchức năng LINQ, sau đó bạn có thể sử dụng gần như hoán đổi với Từ điển.

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

Điều này về cơ bản sẽ làm GroupBy trong câu trả lời của LukeH , nhưng sẽ đưa ra cách băm mà Từ điển cung cấp. Vì vậy, có lẽ bạn không cần phải chuyển đổi nó thành Từ điển mà chỉ cần sử dụng Firstchức năng LINQ bất cứ khi nào bạn cần truy cập giá trị cho khóa.

Bạn có thể tạo một phương thức mở rộng tương tự ToDipedia () với sự khác biệt là nó cho phép trùng lặp. Cái gì đó như:

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

Trong trường hợp này, nếu có trùng lặp, thì giá trị cuối cùng sẽ thắng.

Để xử lý loại bỏ trùng lặp, thực hiện một phương pháp IEqualityComparer<Person>có thể được sử dụng trong Distinct()phương thức và sau đó lấy từ điển của bạn sẽ dễ dàng. Được:

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

Lấy từ điển của bạn:

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

Trong trường hợp chúng tôi muốn tất cả Người (thay vì chỉ một Người) trong từ điển trả về, chúng tôi có thể:

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

Vấn đề với hầu hết các câu trả lời khác là chúng sử dụng Distinct, GroupByhoặc ToLookup, tạo ra một Từ điển bổ sung dưới mui xe. Tương tự ToUpper tạo chuỗi bổ sung. Đây là những gì tôi đã làm, gần như là một bản sao chính xác của mã Microsoft ngoại trừ một thay đổi:

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

Bởi vì một bộ trên bộ chỉ mục làm cho nó thêm khóa, nó sẽ không ném và cũng sẽ chỉ thực hiện một tra cứu khóa. Bạn cũng có thể cho nó một IEqualityComparerví dụStringComparer.OrdinalIgnoreCase

Bắt đầu từ giải pháp của Carra, bạn cũng có thể viết nó dưới dạng:

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