提问



我正在玩LINQ来了解它,但是当我没有一个简单的列表时,我无法弄清楚如何使用Distinct(一个简单的整数列表很容易做到,这不是问题)。我是什么如果想在对象的一个或更多属性的对象列表上使用Distinct?[51]


示例:如果对象为Person,则为Property Id。如何获取所有Person并使用对象的Id属性Distinct?


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


我怎样才能得到Person1和Person3?那可能吗?


如果LINQ不可能,那么根据.NET 3.5中的某些属性获得Person列表的最佳方法是什么?

最佳参考


编辑:这是MoreLINQ的一部分。[52]


你需要的是一个有效的明显的。我不相信它是LINQ的一部分,尽管写起来相当容易:


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构造函数。

其它参考1



  如果我想基于一个或更多属性获取不同的列表,该怎么办?



简单!你想把它们分组并从小组中挑出一个胜利者。


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

其它参考2


如果您希望它看起来像LINQ一样,您也可以使用查询语法:


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

其它参考3


我认为这就足够了:


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

其它参考4


使用:


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帮助您过滤条目(可能更复杂),groupbyselect执行不同的功能。

其它参考5


您可以使用标准Linq.ToLookup()执行此操作。这将为每个唯一键创建一组值。只需选择集合中的第一项[53]


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

其它参考6


以下代码在功能上等同于Jon Skeet的回答。


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


最后,查看Jon Skeet在Google Code上的最新版DistinctBy.cs。[55]

其它参考7


首先按字段解决第一组,然后选择firstordefault项目。


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

其它参考8


我写了一篇文章,解释了如何扩展Distinct功能,以便您可以执行以下操作:


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 - 在不同的功能中指定属性 [56]

其它参考9


如果您需要对多个属性使用Distinct方法,可以查看我的PowerfulExtensions库。目前它处于一个非常年轻的阶段,但你已经可以使用像Distinct,Union,Intersect这样的方法,除了任何数量的属性; [57]


这是你如何使用它:


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

其它参考10


你可以这样做(尽管不是闪电般快速):


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


也就是说,选择列表中具有相同ID的另一个不同人的所有人。


在你的例子中,请注意,只选择人3.我不知道如何分辨出你想要的东西,而不是前两个。

其它参考11


我个人使用以下类:


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的东西留给原来的LINQ实现......)

其它参考12


当我们在项目中遇到这样的任务时,我们定义了一个小的API来组成比较器。


所以,用例是这样的:


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


API本身看起来像这样:


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 。[58]

其它参考13


执行此操作以与其他.NET版本兼容的最佳方法是重写Equals和GetHash来处理此问题(请参阅堆栈溢出问题此代码返回不同的值。但是,我想要的是返回强类型集合而不是匿名类型),但如果您需要在整个代码中使用通用的东西,那么本文中的解决方案就很棒。

其它参考14


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

其它参考15


如果您不想将MoreLinq库添加到项目中以获得DistinctBy功能,那么您可以使用Linq的Distinct方法的重载获得相同的最终结果IEqualityComparer论点。


首先,创建一个通用的自定义相等比较器类,它使用lambda语法来执行泛型类的两个实例的自定义比较:


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集合不包含任何空元素



如果集合可以包含空值,那么只需重写lambdas以检查null,例如:


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


修改


这种方法类似于Vladimir Nesterovsky的回答,但更简单。


它也类似于Joel的回答,但允许涉及多个属性的复杂比较逻辑。


但是,如果你的对象只能Id不同,那么另一个用户给出正确的答案,你需要做的就是覆盖你GetHashCode()Equals()的默认实现。]]类,然后只使用Linq的开箱即用Distinct()方法来过滤掉任何重复项。

其它参考16


您应该能够在人员上覆盖Equals以实际在Person.id上执行Equals。这应该导致你追求的行为。

其它参考17


请试试下面的代码。


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