Linq kullanarak ve kopyalar için endişelenmeden listeyi sözlüğe dönüştür

Person nesnelerinin bir listesi var. Anahtar adı ve soyadı (birleştirilmiş) ve değeri Person nesnesidir bir sözlüğe dönüştürmek istiyorum.

Sorun şu ki bazı yinelenen insanlar var, bu yüzden bu kodu kullanırsanız bu patlar:

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

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

Garip geldiğini biliyorum ama şimdilik yinelenen isimleri umursamıyorum. Birden fazla isim varsa, sadece bir tane almak istiyorum. Zaten bu kodları yazabilir miyim, bu yüzden sadece isimlerden birini alır ve kopyalara patlamaz mı?

İşte bariz, linq olmayan çözüm:

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

LINQ çözümü:

// 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 olmayan bir çözümü tercih ederseniz, böyle bir şey yapabilirsiniz:

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

Distinct () kullanan ve gruplama bulunmayan bir Linq çözümü:

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

LukeH'nin çözümünden daha iyi olup olmadığını bilmiyorum ama işe yarıyor.

Bu lambda ifadesi ile çalışmalıdır:

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

Ayrıca ToLookupdaha sonra bir Sözlük ile neredeyse birbirinin yerine kullanabileceğiniz LINQ işlevini de kullanabilirsiniz .

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

Bu aslında GroupBy'yi LukeH'nin cevabında yapacak, ancak bir Sözlüğün sağladığı hash'i verecektir. Bu nedenle, muhtemelen bir Sözlüğe dönüştürmeniz gerekmez, ancak Firstanahtarın değerine erişmeniz gerektiğinde LINQ işlevini kullanın .

ToDictionary () 'a benzer bir uzantı yöntemi oluşturarak farkın yinelenmesine izin vermesidir. Gibi bir şey:

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

Bu durumda, kopyalar varsa, son değer kazanır.

Yinelenenleri ortadan kaldırmak için IEqualityComparer<Person>, Distinct()yöntemde kullanılabilecek bir tane uygulayın ve ardından sözlüğünüzü almak kolay olacaktır. Verilen:

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

Sözlüğünüzü alı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);
        }

Dönen sözlükte tüm Kişiyi (yalnızca bir Kişi yerine) istiyorsak, şunları yapabiliriz:

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

Diğer cevapların çoğu sorunu kullandıkları olmasıdır Distinct, GroupByya ToLookupbaşlık altında fazladan Sözlük yaratan,. Eşit şekilde ToUpper ekstra dize oluşturur. Yaptığım şey bu, bir değişiklik dışında Microsoft'un kodunun neredeyse tam bir kopyası:

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

Dizinleyicideki bir küme anahtar eklemesine neden olduğundan, atmaz ve yalnızca bir anahtar araması yapar. Ayrıca IEqualityComparer, örneğin birStringComparer.OrdinalIgnoreCase

Carra'nın çözümünden başlayarak şunları da yazabilirsiniz:

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