我玩LINQ来了解它，但我不知道如何使用鲜明当我没有一个简单的列表(一个简单的整数列表是很容易做到的，这不是问题)。如果我想使用鲜明的列表<TElement>上的一个或多个属性的TElement?
示例:如果一个对象是Person，具有属性Id。我怎么能得到所有人，并使用鲜明对他们与对象的属性Id ?
Person1: Id=1, Name="Test1"
Person2: Id=1, Name="Test1"
Person3: Id=2, Name="Test2"
如何得到Person1和Person3?这可能吗?
如果用LINQ是不可能的，那么根据Person的某些属性获得Person列表的最佳方法是什么?
你可以这样做(虽然不是闪电般快):
people.Where(p => !people.Any(q => (p != q && p.Id == q.Id)));
也就是说，“选择列表中没有其他具有相同ID的人的所有人。”
注意，在你的例子中，这只会选择第3个人。我不知道怎么分辨你想要的是哪一个。
编辑:这现在是MoreLINQ的一部分。
你需要的是一个有效的“区别”。我不相信它是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构造函数。
如果我想根据一个或多个属性获得一个不同的列表，该怎么办?
简单!你想把他们分组，然后从中选出一个优胜者。
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();
注意:某些查询提供程序无法解决每个组必须至少有一个元素，在这种情况下调用First是合适的方法。如果您发现自己正在使用这样的查询提供程序，那么FirstOrDefault可以帮助您通过查询提供程序获取查询。
注2:对于EF Core(在EF Core 6之前)兼容的方法，请考虑这个答案。https://stackoverflow.com/a/66529949/8155
我写了一篇文章，解释了如何扩展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.
这是一篇文章(现在在Web档案中):扩展LINQ -在Distinct函数中指定属性
Use:
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执行不同的功能。
如果你想让它看起来像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();
下面的代码在功能上等同于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)));
}
顺便说一句，请在谷歌Code上查看Jon Skeet的最新版本的DistinctBy.cs。
更新2022-04-03
根据Andrew McClement的评论，最好接受John Skeet的回答。
如果您需要在多个属性上使用Distinct方法，您可以查看我的PowerfulExtensions库。目前它在一个非常年轻的阶段，但你已经可以使用方法，如明确，联合，相交，除任何数量的属性;
下面是它的用法:
using PowerfulExtensions.Linq;
...
var distinct = myArray.Distinct(x => x.A, x => x.B);
与其他。net版本兼容的最好方法是重写Equals和GetHash来处理这个问题(参见堆栈溢出问题这段代码返回不同的值。然而，我想要的是返回一个强类型集合，而不是匿名类型)，但是如果您需要在整个代码中使用通用的东西，那么本文中的解决方案非常好。
当我们在项目中面临这样的任务时，我们定义了一个小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;
}
更多细节请访问我们的网站:iequalitycompararer in LINQ。
您可以使用标准Linq.ToLookup()来实现这一点。这将为每个唯一键创建一个值集合。只需选择集合中的第一项
Persons.ToLookup(p => p.Id).Select(coll => coll.First());
我个人使用以下类:
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);
我发现使用这种方法的优点是可以为其他接受IEqualityComparer的方法重用LambdaEqualityComparer类。(哦，我把yield的东西留给最初的LINQ实现…)
List<Person>lst=new List<Person>
var result1 = lst.OrderByDescending(a => a.ID).Select(a =>new Player {ID=a.ID,Name=a.Name} ).Distinct();
如果你不想将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));
瞧!：）
以上假设如下:
财产的人。Id的类型是int people集合不包含任何空元素
如果集合可能包含空值，那么只需重写lambdas来检查空值，例如:
Func<Person, Person, bool> areEqual = (p1, p2) =>
{
return (p1 != null && p2 != null) ? int.Equals(p1.Id, p2.Id) : false;
};
EDIT
这种方法与弗拉基米尔·涅斯特罗夫斯基的答案相似，但更简单。
它也类似于Joel的回答，但允许涉及多个属性的复杂比较逻辑。
然而，如果你的对象只能因Id而不同，那么另一个用户给出了正确的答案，你所需要做的就是在你的Person类中覆盖GetHashCode()和Equals()的默认实现，然后只使用Linq的开箱即开的Distinct()方法来过滤掉任何重复。
解决方案第一组由您的字段，然后选择FirstOrDefault项。
List<Person> distinctPeople = allPeople
.GroupBy(p => p.PersonId)
.Select(g => g.FirstOrDefault())
.ToList();
重写Equals(object obj)和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();
您可以使用DistinctBy()通过对象属性获取Distinct记录。只需在使用它之前添加以下语句:
使用Microsoft.Ajax.Utilities;
然后像这样使用它:
var listToReturn = responseList.DistinctBy(x => x.Index).ToList();
其中'Index'是我想要的数据是不同的属性。
从。net 6开始，在Linq中使用新的DistinctBy()扩展有了新的解决方案，所以我们可以做:
var distinctPersonsById = personList.DistinctBy(x => x.Id);
DistinctBy方法的签名:
// Returns distinct elements from a sequence according to a specified
// key selector function.
public static IEnumerable<TSource> DistinctBy<TSource, TKey> (
this IEnumerable<TSource> source,
Func<TSource, TKey> keySelector);
如果你使用的是旧的。net版本，扩展方法不是内置的，那么你可以定义你自己的扩展方法:
public static class EnumerableExtensions
{
public static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> enumerable, Func<T, TKey> keySelector)
{
return enumerable.GroupBy(keySelector).Select(grp => grp.First());
}
}
用法示例:
var personsDist = persons.DistinctBy(item => item.Name);
也许这个能帮上忙，试试这个。使用HashSet可以提高代码性能。
public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
var known = new HashSet<TKey>();
return source.Where(element => known.Add(keySelector(element)));
}
