Как использовать LINQ для выбора объекта с минимальным или максимальным значением свойства

У меня есть объект Person со значением Nullable DateOfBirth. Есть ли способ использовать LINQ для запроса списка объектов Person для объекта с самым ранним / наименьшим значением DateOfBirth.

Вот с чего я начал:

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

Нулевым значениям DateOfBirth присвоено значение DateTime.MaxValue, чтобы исключить их из минимального рассмотрения (при условии, что хотя бы у одного указан указанный 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);

Обратите внимание, что это вызовет исключение, если последовательность пуста, и вернет первое элемент с минимальным значением, если их больше одного.

В качестве альтернативы вы можете использовать реализацию, которую мы получили в MoreLINQ , в MinBy.cs . (Там есть соответствующийMaxBy , конечно.)

Установить через консоль диспетчера пакетов:

PM> Install-Package morelinq

ПРИМЕЧАНИЕ. Я включил этот ответ для полноты, поскольку в ОП не упоминается, что является источником данных, и мы не должны делать никаких предположений.

Этот запрос дает правильный ответ, но может быть медленнее, поскольку может потребоваться отсортировать все элементы в Peopleзависимости от структуры данных People:

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

ОБНОВЛЕНИЕ: На самом деле я не должен называть это решение «наивным», но пользователь должен знать, к чему он обращается. «Медлительность» этого решения зависит от базовых данных. Если это массив или List<T>, то у LINQ to Objects нет другого выбора, кроме как сначала отсортировать всю коллекцию перед выбором первого элемента. В этом случае это будет медленнее, чем предложенное другое решение. Однако, если это таблица LINQ to SQL и DateOfBirthиндексированный столбец, SQL Server будет использовать индекс вместо сортировки всех строк. Другие пользовательские IEnumerable<T>реализации могут также использовать индексы (см. I4o: Indexed 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;

Для версии C # до 7.0 вместо этого может использоваться анонимный тип :

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

Они работают , потому что оба значения кортежа и анонимный тип имеют осмысленные компараторов по умолчанию: для (x1, y1) и (x2, y2), она сначала сравнивает x1против x2, то y1против y2. Вот почему встроенный .Minможет быть использован на этих типах.

А так как анонимный тип и кортеж значения являются типами значения, они должны быть оба очень эффективными.

НОТА

В моих вышеприведенных ArgMinреализациях я предполагал DateOfBirthвзять тип DateTimeдля простоты и ясности. Исходный вопрос просит исключить эти записи с нулевым DateOfBirthполем:

Нулевым значениям DateOfBirth присвоено значение DateTime.MaxValue, чтобы исключить их из минимального рассмотрения (при условии, что хотя бы у одного указан указанный DOB).

Это может быть достигнуто с предварительной фильтрацией

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

Так что это несущественно в вопросе реализации ArgMinили ArgMax.

ЗАМЕТКА 2

Приведенный выше подход имеет оговорку, что, когда два экземпляра имеют одинаковое минимальное значение, Min()реализация попытается сравнить эти экземпляры как прерыватели связей. Однако, если класс экземпляров не реализуется IComparable, будет выдана ошибка времени выполнения:

По крайней мере один объект должен реализовывать IComparable

К счастью, это все еще можно исправить довольно чисто. Идея состоит в том, чтобы связать отдаленный «идентификатор» с каждой записью, которая служит однозначным нарушителем связей. Мы можем использовать инкрементный идентификатор для каждой записи. Все еще используя возраст людей в качестве примера:

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) не лучшее решение. Пол Беттс дал более полное решение, чем мой. Но мое по-прежнему решение 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();
}

Совершенно простое использование агрегата (эквивалентно сложению на других языках):

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

Единственный недостаток - доступ к свойству дважды для каждого элемента последовательности, что может быть дорого. Это трудно исправить.

Ниже приведено более общее решение. По сути, он делает то же самое (в порядке O (N)), но для любых типов IEnumberable и может смешиваться с типами, чьи селекторы свойств могут возвращать нуль.

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, если вам нужно, или использовать реализацию MoreLINQ, которую дал Джон Скит.

Другая реализация, которая может работать с обнуляемыми клавишами выбора и для коллекции ссылочного типа, возвращает нуль, если подходящих элементов не найдено. Это может быть полезно, например, для обработки результатов базы данных.

  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 firstBornDate = People.GroupBy(p => p.DateOfBirth).Min(g => g.Key).FirstOrDefault();

Я сам искал что-то подобное, желательно без использования библиотеки или сортировки всего списка. Мое решение оказалось похожим на сам вопрос, только немного упрощенным.

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