Cómo usar LINQ para seleccionar objetos con un valor de propiedad mínimo o máximo

Tengo un objeto Person con una propiedad Nullable DateOfBirth. ¿Hay alguna manera de usar LINQ para consultar una lista de objetos Person para el que tiene el valor DateOfBirth más antiguo / más pequeño?

Esto es con lo que comencé:

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

Los valores nulos de DateOfBirth se establecen en DateTime.MaxValue para descartarlos de la consideración mínima (suponiendo que al menos uno tenga un DOB especificado).

Pero todo lo que hace por mí es establecer firstBornDate en un valor DateTime. Lo que me gustaría obtener es el objeto Persona que coincida con eso. ¿Necesito escribir una segunda consulta así:

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

¿O hay una forma más ágil de hacerlo?

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

Desafortunadamente no hay un método incorporado para hacer esto, pero es bastante fácil de implementar por ti mismo. Aquí están las entrañas:

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;
    }
}

Ejemplo de uso:

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

Tenga en cuenta que esto arrojará una excepción si la secuencia está vacía, y devolverá el primer elemento con el valor mínimo si hay más de uno.

Alternativamente, puede usar la implementación que tenemos en MoreLINQ , en MinBy.cs . (Hay un correspondiente MaxBy, por supuesto).

Instalar a través de la consola del administrador de paquetes:

PM> Install-Package morelinq

NOTA: Incluyo esta respuesta para completar ya que el OP no mencionó cuál es la fuente de datos y no debemos hacer suposiciones.

Esta consulta da la respuesta correcta, pero podría ser más lenta ya que podría tener que ordenar todos los elementos People, según la estructura de datos People:

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

ACTUALIZACIÓN: En realidad, no debería llamar a esta solución "ingenua", pero el usuario necesita saber contra qué está consultando. La "lentitud" de esta solución depende de los datos subyacentes. Si se trata de una matriz o List<T>, entonces LINQ to Objects no tiene más remedio que ordenar la colección completa primero antes de seleccionar el primer elemento. En este caso será más lento que la otra solución sugerida. Sin embargo, si esta es una tabla LINQ to SQL y DateOfBirthes una columna indexada, SQL Server usará el índice en lugar de ordenar todas las filas. Otros personalizados IEnumerable<T>implementaciones también pueden hacer uso de índices (ver i4o: indexado LINQ , o la base de datos de objetos db4o ) y hacer de esta solución más rápida que Aggregate()o MaxBy()/MinBy()que necesitan iterar toda la colección una vez. De hecho, LINQ to Objects podría (en teoría) haber hecho casos especiales OrderBy()para colecciones ordenadas como SortedList<T>, pero, por lo que sé, no lo hace.

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

Haría el truco

Entonces estás pidiendo ArgMino ArgMax. C # no tiene una API integrada para esos.

He estado buscando una manera limpia y eficiente (O (n) a tiempo) de hacer esto. Y creo que encontré uno:

La forma general de este patrón es:

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

Especialmente, usando el ejemplo en la pregunta original:

Para C # 7.0 y superior que admite la tupla de valor :

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

Para la versión C # anterior a la 7.0, se puede usar el tipo anónimo en su lugar:

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

Trabajan porque ambos tuple de valor y tipo anónimo tienen comparadores sensibles predeterminados: para (x1, y1) y (x2, y2), primero se compara x1frente x2, entonces y1vs y2. Es por eso que el incorporado .Minse puede usar en esos tipos.

Y dado que tanto el tipo anónimo como la tupla de valor son tipos de valor, ambos deberían ser muy eficientes.

NOTA

En mis ArgMinimplementaciones anteriores , asumí DateOfBirthque tomaba el tipo DateTimede letra por simplicidad y claridad. La pregunta original pide excluir esas entradas con DateOfBirthcampo nulo :

Los valores nulos de DateOfBirth se establecen en DateTime.MaxValue para descartarlos de la consideración mínima (suponiendo que al menos uno tenga un DOB especificado).

Se puede lograr con un prefiltrado

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

Por lo tanto, no tiene importancia la cuestión de implementar ArgMino ArgMax.

NOTA 2

El enfoque anterior tiene la advertencia de que cuando hay dos instancias que tienen el mismo valor mínimo, la Min()implementación intentará comparar las instancias como un desempate. Sin embargo, si la clase de las instancias no se implementa IComparable, se generará un error de tiempo de ejecución:

Al menos un objeto debe implementar IComparable

Afortunadamente, esto todavía se puede arreglar de manera bastante limpia. La idea es asociar una "ID" distante con cada entrada que sirva como un desempate inequívoco. Podemos usar una identificación incremental para cada entrada. Todavía usando la edad de las personas como ejemplo:

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

Solución sin paquetes adicionales:

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

También puedes envolverlo en extensión:

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

y en este caso:

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

Por cierto ... O (n ^ 2) no es la mejor solución. Paul Betts dio una solución más rica que la mía. Pero mi sigue siendo la solución LINQ y es más simple y más corta que otras soluciones aquí.

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

Uso perfectamente simple de agregado (equivalente a doblar en otros idiomas):

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

El único inconveniente es que se accede a la propiedad dos veces por elemento de secuencia, lo que podría ser costoso. Eso es difícil de arreglar.

La siguiente es la solución más genérica. Básicamente hace lo mismo (en orden O (N)) pero en cualquier tipo IEnumberable y puede mezclarse con tipos cuyos selectores de propiedades podrían devolver nulo.

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

Pruebas:

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

EDITAR de nuevo:

Lo siento. Además de perder el anulable, estaba mirando la función incorrecta,

Min <(Of <(TSource, TResult>)>) (IEnumerable <(Of <(TSource>)>), Func <(Of <(TSource, TResult>)>)) devuelve el tipo de resultado como usted dijo.

Diría que una posible solución es implementar IComparable y usar Min <(Of <(TSource>)>) (IEnumerable <(Of <(TSource>)>)) , que realmente devuelve un elemento de IEnumerable. Por supuesto, eso no te ayuda si no puedes modificar el elemento. Encuentro el diseño de MS un poco extraño aquí.

Por supuesto, siempre puede hacer un bucle for si lo necesita, o usar la implementación de MoreLINQ que dio Jon Skeet.

Otra implementación, que podría funcionar con teclas de selección anulables, y para la recopilación del tipo de referencia devuelve nulo si no se encuentran elementos adecuados. Esto podría ser útil luego de procesar los resultados de la base de datos, por ejemplo.

  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;
    }
  }

Ejemplo:

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

Estaba buscando algo similar yo mismo, preferiblemente sin usar una biblioteca o ordenar toda la lista. Mi solución terminó similar a la pregunta en sí, simplemente simplificada un poco.

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