如何使用LINQ选择具有最小或最大属性值的对象

我有一个具有Nullable DateOfBirth属性的Person对象。有没有一种方法可以使用LINQ来查询Person对象列表中最早/最小的DateOfBirth值。

这是我开始的：

var firstBornDate = People.Min(p => p.DateOfBirth.GetValueOrDefault(DateTime.MaxValue));

空的DateOfBirth值设置为DateTime.MaxValue以便将它们排除在Min考虑之外（假设至少一个具有指定的DOB）。

但是对我来说，所有要做的就是将firstBornDate设置为DateTime值。我想要得到的是与此匹配的Person对象。我是否需要这样编写第二个查询：

var firstBorn = People.Single(p=> (p.DateOfBirth ?? DateTime.MaxValue) == firstBornDate);

还是有一种更精简的方法？

People.Aggregate((curMin, x) => (curMin == null || (x.DateOfBirth ?? DateTime.MaxValue) <
    curMin.DateOfBirth ? x : curMin))

不幸的是，没有内置的方法可以执行此操作，但是它很容易实现。这是它的胆量：

public static TSource MinBy<TSource, TKey>(this IEnumerable<TSource> source,
    Func<TSource, TKey> selector)
{
    return source.MinBy(selector, null);
}

public static TSource MinBy<TSource, TKey>(this IEnumerable<TSource> source,
    Func<TSource, TKey> selector, IComparer<TKey> comparer)
{
    if (source == null) throw new ArgumentNullException("source");
    if (selector == null) throw new ArgumentNullException("selector");
    comparer = comparer ?? Comparer<TKey>.Default;

    using (var sourceIterator = source.GetEnumerator())
    {
        if (!sourceIterator.MoveNext())
        {
            throw new InvalidOperationException("Sequence contains no elements");
        }
        var min = sourceIterator.Current;
        var minKey = selector(min);
        while (sourceIterator.MoveNext())
        {
            var candidate = sourceIterator.Current;
            var candidateProjected = selector(candidate);
            if (comparer.Compare(candidateProjected, minKey) < 0)
            {
                min = candidate;
                minKey = candidateProjected;
            }
        }
        return min;
    }
}

用法示例：

var firstBorn = People.MinBy(p => p.DateOfBirth ?? DateTime.MaxValue);

请注意，如果序列为空，则将引发异常；如果有多个，则将返回具有最小值的第一个元素。

另外，您可以使用MinLIN.cs中MoreLINQ中提供的实现。（MaxBy当然有相应的。）

通过软件包管理器控制台安装：

PM>安装包morelinq

注意：为了完整起见，我包括了这个答案，因为OP没有提到数据源是什么，我们不应该做任何假设。

该查询给出了正确的答案，但是可能会变慢，因为它可能必须根据中的数据结构对中的所有项目进行排序：PeoplePeople

var oldest = People.OrderBy(p => p.DateOfBirth ?? DateTime.MaxValue).First();

更新：实际上，我不应该将此解决方案称为“天真”，但用户确实需要知道他要查询的内容。该解决方案的“慢度”取决于基础数据。如果这是一个数组或List<T>，则LINQ to Objects只能选择先对整个集合进行排序，然后再选择第一个项目。在这种情况下，它将比建议的其他解决方案慢。但是，如果这是LINQ to SQL表并且DateOfBirth是索引列，则SQL Server将使用索引而不是对所有行进行排序。其他自定义IEnumerable<T>实现也可以使用索引（请参阅i4o：索引LINQ或对象数据库db4o），并使此解决方案比Aggregate()或MaxBy()/ 更快。MinBy()，它需要对整个集合进行一次迭代。实际上，从理论上讲，LINQ to Objects可以OrderBy()对排序后的集合进行特殊处理，例如SortedList<T>，但据我所知没有。

People.OrderBy(p => p.DateOfBirth.GetValueOrDefault(DateTime.MaxValue)).First()

会做到的

因此，您要的是ArgMin或ArgMax。C＃没有针对这些的内置API。

我一直在寻找一种干净有效的方法（及时（O [n））来做到这一点。我想我发现了一个：

此模式的一般形式是：

var min = data.Select(x => (key(x), x)).Min().Item2;
                            ^           ^       ^
              the sorting key           |       take the associated original item
                                Min by key(.)

特别地，使用原始问题中的示例：

对于支持值元组的 C＃7.0及更高版本：

var youngest = people.Select(p => (p.DateOfBirth, p)).Min().Item2;

对于7.0之前的C＃版本，可以改用匿名类型：

var youngest = people.Select(p => new { ppl = p; age = p.DateOfBirth }).Min().ppl;

他们的工作，因为这两个值的元组和匿名类型有合理的默认comparers：对（X1，Y1）和（x2，y2）的，它首先比较x1VS x2，然后y1VS y2。这就是为什么内置.Min可以在这些类型上使用函数。

而且由于匿名类型和值元组都是值类型，因此它们都应该非常有效。

注意

在我的上述ArgMin实现中DateOfBirth，DateTime为简单起见，我假定采用type 。原始问题要求排除那些具有空DateOfBirth字段的条目：

空的DateOfBirth值设置为DateTime.MaxValue以便将它们排除在Min考虑之外（假设至少一个具有指定的DOB）。

可以通过预过滤来实现

people.Where(p => p.DateOfBirth.HasValue)

因此，对于实施ArgMin或ArgMax。

笔记2

上面的方法有一个告诫，当有两个具有相同最小值的实例时，Min()实现将尝试将这些实例作为决胜局进行比较。但是，如果实例的类未实现IComparable，则将引发运行时错误：

至少一个对象必须实现IComparable

幸运的是，这仍然可以解决得很干净。这个想法是将一个明显的“ ID”与充当明确的决胜局的每个条目相关联。我们可以为每个条目使用增量ID。仍以人口年龄为例：

var youngest = Enumerable.Range(0, int.MaxValue)
               .Zip(people, (idx, ppl) => (ppl.DateOfBirth, idx, ppl)).Min().Item3;

无需额外包装的解决方案：

var min = lst.OrderBy(i => i.StartDate).FirstOrDefault();
var max = lst.OrderBy(i => i.StartDate).LastOrDefault();

您也可以将其包装到扩展中：

public static class LinqExtensions
{
    public static T MinBy<T, TProp>(this IEnumerable<T> source, Func<T, TProp> propSelector)
    {
        return source.OrderBy(propSelector).FirstOrDefault();
    }

    public static T MaxBy<T, TProp>(this IEnumerable<T> source, Func<T, TProp> propSelector)
    {
        return source.OrderBy(propSelector).LastOrDefault();
    }
}

在这种情况下：

var min = lst.MinBy(i => i.StartDate);
var max = lst.MaxBy(i => i.StartDate);

顺便说一下... O（n ^ 2）不是最佳解决方案。保罗·贝茨（Paul Betts）提供了比我强的解决方案。但是我仍然是LINQ解决方案，比这里的其他解决方案更简单，更短。

public class Foo {
    public int bar;
    public int stuff;
};

void Main()
{
    List<Foo> fooList = new List<Foo>(){
    new Foo(){bar=1,stuff=2},
    new Foo(){bar=3,stuff=4},
    new Foo(){bar=2,stuff=3}};

    Foo result = fooList.Aggregate((u,v) => u.bar < v.bar ? u: v);
    result.Dump();
}

完全简单地使用汇总（相当于其他语言中的fold）：

var firstBorn = People.Aggregate((min, x) => x.DateOfBirth < min.DateOfBirth ? x : min);

唯一的缺点是，每个序列元素对该属性访问两次，这可能会很昂贵。很难解决。

以下是更通用的解决方案。它基本上执行相同的操作（以O（N）顺序），但是在任何IEnumberable类型上，都可以与属性选择器可以返回null的类型混合使用。

public static class LinqExtensions
{
    public static T MinBy<T>(this IEnumerable<T> source, Func<T, IComparable> selector)
    {
        if (source == null)
        {
            throw new ArgumentNullException(nameof(source));
        }
        if (selector == null)
        {
            throw new ArgumentNullException(nameof(selector));
        }
        return source.Aggregate((min, cur) =>
        {
            if (min == null)
            {
                return cur;
            }
            var minComparer = selector(min);
            if (minComparer == null)
            {
                return cur;
            }
            var curComparer = selector(cur);
            if (curComparer == null)
            {
                return min;
            }
            return minComparer.CompareTo(curComparer) > 0 ? cur : min;
        });
    }
}

测试：

var nullableInts = new int?[] {5, null, 1, 4, 0, 3, null, 1};
Assert.AreEqual(0, nullableInts.MinBy(i => i));//should pass

再次编辑：

抱歉。除了缺少可空值之外，我还在看错误的函数，

Min <（Of <（TSource，TResult>）>）（IEnumerable <（Of <（TSource>）>），Func <（Of <（TSource，TResult>）>））确实会返回您所说的结果类型。

我会说一个可能的解决方案是实现IComparable并使用Min <（Of <（TSource>）>）（IEnumerable <（Of <（TSource>）>）），这实际上确实从IEnumerable返回了一个元素。当然，如果您不能修改元素，那对您没有帮助。我在这里发现MS的设计有点奇怪。

当然，如果需要，您始终可以进行for循环，或者使用Jon Skeet提供的MoreLINQ实现。

另一个可以与可为空的选择器键一起使用的实现，如果找不到合适的元素，则对于引用类型的集合将返回null。例如，这可能对随后处理数据库结果很有帮助。

  public static class IEnumerableExtensions
  {
    /// <summary>
    /// Returns the element with the maximum value of a selector function.
    /// </summary>
    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
    /// <typeparam name="TKey">The type of the key returned by keySelector.</typeparam>
    /// <param name="source">An IEnumerable collection values to determine the element with the maximum value of.</param>
    /// <param name="keySelector">A function to extract the key for each element.</param>
    /// <exception cref="System.ArgumentNullException">source or keySelector is null.</exception>
    /// <exception cref="System.InvalidOperationException">source contains no elements.</exception>
    /// <returns>The element in source with the maximum value of a selector function.</returns>
    public static TSource MaxBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) => MaxOrMinBy(source, keySelector, 1);

    /// <summary>
    /// Returns the element with the minimum value of a selector function.
    /// </summary>
    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
    /// <typeparam name="TKey">The type of the key returned by keySelector.</typeparam>
    /// <param name="source">An IEnumerable collection values to determine the element with the minimum value of.</param>
    /// <param name="keySelector">A function to extract the key for each element.</param>
    /// <exception cref="System.ArgumentNullException">source or keySelector is null.</exception>
    /// <exception cref="System.InvalidOperationException">source contains no elements.</exception>
    /// <returns>The element in source with the minimum value of a selector function.</returns>
    public static TSource MinBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) => MaxOrMinBy(source, keySelector, -1);


    private static TSource MaxOrMinBy<TSource, TKey>
      (IEnumerable<TSource> source, Func<TSource, TKey> keySelector, int sign)
    {
      if (source == null) throw new ArgumentNullException(nameof(source));
      if (keySelector == null) throw new ArgumentNullException(nameof(keySelector));
      Comparer<TKey> comparer = Comparer<TKey>.Default;
      TKey value = default(TKey);
      TSource result = default(TSource);

      bool hasValue = false;

      foreach (TSource element in source)
      {
        TKey x = keySelector(element);
        if (x != null)
        {
          if (!hasValue)
          {
            value = x;
            result = element;
            hasValue = true;
          }
          else if (sign * comparer.Compare(x, value) > 0)
          {
            value = x;
            result = element;
          }
        }
      }

      if ((result != null) && !hasValue)
        throw new InvalidOperationException("The source sequence is empty");

      return result;
    }
  }

例：

public class A
{
  public int? a;
  public A(int? a) { this.a = a; }
}

var b = a.MinBy(x => x.a);
var c = a.MaxBy(x => x.a);

我一直在寻找类似的东西，最好不要使用库或对整个列表进行排序。我的解决方案最终类似于问题本身，只是简化了一点。

var firstBorn = People.FirstOrDefault(p => p.DateOfBirth == People.Min(p2 => p2.DateOfBirth));