කිසියම් දේපලක් මත ලින්ක් හි වෙනස ()

මම ඒ ගැන ඉගෙන ගැනීමට LINQ සමඟ සෙල්ලම් කරමි, නමුත් මට Distinctසරල ලැයිස්තුවක් නොමැති විට භාවිතා කරන්නේ කෙසේදැයි මට සිතාගත නොහැක (පූර්ණ සංඛ්‍යා ලැයිස්තුවක් කිරීම පහසුය, මෙය ප්‍රශ්නය නොවේ). වස්තුවක ගුණාංග එකක් හෝ වැඩි ගණනක වස්තුවක ලැයිස්තුවක් මත වෙනස භාවිතා කිරීමට අවශ්‍ය නම් මා කුමක් කළ යුතුද?

උදාහරණය: වස්තුවක් නම් Person, දේපල සමඟ Id. සියලු පුද්ගලයින් ලබාගෙන වස්තුවේ Distinctදේපල සමඟ ඔවුන් භාවිතා කරන්නේ Idකෙසේද?

Person1: Id=1, Name="Test1"
Person2: Id=1, Name="Test1"
Person3: Id=2, Name="Test2"

මට සාධාරණව Person1සහ Person3කෙසේද? එය කළ හැකිද?

LINQ සමඟ එය කළ නොහැකි නම්, Person.NET 3.5 හි ඇති සමහර ගුණාංග මත පදනම්ව ලැයිස්තුවක් තබා ගැනීමට හොඳම ක්‍රමය කුමක්ද?

සංස්කරණය කරන්න : මෙය දැන් MoreLINQ හි කොටසකි .

ඔබට අවශ්‍ය වන්නේ “වෙනස් ආකාරයකින්” .ලදායී ලෙස ය. එය ලිවීමට තරමක් පහසු වුවත්, එය ලින්ක්හි කොටසක් බව මම විශ්වාස නොකරමි:

public static IEnumerable<TSource> DistinctBy<TSource, TKey>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
    HashSet<TKey> seenKeys = new HashSet<TKey>();
    foreach (TSource element in source)
    {
        if (seenKeys.Add(keySelector(element)))
        {
            yield return element;
        }
    }
}

එබැවින් Idදේපල පමණක් භාවිතා කරමින් පැහැදිලි අගයන් සොයා ගැනීමට ඔබට භාවිතා කළ හැකිය:

var query = people.DistinctBy(p => p.Id);

බහු ගුණාංග භාවිතා කිරීම සඳහා, ඔබට සමානාත්මතාවය නිසි පරිදි ක්‍රියාත්මක කරන නිර්නාමික වර්ග භාවිතා කළ හැකිය:

var query = people.DistinctBy(p => new { p.Id, p.Name });

පරීක්ෂා නොකළ නමුත් එය ක්‍රියාත්මක විය යුතුය (එය දැන් අවම වශයෙන් සම්පාදනය කරයි).

එය යතුරු සඳහා පෙරනිමි සංසන්දකය උපකල්පනය කරයි - ඔබට සමානාත්මතා සංසන්දකය තුළ සමත් වීමට අවශ්‍ය නම්, එය HashSetඉදිකිරීම්කරු වෙත භාර දෙන්න.

දේපල එකක් හෝ කිහිපයක් මත පදනම්ව පැහැදිලි ලැයිස්තුවක් ලබා ගැනීමට මට අවශ්‍ය නම් කුමක් කළ යුතුද?

සරල! ඔබට ඒවා කණ්ඩායම් කර ජයග්‍රාහකයෙකු කණ්ඩායමෙන් තෝරා ගැනීමට අවශ්‍යය.

List<Person> distinctPeople = allPeople
  .GroupBy(p => p.PersonId)
  .Select(g => g.First())
  .ToList();

ඔබට බහු ගුණාංග මත කණ්ඩායම් අර්ථ දැක්වීමට අවශ්‍ය නම්, මෙන්න:

List<Person> distinctPeople = allPeople
  .GroupBy(p => new {p.PersonId, p.FavoriteColor} )
  .Select(g => g.First())
  .ToList();

භාවිත:

List<Person> pList = new List<Person>();
/* Fill list */

var result = pList.Where(p => p.Name != null).GroupBy(p => p.Id).Select(grp => grp.FirstOrDefault());

මෙම whereඔබ ඇතුළත් කිරීම් (වඩාත් සංකීර්ණ විය හැකි) සහ පෙරීමට උපකාරී groupbyහා selectපැවති විශේෂ කාර්යයක් ඉටු.

ඔබට ලින්ක් වැනි පෙනුමක් ලබා ගැනීමට අවශ්‍ය නම් විමසුම් සින්ටැක්ස් භාවිතා කළ හැකිය:

var uniquePeople = from p in people
                   group p by new {p.ID} //or group by new {p.ID, p.Name, p.Whatever}
                   into mygroup
                   select mygroup.FirstOrDefault();

මම හිතන්නේ එය ප්‍රමාණවත් ය:

list.Select(s => s.MyField).Distinct();

ඔබේ ක්ෂේත්‍ර අනුව පළමු කණ්ඩායම විසඳන්න, පසුව පළමු ඇණවුම් අයිතමය තෝරන්න.

    List<Person> distinctPeople = allPeople
   .GroupBy(p => p.PersonId)
   .Select(g => g.FirstOrDefault())
   .ToList();

ඔබට මෙය සම්මතයෙන් කළ Linq.ToLookup()හැකිය. මෙය එක් එක් අද්විතීය යතුර සඳහා අගයන් එකතුවක් නිර්මාණය කරනු ඇත. එකතුවේ පළමු අයිතමය තෝරන්න

Persons.ToLookup(p => p.Id).Select(coll => coll.First());

පහත කේතය ජෝන් ස්කීට්ගේ පිළිතුරට ක්‍රියාකාරීව සමාන වේ .

.NET 4.5 හි පරීක්ෂා කර ඇති අතර, LINQ හි ​​ඕනෑම පෙර සංස්කරණයක් මත ක්‍රියා කළ යුතුය.

public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
  this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
  HashSet<TKey> seenKeys = new HashSet<TKey>();
  return source.Where(element => seenKeys.Add(keySelector(element)));
}

අහම්බෙන්, ගූගල් කේතයේ ජෝන් ස්කීට් හි DistinctBy.cs හි නවතම අනුවාදය බලන්න .

පහත දැක්වෙන පරිදි ඔබට කළ හැකි වන පරිදි සුවිශේෂී ශ්‍රිතය දීර් extend කරන්නේ කෙසේද යන්න පැහැදිලි කරන ලිපියක් මා ලියා ඇත:

var people = new List<Person>();

people.Add(new Person(1, "a", "b"));
people.Add(new Person(2, "c", "d"));
people.Add(new Person(1, "a", "b"));

foreach (var person in people.Distinct(p => p.ID))
    // Do stuff with unique list here.

මෙන්න ලිපිය: LINQ දීර් tend කිරීම - පැහැදිලි ශ්‍රිතයේ දේපලක් නියම කිරීම

පුද්ගලිකව මම පහත පන්තිය භාවිතා කරමි:

public class LambdaEqualityComparer<TSource, TDest> : 
    IEqualityComparer<TSource>
{
    private Func<TSource, TDest> _selector;

    public LambdaEqualityComparer(Func<TSource, TDest> selector)
    {
        _selector = selector;
    }

    public bool Equals(TSource obj, TSource other)
    {
        return _selector(obj).Equals(_selector(other));
    }

    public int GetHashCode(TSource obj)
    {
        return _selector(obj).GetHashCode();
    }
}

පසුව, දිගු කිරීමේ ක්‍රමයක්:

public static IEnumerable<TSource> Distinct<TSource, TCompare>(
    this IEnumerable<TSource> source, Func<TSource, TCompare> selector)
{
    return source.Distinct(new LambdaEqualityComparer<TSource, TCompare>(selector));
}

අවසාන වශයෙන්, අපේක්ෂිත භාවිතය:

var dates = new List<DateTime>() { /* ... */ }
var distinctYears = dates.Distinct(date => date.Year);

මෙම ප්‍රවේශය භාවිතා කිරීමෙන් මා සොයාගත් වාසිය LambdaEqualityComparerනම්, පිළිගන්නා වෙනත් ක්‍රම සඳහා පන්තිය නැවත භාවිතා කිරීමයි IEqualityComparer. (ඔහ්, මම yieldමුල් ලින්ක් ක්‍රියාත්මක කිරීම සඳහා දේවල් තබමි ...)

වස්තු දේපලකින් පැහැදිලි වාර්තා ලබා ගැනීම සඳහා ඔබට DistinctBy () භාවිතා කළ හැකිය. එය භාවිතා කිරීමට පෙර පහත ප්‍රකාශය එක් කරන්න:

Microsoft.Ajax.Utilities භාවිතා කිරීම;

ඉන්පසු එය පහත පරිදි භාවිතා කරන්න:

var listToReturn = responseList.DistinctBy(x => x.Index).ToList();

'දර්ශකය' යනු දත්ත එකිනෙකට වෙනස් වීමට මට අවශ්‍ය දේපලයි.

ඔබට බහු ගුණාංග පිළිබඳ විශේෂිත ක්‍රමයක් අවශ්‍ය නම්, ඔබට මගේ බලවත් දිගුවන් පරීක්ෂා කළ හැකිය පුස්තකාලය . දැනට එය ඉතා තරුණ අවධියක පවතී, නමුත් දැනටමත් ඔබට ඕනෑම දේපල ගණනක් හැර වෙන වෙනම, යුනියන්, ඉන්ටර්සෙක්ට් වැනි ක්‍රම භාවිතා කළ හැකිය;

ඔබ එය භාවිතා කරන ආකාරය මෙයයි:

using PowerfulExtensions.Linq;
...
var distinct = myArray.Distinct(x => x.A, x => x.B);

අපගේ ව්‍යාපෘතියේ එවැනි කාර්යයකට අප මුහුණ දුන් විට, සංසන්දකයන් රචනා කිරීම සඳහා අපි කුඩා API එකක් අර්ථ දැක්වුවෙමු.

ඉතින්, භාවිත නඩුව මේ වගේ විය:

var wordComparer = KeyEqualityComparer.Null<Word>().
    ThenBy(item => item.Text).
    ThenBy(item => item.LangID);
...
source.Select(...).Distinct(wordComparer);

ඒපීඅයි එක මේ වගේ ය:

using System;
using System.Collections;
using System.Collections.Generic;

public static class KeyEqualityComparer
{
    public static IEqualityComparer<T> Null<T>()
    {
        return null;
    }

    public static IEqualityComparer<T> EqualityComparerBy<T, K>(
        this IEnumerable<T> source,
        Func<T, K> keyFunc)
    {
        return new KeyEqualityComparer<T, K>(keyFunc);
    }

    public static KeyEqualityComparer<T, K> ThenBy<T, K>(
        this IEqualityComparer<T> equalityComparer,
        Func<T, K> keyFunc)
    {
        return new KeyEqualityComparer<T, K>(keyFunc, equalityComparer);
    }
}

public struct KeyEqualityComparer<T, K>: IEqualityComparer<T>
{
    public KeyEqualityComparer(
        Func<T, K> keyFunc,
        IEqualityComparer<T> equalityComparer = null)
    {
        KeyFunc = keyFunc;
        EqualityComparer = equalityComparer;
    }

    public bool Equals(T x, T y)
    {
        return ((EqualityComparer == null) || EqualityComparer.Equals(x, y)) &&
                EqualityComparer<K>.Default.Equals(KeyFunc(x), KeyFunc(y));
    }

    public int GetHashCode(T obj)
    {
        var hash = EqualityComparer<K>.Default.GetHashCode(KeyFunc(obj));

        if (EqualityComparer != null)
        {
            var hash2 = EqualityComparer.GetHashCode(obj);

            hash ^= (hash2 << 5) + hash2;
        }

        return hash;
    }

    public readonly Func<T, K> KeyFunc;
    public readonly IEqualityComparer<T> EqualityComparer;
}

වැඩි විස්තර අපගේ වෙබ් අඩවියේ ඇත: LINQ හි ​​IEqualityComparer .

ඔබට එය කළ හැකිය (අකුණු වේගයෙන් නොවුනත්):

people.Where(p => !people.Any(q => (p != q && p.Id == q.Id)));

එනම්, "එකම හැඳුනුම්පතක් ඇති ලැයිස්තුවේ වෙනත් වෙනස් පුද්ගලයෙක් නොමැති සියලු පුද්ගලයින් තෝරන්න."

ඔබේ උදාහරණයේ දී, එය පුද්ගලයකු 3 ක් පමණක් තෝරා ගනු ඇතැයි සිතන්න. පෙර දෙකෙන් ඔබට අවශ්‍ය දේ කීමට මට විශ්වාස නැත.

DistinctByක්‍රියාකාරීත්වය ලබා ගැනීම සඳහා ඔබේ ව්‍යාපෘතියට මෝර්ලින්ක් පුස්තකාලය එක් කිරීමට ඔබට අවශ්‍ය නැතිනම්, ලින්ක්ගේ Distinctක්‍රමවේදය අධික ලෙස භාවිතා කිරීමෙන් ඔබට එකම අවසාන ප්‍රති result ලය ලබා ගත හැකිය .IEqualityComparer .

සාමාන්‍ය පන්තියේ අවස්ථා දෙකක අභිරුචි සංසන්දනය කිරීම සඳහා ලැම්බඩා සින්ටැක්ස් භාවිතා කරන සාමාන්‍ය අභිරුචි සමානාත්මතා සංසන්දනාත්මක පන්තියක් නිර්මාණය කිරීමෙන් ඔබ ආරම්භ කරයි:

public class CustomEqualityComparer<T> : IEqualityComparer<T>
{
    Func<T, T, bool> _comparison;
    Func<T, int> _hashCodeFactory;

    public CustomEqualityComparer(Func<T, T, bool> comparison, Func<T, int> hashCodeFactory)
    {
        _comparison = comparison;
        _hashCodeFactory = hashCodeFactory;
    }

    public bool Equals(T x, T y)
    {
        return _comparison(x, y);
    }

    public int GetHashCode(T obj)
    {
        return _hashCodeFactory(obj);
    }
}

ඔබේ ප්‍රධාන කේතයේ ඔබ එය එසේ භාවිතා කරයි:

Func<Person, Person, bool> areEqual = (p1, p2) => int.Equals(p1.Id, p2.Id);

Func<Person, int> getHashCode = (p) => p.Id.GetHashCode();

var query = people.Distinct(new CustomEqualityComparer<Person>(areEqual, getHashCode));

වොයිලා! :)

ඉහත සඳහන් කරුණු පහත දැක්වේ:

• දේපල Person.Idවර්ගයට අයත් වේint
• මෙම peopleඑකතුව ඕනෑම ශූන්ය අංග අඩංගු නොවේ

එකතුවට ශුන්‍ය අඩංගු විය හැකි නම්, ශුන්‍යය පරීක්ෂා කිරීම සඳහා ලැම්බඩා නැවත ලියන්න, උදා:

Func<Person, Person, bool> areEqual = (p1, p2) => 
{
    return (p1 != null && p2 != null) ? int.Equals(p1.Id, p2.Id) : false;
};

සංස්කරණය කරන්න

මෙම ප්‍රවේශය ව්ලැඩිමීර් නෙස්ටරොව්ස්කිගේ පිළිතුරට සමාන නමුත් සරල ය.

එය ජොයෙල්ගේ පිළිතුරේ ඇති පිළිතුරට සමාන වන නමුත් බහු ගුණාංග සම්බන්ධ සංකීර්ණ සංසන්දනාත්මක තර්කනයකට ඉඩ දෙයි.

කෙසේ වෙතත්, ඔබගේ වස්තූන් පමණක් මෙතෙක් විසින් වෙනස් කළ හැකි නම් Idඑවිට තවත් පරිශීලකයෙකු නිවැරදි පිළිතුර ලබා දුන් ඔබ කළ යුතු සියල්ල පෙරනිමි නිර්මාණයන් යටපත් කිරීම බව GetHashCode()හා Equals()ඔබේ Personපන්තිය හා ඉන්පසු එහි සිදු-of-the-කොටුව භාවිතා Distinct()පෙරහන Linq ක්රමය ඕනෑම අනුපිටපත්.

මෙය කළ හැකි හොඳම ක්‍රමය වන්නේ වෙනත් .නෙට් අනුවාදයන් සමඟ අනුකූල වන අතර මෙය හැසිරවීමට සමාන හා ගෙට්හැෂ් අභිබවා යාමයි . නිර්නාමික වර්ගයකි ), නමුත් ඔබේ කේතය පුරාම සාමාන්‍ය දෙයක් ඔබට අවශ්‍ය නම්, මෙම ලිපියේ විසඳුම් විශිෂ්ටයි.

පාගාගෙන සමාන වේ (වස්තුව එය විවෘත) සහ GetHashCode () ක්රම:

class Person
{
    public int Id { get; set; }
    public int Name { get; set; }

    public override bool Equals(object obj)
    {
        return ((Person)obj).Id == Id;
        // or: 
        // var o = (Person)obj;
        // return o.Id == Id && o.Name == Name;
    }
    public override int GetHashCode()
    {
        return Id.GetHashCode();
    }
}

ඉන්පසු අමතන්න:

List<Person> distinctList = new[] { person1, person2, person3 }.Distinct().ToList();

List<Person>lst=new List<Person>
        var result1 = lst.OrderByDescending(a => a.ID).Select(a =>new Player {ID=a.ID,Name=a.Name} ).Distinct();

Person.id හි ඇත්ත වශයෙන්ම සමාන දේ කිරීමට ඔබට පුද්ගලයාට සමානකම් ඉක්මවා යා හැක. මෙය ඔබ අනුගමනය කරන හැසිරීමට හේතු විය යුතුය.

කරුණාකර පහත කේතය සමඟ උත්සාහ කරන්න.

var Item = GetAll().GroupBy(x => x .Id).ToList();