Minimum veya maksimum özellik değeri olan nesneyi seçmek için LINQ nasıl kullanılır

Nullable DateOfBirth özelliği olan bir Person nesnesi var. En erken / en küçük DateOfBirth değerine sahip bir Kişi nesneleri listesini sorgulamak için LINQ kullanmanın bir yolu var mı.

İşte bunlarla başladım:

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

Boş DateOfBirth değerleri, bunları Min değerlendirmesinin dışında bırakmak için DateTime.MaxValue olarak ayarlanır (en az bir tanesinin belirli bir DOB'u olduğu varsayılarak).

Ama benim için tek yapmanız gereken firstBornDate öğesini bir DateTime değerine ayarlamak. Almak istediğim, buna uyan Kişi nesnesidir. Bunun gibi ikinci bir sorgu yazmak gerekir mi:

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

Yoksa bunu yapmak için daha yalın bir yol var mı?

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

Ne yazık ki, bunu yapmak için yerleşik bir yöntem yoktur, ancak kendiniz için uygulamak yeterince kolaydır. İşte bunun cesaretleri:

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

Örnek kullanım:

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

Sekans boşsa bunun bir istisna atacağını ve birden fazla varsa ilk öğeyi minimum değerle döndüreceğini unutmayın .

Alternatif olarak, biz var uygulanmasını kullanabilirsiniz MoreLINQ içinde, MinBy.cs . ( MaxByElbette buna karşılık gelen bir şey var .)

Paket yöneticisi konsolu üzerinden yükleme:

PM> Kurulum Paketi morelinq

NOT: OP'nin veri kaynağının ne olduğundan bahsetmediği ve herhangi bir varsayımda bulunmamamız gerektiği için bu cevabı tamlık için ekliyorum.

Bu sorgu doğru yanıtı verir, ancak veri yapısının ne olduğuna bağlı olarak tüm öğeleri sıralamak zorunda kalabileceğinden daha yavaş olabilir :PeoplePeople

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

GÜNCELLEME: Aslında bu çözümü "saf" dememeliyim, ancak kullanıcının neye karşı sorguladığını bilmesine gerek yok. Bu çözümün "yavaşlığı" temel verilere bağlıdır. Bu bir dizi veya List<T>daha sonra, LINQ to Objects seçeneği, ilk öğeyi seçmeden önce tüm koleksiyonu sıralamaktan başka bir seçeneğe sahip değildir. Bu durumda önerilen diğer çözümden daha yavaş olacaktır. Ancak, bu bir LINQ to SQL tablosu ve DateOfBirthdizinli bir sütun ise, SQL Server tüm satırları sıralamak yerine dizini kullanır. Diğer özel IEnumerable<T>uygulamalar da dizinleri kullanabilir (bkz. İ4o: Dizinlenmiş LINQ veya nesne veritabanı db4o ) ve bu çözümü Aggregate()veya MaxBy()/MinBy()tüm koleksiyonu bir kez yinelemek gerekiyor. Aslında, Nesneler için LINQ (teorik olarak) OrderBy()gibi sıralanmış koleksiyonlar için özel durumlar yapabilirdi SortedList<T>, ama bildiğim kadarıyla değil.

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

Hile yapmak

Demek istiyorsun ArgMinya da ArgMax. C # için bunlar için yerleşik bir API yoktur.

Bunu yapmak için temiz ve verimli (O (n) zamanında) bir yol arıyordum. Ve sanırım birini buldum:

Bu desenin genel formu:

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

Özellikle, orijinal sorudaki örneği kullanarak:

Değer demetini destekleyen C # 7.0 ve üstü için :

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

7.0'dan önceki C # sürümü için bunun yerine anonim tür kullanılabilir:

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

Değer tanımlama grubu ve anonim tip hem mantıklı varsayılan comparers var çünkü çalışmak: (x1, y1) ve (x2, y2) için, ilk karşılaştırır x1vs x2sonra, y1vs y2. Bu yüzden yerleşik .Minbu türlerde kullanılabilir.

Hem anonim tür hem de değer grubu değer türleri olduğu için ikisi de çok verimli olmalıdır.

NOT

Benim yukarıda yılında ArgMinuygulamalarda ben kabul DateOfBirthtipini almaya DateTimesadelik ve netlik için. Orijinal soru, boş DateOfBirthalana sahip girişleri hariç tutmanızı ister :

Boş DateOfBirth değerleri, bunları Min değerlendirmesinin dışında bırakmak için DateTime.MaxValue olarak ayarlanır (en az bir tanesinin belirli bir DOB'u olduğu varsayılarak).

Ön filtreleme ile elde edilebilir

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

Yani, uygulama ArgMinya da ArgMax.

NOT 2

Yukarıdaki yaklaşım, aynı min değerine sahip iki örnek olduğunda, Min()uygulamanın örnekleri bir bağlantı kesici olarak karşılaştırmaya çalışacağına dair bir uyarı verir . Ancak, örneklerin sınıfı uygulanmazsa IComparable, bir çalışma zamanı hatası atılır:

En az bir nesne IComparable uygulamalıdır

Neyse ki, bu hala temiz bir şekilde düzeltilebilir. Fikir uzak bir "ID" yi, açık bir bağlayıcı-kırıcı görevi gören her bir girişle ilişkilendirmektir. Her giriş için artımlı bir kimlik kullanabiliriz. Hala insanların yaşını örnek olarak kullanıyorum:

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

Ek paket içermeyen çözüm:

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

ayrıca uzatma içine sarabilirsiniz:

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

ve bu durumda:

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

Bu arada ... O (n ^ 2) en iyi çözüm değil. Paul Betts benden daha yağlı bir çözüm verdi. Ama benim hala LINQ çözümü ve buradaki diğer çözümlerden daha basit ve daha kısa.

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

Agregatın mükemmel derecede basit kullanımı (diğer dillerde katlanmaya eşdeğer):

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

Tek dezavantajı, özelliğe dizi öğesi başına iki kez erişilmesidir, bu da pahalı olabilir. Bunu düzeltmek zor.

Aşağıdakiler daha genel bir çözümdür. Aslında aynı şeyi (O (N) sırayla) yapar, ancak herhangi bir IEnumberable türünde ve özellik seçicileri null dönebilen türlerle karıştırılabilir.

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

Testler:

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

Tekrar DÜZENLE:

Afedersiniz. Yanlış fonksiyona baktığım nullable'ı kaçırmanın yanı sıra,

Min <(Of <(TSource, TResult>)>) (IEnumerable <(Of <(TSource>)>), Func <(Of <(TSource, TResult>)>)) sonuç türünü söylediğiniz gibi döndürür.

Ben olası bir çözüm IComparable uygulamak ve gerçekten IEnumerable bir öğe döndürür Min <(Of <(TSource>)>) (IEnumerable <(Of <(TSource>)>)) kullanmak olduğunu söyleyebilirim . Elbette, öğeyi değiştiremezseniz size yardımcı olmaz. MS'in tasarımını burada biraz garip buluyorum.

Tabii ki, ihtiyacınız varsa her zaman bir for döngüsü yapabilirsiniz veya Jon Skeet'in verdiği MoreLINQ uygulamasını kullanabilirsiniz.

Null edilebilir seçici anahtarlarla çalışabilen ve başvuru türü koleksiyonu için uygun bir öğe bulunamazsa başka bir uygulama null değerini döndürür. Bu, örneğin veritabanı sonuçlarının işlenmesinde yardımcı olabilir.

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

Misal:

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

Aşağıdaki fikri deneyin:

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

Tercihen bir kütüphane kullanmadan veya tüm listeyi sıralamaksızın kendime benzer bir şey arıyordum. Benim çözümüm sorunun kendisine benzedi, sadece basitleştirildi.

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