您可以使用DistinctBy()通过对象属性获取Distinct记录。只需在使用它之前添加以下语句:

使用Microsoft.Ajax.Utilities;

然后像这样使用它:

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

其中'Index'是我想要的数据是不同的属性。

当我们在项目中面临这样的任务时，我们定义了一个小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。

如果我想根据一个或多个属性获得一个不同的列表，该怎么办?

简单!你想把他们分组，然后从中选出一个优胜者。

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

请尝试以下代码。

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

与其他。net版本兼容的最好方法是重写Equals和GetHash来处理这个问题(参见堆栈溢出问题这段代码返回不同的值。然而，我想要的是返回一个强类型集合，而不是匿名类型)，但是如果您需要在整个代码中使用通用的东西，那么本文中的解决方案非常好。

我个人使用以下类:

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实现…)