Konversi daftar ke kamus menggunakan LINQ dan tidak khawatir tentang duplikat

Saya punya daftar objek Person. Saya ingin mengonversi ke Kamus di mana kuncinya adalah nama depan dan belakang (digabungkan) dan nilainya adalah objek Orang.

Masalahnya adalah saya memiliki beberapa orang yang terduplikasi, jadi ini meledak jika saya menggunakan kode ini:

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

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

Saya tahu ini kedengarannya aneh, tetapi saya tidak begitu peduli dengan nama duplikat untuk saat ini. Jika ada banyak nama, saya hanya ingin mengambil satu. Apakah ada yang bisa saya tuliskan kode ini di atas sehingga hanya membutuhkan satu nama dan tidak meledak pada duplikat?

Inilah solusi yang jelas dan tidak linq:

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

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

Jika Anda lebih suka solusi non-LINQ maka Anda dapat melakukan sesuatu seperti ini:

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

Solusi Linq menggunakan Distinct () dan dan tanpa pengelompokan adalah:

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

Saya tidak tahu apakah itu lebih baik daripada solusi LukeH tetapi berfungsi juga.

Ini harus bekerja dengan ekspresi lambda:

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

Anda juga dapat menggunakan ToLookupfungsi LINQ, yang kemudian dapat Anda gunakan hampir secara bergantian dengan Kamus.

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

Ini pada dasarnya akan melakukan GroupBy dalam jawaban LukeH , tetapi akan memberikan hashing bahwa Kamus menyediakan. Jadi, Anda mungkin tidak perlu mengubahnya ke Kamus, tetapi cukup gunakan Firstfungsi LINQ setiap kali Anda perlu mengakses nilai untuk kunci.

Anda dapat membuat metode ekstensi yang mirip dengan ToDictionary () dengan perbedaannya yaitu memungkinkan duplikat. Sesuatu seperti:

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

Dalam hal ini, jika ada duplikat, maka nilai terakhir yang menang.

Untuk menangani menghilangkan duplikat, implementasikan metode IEqualityComparer<Person>yang dapat digunakan dalam Distinct()metode ini, dan kemudian mendapatkan kamus Anda akan mudah. Diberikan:

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

Dapatkan kamus Anda:

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

Jika kita ingin semua Orang (bukan hanya satu Orang) dalam kamus yang kembali, kita dapat:

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

Masalah dengan sebagian besar jawaban lain adalah bahwa mereka menggunakan Distinct, GroupByatau ToLookup, yang menciptakan Kamus tambahan di bawah tenda. Sama dengan ToUpper menciptakan string ekstra. Inilah yang saya lakukan, yang merupakan salinan persis kode Microsoft kecuali satu perubahan:

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

Karena satu set pada indexer menyebabkannya menambahkan kunci, itu tidak akan membuang, dan juga hanya akan melakukan satu pencarian kunci. Anda juga dapat memberikannya IEqualityComparer, misalnyaStringComparer.OrdinalIgnoreCase

Mulai dari solusi Carra, Anda juga dapat menuliskannya sebagai:

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