Verwendung von LINQ zur Auswahl eines Objekts mit minimalem oder maximalem Eigenschaftswert

Ich habe ein Personenobjekt mit einer Nullable DateOfBirth-Eigenschaft. Gibt es eine Möglichkeit, mit LINQ eine Liste von Personenobjekten für das Objekt mit dem frühesten / kleinsten DateOfBirth-Wert abzufragen?

Folgendes habe ich begonnen:

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

Null DateOfBirth-Werte werden auf DateTime.MaxValue gesetzt, um sie aus der Min-Betrachtung auszuschließen (vorausgesetzt, mindestens einer hat ein angegebenes DOB).

Für mich bedeutet das jedoch nur, firstBornDate auf einen DateTime-Wert zu setzen. Was ich erhalten möchte, ist das Person-Objekt, das dazu passt. Muss ich eine zweite Abfrage wie folgt schreiben:

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

Oder gibt es einen schlankeren Weg, dies zu tun?

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

Leider gibt es dafür keine integrierte Methode, aber es ist einfach genug, sie selbst zu implementieren. Hier sind die Eingeweide davon:

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

Anwendungsbeispiel:

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

Beachten Sie, dass dies eine Ausnahme auslöst, wenn die Sequenz leer ist, und das erste Element mit dem Minimalwert zurückgibt, wenn es mehr als ein Element gibt.

Alternativ können Sie die Implementierung verwenden, die wir in MoreLINQ in MinBy.cs haben . (Es gibt MaxBynatürlich eine entsprechende .)

Installation über die Paketmanager-Konsole:

PM> Install-Package morelinq

HINWEIS: Der Vollständigkeit halber füge ich diese Antwort hinzu, da das OP die Datenquelle nicht erwähnt hat und wir keine Annahmen treffen sollten.

Diese Abfrage gibt die richtige Antwort, kann jedoch langsamer sein, da je nach Datenstruktur möglicherweise alle Elemente sortiert werden müssen :PeoplePeople

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

UPDATE: Eigentlich sollte ich diese Lösung nicht "naiv" nennen, aber der Benutzer muss wissen, gegen was er abfragt. Die "Langsamkeit" dieser Lösung hängt von den zugrunde liegenden Daten ab. Wenn dies ein Array oder ist List<T>, hat LINQ to Objects keine andere Wahl, als zuerst die gesamte Sammlung zu sortieren, bevor das erste Element ausgewählt wird. In diesem Fall ist es langsamer als die andere vorgeschlagene Lösung. Wenn es sich jedoch um eine LINQ to SQL-Tabelle und DateOfBirtheine indizierte Spalte handelt, verwendet SQL Server den Index, anstatt alle Zeilen zu sortieren. Andere benutzerdefinierte IEnumerable<T>Implementierungen könnten ebenfalls Indizes verwenden (siehe i4o: Indexed LINQ oder die Objektdatenbank db4o ) und diese Lösung schneller als Aggregate()oder MaxBy()/ machenMinBy()die die gesamte Sammlung einmal iterieren müssen. Tatsächlich hätte LINQ to Objects (theoretisch) Sonderfälle OrderBy()für sortierte Sammlungen wie machen können SortedList<T>, aber meines Wissens nicht.

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

Würde den Trick machen

Sie fragen also nach ArgMinoder ArgMax. C # hat keine integrierte API für diese.

Ich habe nach einem sauberen und effizienten (O (n) in der Zeit) Weg gesucht, um dies zu tun. Und ich glaube, ich habe einen gefunden:

Die allgemeine Form dieses Musters ist:

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

Insbesondere anhand des Beispiels in der ursprünglichen Frage:

Für C # 7.0 und höher unterstützt das Wertetupel :

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

Für die C # -Version vor 7.0 kann stattdessen ein anonymer Typ verwendet werden:

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

Sie funktionieren, weil sowohl Wertetupel als auch anonymer Typ sinnvolle Standardvergleiche haben: Für (x1, y1) und (x2, y2) werden zuerst x1vs x2und dann y1vs verglichen y2. Aus diesem Grund .Minkann das integrierte Gerät für diese Typen verwendet werden.

Und da sowohl anonymer Typ als auch Wertetupel Werttypen sind, sollten beide sehr effizient sein.

HINWEIS

In meinen obigen ArgMinImplementierungen habe ich aus Gründen der Einfachheit und Klarheit angenommen DateOfBirth, dass der Typ verwendet wird DateTime. In der ursprünglichen Frage werden die Einträge mit dem Nullfeld ausgeschlossen DateOfBirth:

Null DateOfBirth-Werte werden auf DateTime.MaxValue gesetzt, um sie aus der Min-Betrachtung auszuschließen (vorausgesetzt, mindestens einer hat ein angegebenes DOB).

Dies kann mit einer Vorfilterung erreicht werden

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

Es ist also unerheblich für die Frage der Implementierung ArgMinoder ArgMax.

ANMERKUNG 2

Der obige Ansatz hat die Einschränkung, dass die Min()Implementierung versucht, die Instanzen als Tie-Breaker zu vergleichen , wenn zwei Instanzen denselben Min-Wert haben . Wenn die Klasse der Instanzen jedoch nicht implementiert wird IComparable, wird ein Laufzeitfehler ausgegeben:

Mindestens ein Objekt muss IComparable implementieren

Zum Glück kann dies noch recht sauber behoben werden. Die Idee ist, jedem Eintrag, der als eindeutiger Krawattenbrecher dient, eine entfernte "ID" zuzuordnen. Wir können für jeden Eintrag eine inkrementelle ID verwenden. Verwenden Sie immer noch das Alter der Menschen als Beispiel:

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

Lösung ohne zusätzliche Pakete:

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

Sie können es auch in eine Erweiterung einwickeln:

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

und in diesem Fall:

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

Übrigens ... O (n ^ 2) ist nicht die beste Lösung. Paul Betts gab Fatster-Lösung als meine. Aber meine Lösung ist immer noch LINQ und sie ist einfacher und kürzer als andere Lösungen hier.

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

Perfekt einfache Verwendung des Aggregats (entspricht dem Falten in anderen Sprachen):

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

Der einzige Nachteil ist, dass zweimal pro Sequenzelement auf die Eigenschaft zugegriffen wird, was teuer sein kann. Das ist schwer zu beheben.

Das Folgende ist die allgemeinere Lösung. Es macht im Wesentlichen dasselbe (in O (N) Reihenfolge), jedoch bei allen IEnumberable-Typen und kann mit Typen gemischt werden, deren Eigenschaftsauswahl null zurückgeben könnte.

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

Nochmals BEARBEITEN:

Es tut uns leid. Abgesehen davon, dass ich das Nullable vermisst habe, habe ich mir die falsche Funktion angesehen.

Min <(Of <(TSource, TResult>)>) (IEnumerable <(Of <(TSource>)>), Func <(Of <(TSource, TResult>)>)) gibt den Ergebnistyp wie gesagt zurück.

Ich würde sagen, eine mögliche Lösung besteht darin, IComparable zu implementieren und Min <(Of <(TSource>)>) (IEnumerable <(Of <(TSource>)>)) zu verwenden , das tatsächlich ein Element aus IEnumerable zurückgibt. Das hilft Ihnen natürlich nicht, wenn Sie das Element nicht ändern können. Ich finde das Design von MS hier etwas seltsam.

Natürlich können Sie bei Bedarf jederzeit eine for-Schleife ausführen oder die von Jon Skeet bereitgestellte MoreLINQ-Implementierung verwenden.

Eine andere Implementierung, die mit nullbaren Auswahlschlüsseln und für die Sammlung von Referenztypen arbeiten könnte, gibt null zurück, wenn keine geeigneten Elemente gefunden wurden. Dies kann beispielsweise bei der Verarbeitung von Datenbankergebnissen hilfreich sein.

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

Beispiel:

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

Ich habe selbst nach etwas Ähnlichem gesucht, vorzugsweise ohne eine Bibliothek zu benutzen oder die gesamte Liste zu sortieren. Meine Lösung endete ähnlich wie die Frage selbst, nur ein wenig vereinfacht.

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