Comment utiliser LINQ pour sélectionner un objet avec une valeur de propriété minimale ou maximale

J'ai un objet Person avec une propriété Nullable DateOfBirth. Existe-t-il un moyen d'utiliser LINQ pour interroger une liste d'objets Person pour celui avec la valeur DateOfBirth la plus ancienne / la plus petite.

Voici ce que j'ai commencé avec:

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

Les valeurs Null DateOfBirth sont définies sur DateTime.MaxValue afin de les exclure de la considération Min (en supposant qu'au moins une a un DOB spécifié).

Mais tout ce que cela fait pour moi, c'est de définir firstBornDate sur une valeur DateTime. Ce que j'aimerais obtenir, c'est l'objet Personne qui correspond à cela. Dois-je écrire une deuxième requête comme ceci:

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

Ou existe-t-il une façon plus simple de le faire?

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

Malheureusement, il n'y a pas de méthode intégrée pour le faire, mais c'est assez facile à mettre en œuvre par vous-même. En voici les tripes:

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

Exemple d'utilisation:

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

Notez que cela lèvera une exception si la séquence est vide et retournera le premier élément avec la valeur minimale s'il y en a plus d'un.

Alternativement, vous pouvez utiliser l'implémentation que nous avons dans MoreLINQ , dans MinBy.cs . (Il y a un correspondant MaxBy, bien sûr.)

Installer via la console du gestionnaire de packages:

PM> Install-Package morelinq

REMARQUE: J'inclus cette réponse pour être complet car le PO n'a pas mentionné la source des données et nous ne devons faire aucune hypothèse.

Cette requête donne la bonne réponse, mais peut être plus lente car elle peut devoir trier tous les éléments People, selon la structure des données People:

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

MISE À JOUR: En fait, je ne devrais pas appeler cette solution "naïve", mais l'utilisateur a besoin de savoir contre quoi il interroge. La «lenteur» de cette solution dépend des données sous-jacentes. S'il s'agit d'un tableau ou List<T>, alors LINQ to Objects n'a pas d'autre choix que de trier la collection entière avant de sélectionner le premier élément. Dans ce cas, il sera plus lent que l'autre solution suggérée. Toutefois, s'il s'agit d'une table LINQ to SQL et d' DateOfBirthune colonne indexée, SQL Server utilisera l'index au lieu de trier toutes les lignes. D'autres IEnumerable<T>implémentations personnalisées pourraient également utiliser des index (voir i4o: LINQ indexé ou la base de données d'objets db4o ) et rendre cette solution plus rapide que Aggregate()ou MaxBy()/MinBy()qui ont besoin d'itérer la collection entière une fois. En fait, LINQ to Objects aurait pu (en théorie) créer des cas spéciaux OrderBy()pour des collections triées comme SortedList<T>, mais ce n'est pas le cas, à ma connaissance.

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

Ferait l'affaire

Vous demandez donc ArgMinou ArgMax. C # n'a pas d'API intégrée pour ceux-ci.

Je cherchais un moyen propre et efficace (O (n) dans le temps) de le faire. Et je pense que j'en ai trouvé un:

La forme générale de ce modèle est:

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

Surtout, en utilisant l'exemple de la question d'origine:

Pour C # 7.0 et supérieur qui prend en charge le tuple de valeur :

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

Pour la version C # antérieure à 7.0, le type anonyme peut être utilisé à la place:

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

Ils travaillent parce que les deux tuple de valeur et le type anonyme ont par défaut sensées comparateurs: pour (x1, y1) et (x2, y2), il compare d' abord x1vs x2, puis y1vs y2. C'est pourquoi le intégré .Minpeut être utilisé sur ces types.

Et comme le type anonyme et le tuple de valeur sont tous deux des types de valeur, ils devraient être tous deux très efficaces.

REMARQUE

Dans mes ArgMinimplémentations ci-dessus, j'ai supposé DateOfBirthprendre le type DateTimepour plus de simplicité et de clarté. La question d'origine demande d'exclure ces entrées avec un DateOfBirthchamp nul :

Les valeurs Null DateOfBirth sont définies sur DateTime.MaxValue afin de les exclure de la considération Min (en supposant qu'au moins une a un DOB spécifié).

Il peut être réalisé avec un pré-filtrage

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

C'est donc sans importance pour la question de la mise en œuvre de ArgMinou ArgMax.

NOTE 2

L'approche ci-dessus a une mise en garde: lorsque deux instances ont la même valeur minimale, l' Min()implémentation essaiera de comparer les instances en tant que bris d'égalité. Cependant, si la classe des instances n'est pas implémentée IComparable, une erreur d'exécution sera levée:

Au moins un objet doit implémenter IComparable

Heureusement, cela peut encore être résolu de manière assez nette. L'idée est d'associer un "ID" distanct à chaque entrée qui sert de bris d'égalité sans ambiguïté. Nous pouvons utiliser un ID incrémentiel pour chaque entrée. En utilisant toujours l'âge des gens comme exemple:

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

Solution sans packages supplémentaires:

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

vous pouvez également l'envelopper dans l'extension:

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

et dans ce cas:

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

Au fait ... O (n ^ 2) n'est pas la meilleure solution. Paul Betts a donné une solution plus grosse que la mienne. Mais ma solution est toujours LINQ et elle est plus simple et plus courte que les autres solutions ici.

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

Utilisation parfaitement simple de l'agrégat (équivalent à se plier dans d'autres langues):

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

Le seul inconvénient est que la propriété est accessible deux fois par élément de séquence, ce qui peut être coûteux. C'est difficile à résoudre.

Voici la solution la plus générique. Il fait essentiellement la même chose (dans l'ordre O (N)) mais sur tous les types IEnumberable et peut être mélangé avec des types dont les sélecteurs de propriété pourraient retourner 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;
        });
    }
}

Tests:

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

MODIFIER à nouveau:

Désolé. En plus de manquer la valeur nulle, je regardais la mauvaise fonction,

Min <(Of <(TSource, TResult>)>) (IEnumerable <(Of <(TSource>)>), Func <(Of <(TSource, TResult>)>)) renvoie le type de résultat comme vous l'avez dit.

Je dirais qu'une solution possible est d'implémenter IComparable et d'utiliser Min <(Of <(TSource>)>) (IEnumerable <(Of <(TSource>)>)) , qui retourne vraiment un élément de IEnumerable. Bien sûr, cela ne vous aide pas si vous ne pouvez pas modifier l'élément. Je trouve le design de MS un peu bizarre ici.

Bien sûr, vous pouvez toujours faire une boucle for si vous en avez besoin, ou utiliser l'implémentation MoreLINQ de Jon Skeet.

Une autre implémentation, qui pourrait fonctionner avec des clés de sélection nullables, et pour la collection de type de référence, renvoie null si aucun élément approprié n'a été trouvé. Cela pourrait être utile pour le traitement des résultats de la base de données par exemple.

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

Exemple:

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

Essayez l'idée suivante:

var firstBornDate = People.GroupBy(p => p.DateOfBirth).Min(g => g.Key).FirstOrDefault();

Je cherchais quelque chose de similaire moi-même, de préférence sans utiliser de bibliothèque ou trier la liste entière. Ma solution a fini par ressembler à la question elle-même, juste un peu simplifiée.

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