Maksimum veya Varsayılan?

Satır döndürmeyen bir LINQ sorgusundan Max değerini almanın en iyi yolu nedir? Sadece yaparsam

Dim x = (From y In context.MyTable _
         Where y.MyField = value _
         Select y.MyCounter).Max

Sorgu hiçbir satır döndürmediğinde bir hata alıyorum. Yapabilirim

Dim x = (From y In context.MyTable _
         Where y.MyField = value _
         Select y.MyCounter _
         Order By MyCounter Descending).FirstOrDefault

ama bu böylesine basit bir istek için biraz küstahlık hissi veriyor. Bunu yapmanın daha iyi bir yolunu mu kaçırıyorum?

GÜNCELLEME: İşte arka hikaye: Bir alt tablodan bir sonraki uygunluk sayacını almaya çalışıyorum (eski sistem, beni başlatma ...). Her hasta için ilk uygunluk sırası her zaman 1'dir, ikincisi 2'dir, vb. (Açıkçası bu alt tablonun birincil anahtarı değildir). Bu nedenle, bir hasta için mevcut maksimum sayaç değerini seçiyorum ve sonra yeni bir satır oluşturmak için buna 1 ekliyorum. Mevcut bir alt değer olmadığında, 0 döndürmek için sorguya ihtiyacım var (böylece 1 ekleyerek bana 1 sayaç değeri verecek). Eski uygulama sayaç değerlerinde boşluklar (olası) içeriyorsa, alt satırların ham sayısına güvenmek istemediğimi unutmayın. Soruyu çok genel yapmaya çalıştığım için üzüldüm.

Yana DefaultIfEmptyLINQ SQL için uygulanmadı, ben iade hata üzerinde arama yaptı ve bir buldum büyüleyici makale toplam işlevleri null setleri ile fırsatlar olduğunu. Bulduğumu özetlemek için, seçiminiz dahilindeki boş bir karaktere döküm yaparak bu sınırlamanın üstesinden gelebilirsiniz. Benim VB biraz paslı, ama bence böyle bir şey gitmek istiyorum:

Dim x = (From y In context.MyTable _
         Where y.MyField = value _
         Select CType(y.MyCounter, Integer?)).Max

Veya C # ile:

var x = (from y in context.MyTable
         where y.MyField == value
         select (int?)y.MyCounter).Max();

Ben sadece benzer bir sorun vardı, ama bir sorguda sözdizimi yerine LINQ uzantısı yöntemleri kullanıyordum. Nullable numarasına döküm burada da çalışır:

int max = list.Max(i => (int?)i.MyCounter) ?? 0;

Bir davaya benziyor DefaultIfEmpty(test edilmemiş kod takip ediyor):

Dim x = (From y In context.MyTable _
         Where y.MyField = value _
         Select y.MyCounter).DefaultIfEmpty.Max

Ne istediğini düşün!

En fazla {1, 2, 3, -1, -2, -3} 3'tür. En fazla {2} en fazla 2'dir. Ama boş kümenin maksimum değeri {} nedir? Açıkçası bu anlamsız bir soru. Boş kümenin maksimum değeri basitçe tanımlanmamıştır. Cevap almaya çalışmak matematiksel bir hatadır. Herhangi bir kümenin maksimum değeri, bu kümedeki bir öğe olmalıdır. Boş kümenin hiçbir öğesi yoktur, bu nedenle belirli bir sayının bu kümede bulunmadan o kümenin maksimum değeri olduğunu iddia etmek matematiksel bir çelişkidir.

Tıpkı programcı sıfıra bölünmesini istediğinde bilgisayarın bir istisna atması gibi doğru bir davranış olduğu gibi, programcı boş kümenin maks. Değerini almasını istediğinde bilgisayarın bir istisna atması doğru bir davranıştır. Sıfıra bölme, boş kümenin maksimumunu almak, spacklerorke'yi kıpırdatmak ve uçan tek boynuzlu atı Neverland'a sürmek anlamsız, imkansız, tanımsızdır.

Şimdi, gerçekte ne yapmak istiyorsunuz?

Diziye her zaman ekleyebilirsiniz Double.MinValue. Bu, en az bir elemanın olmasını ve Maxsadece asgari olması durumunda onu döndürmesini sağlayacaktır. Daha verimlidir (hangi seçeneği belirlemek için Concat, FirstOrDefaultya Take(1)), Yeterli kıyaslama gerçekleştirmelidir.

double x = context.MyTable
    .Where(y => y.MyField == value)
    .Select(y => y.MyCounter)
    .Concat(new double[]{Double.MinValue})
    .Max();

int max = list.Any() ? list.Max(i => i.MyCounter) : 0;

Listede herhangi bir öğe varsa (boş değil), Sayım Alanımın maksimumu alır, aksi takdirde 0 döndürür.

Net 3.5'ten beri, varsayılan değeri bağımsız değişken olarak ileten DefaultIfEmpty () kullanabilirsiniz. Aşağıdaki yollardan biri gibi bir şey:

int max = (from e in context.Table where e.Year == year select e.RecordNumber).DefaultIfEmpty(0).Max();
DateTime maxDate = (from e in context.Table where e.Year == year select e.StartDate ?? DateTime.MinValue).DefaultIfEmpty(DateTime.MinValue).Max();

Birincisi NOT NULL sütununu sorguladığınızda izin verilir ve ikincisi NULLABLE sütununu sorgulamak için kullanılan yöntemdir. DefaultIfEmpty () öğesini bağımsız değişkenler olmadan kullanırsanız, varsayılan değerler, Varsayılan Değerler Tablosunda görebileceğiniz gibi, çıktı türünüz için tanımlanan değer olacaktır .

Ortaya çıkan SELECT çok zarif olmayacak, ancak kabul edilebilir.

Umarım yardımcı olur.

Sorunun hiçbir sonuç olmadığında ne olmasını istediğinizi düşünüyorum. Bu istisnai bir durumda, ben bir try / catch bloğundaki sorguyu sarmak ve standart sorgu oluşturur istisna işlemek. Sorgunun hiçbir sonuç döndürmemesi uygunsa, o durumda sonucun ne olmasını istediğinizi bulmanız gerekir. @ David'in cevabı olabilir (veya benzer bir şey işe yarayabilir). Yani, MAX her zaman pozitif olacaksa, listeye yalnızca hiçbir sonuç yoksa seçilecek bilinen bir "kötü" değer eklemek yeterli olabilir. Genel olarak, üzerinde çalışmak için bazı veriler olması için maksimum alan bir sorgu beklerdim ve aksi takdirde her zaman elde ettiğiniz değerin doğru olup olmadığını kontrol etmek zorunda olduğu gibi denemek / yakalamak yol gitmek istiyorum. BEN'

Try
   Dim x = (From y In context.MyTable _
            Where y.MyField = value _
            Select y.MyCounter).Max
   ... continue working with x ...
Catch ex As SqlException
       ... do error processing ...
End Try

Başka bir olasılık, ham SQL'de nasıl yaklaşabileceğinize benzer şekilde gruplama olabilir:

from y in context.MyTable
group y.MyCounter by y.MyField into GrpByMyField
where GrpByMyField.Key == value
select GrpByMyField.Max()

Tek şey (tekrar LINQPad'de test etmek) VB LINQ lezzetine geçmek, gruplama cümlesinde sözdizimi hataları verir. Eminim kavramsal eşdeğer bulabilecek kadar kolaydır, sadece VB'ye nasıl yansıtacağımı bilmiyorum.

Oluşturulan SQL, aşağıdaki satırlarda bir şey olacaktır:

SELECT [t1].[MaxValue]
FROM (
    SELECT MAX([t0].[MyCounter) AS [MaxValue], [t0].[MyField]
    FROM [MyTable] AS [t0]
    GROUP BY [t0].[MyField]
    ) AS [t1]
WHERE [t1].[MyField] = @p0

İç içe SELECT, sorgu yürütme tüm satırları alır gibi geri alınan kümeden eşleşen birini seçer gibi icky görünüyor ... soru SQL Server sorgu iç SELECT için nereye yan tümcesini uygulamak karşılaştırılabilir bir şey optimize olup olmadığını sorusudur. Şimdi bakıyorum ...

SQL Server'da yürütme planlarını yorumlama konusunda bilgili değilim, ancak WHERE yan tümcesi dış SELECT'te olduğunda, bu adımda elde edilen gerçek satırların sayısı, yalnızca eşleşen satırlara göre tablodaki tüm satırlardır. WHERE yan tümcesi iç SELECT öğesinde olduğunda. Bununla birlikte, tüm satırlar dikkate alındığında sadece% 1 maliyetin aşağıdaki adıma kaydırıldığı ve her iki şekilde de sadece bir satırın SQL Server'dan geri geldiği görülüyor, bu yüzden belki de şeylerin büyük şemasında büyük bir fark yok .

Geç kaldım, ama aynı endişem vardı ...

Kodunuzu orijinal gönderiden yeniden sildiğinizde, S kümesinin maks.

(From y In context.MyTable _
 Where y.MyField = value _
 Select y.MyCounter)

Son yorumunuzu dikkate alarak

Aralarından seçim yapabileceğiniz hiçbir kayıt olmadığında 0'ı istediğimi biliyorum, ki bu da nihai çözüm üzerinde kesinlikle bir etkiye sahip

Sorununuzu şu şekilde yeniden ifade edebilirim: Maksimum {0 + S} istiyorsunuz. Ve concat ile önerilen çözüm semantik doğru olanı gibi görünüyor :-)

var max = new[]{0}
          .Concat((From y In context.MyTable _
                   Where y.MyField = value _
                   Select y.MyCounter))
          .Max();

Neden daha doğrudan bir şey değil:

Dim x = context.MyTable.Max(Function(DataItem) DataItem.MyField = Value)

Dikkat çekilmesi gereken ilginç bir fark, FirstOrDefault ve Take (1) aynı SQL'i oluştururken (yine de LINQPad'e göre), FirstOrDefault'un eşleşen bir satır olmadığında ve Take (1) döndürdüğünde bir değer döndürmesi sonuç yok ... en azından LINQPad'de.

Sadece orada herkesin Linq to Entities kullandığını bilmesini sağlamak için yukarıdaki yöntemler işe yaramaz ...

Eğer böyle bir şey yapmaya çalışırsanız

var max = new[]{0}
      .Concat((From y In context.MyTable _
               Where y.MyField = value _
               Select y.MyCounter))
      .Max();

Bir istisna atar:

System.NotSupportedException: 'NewArrayInit' LINQ ifade düğümü türü LINQ to Entities'de desteklenmiyor.

Sadece yapmayı öneririm

(From y In context.MyTable _
                   Where y.MyField = value _
                   Select y.MyCounter))
          .OrderByDescending(x=>x).FirstOrDefault());

Ve FirstOrDefaultlisteniz boşsa 0 döndürecektir.

decimal Max = (decimal?)(context.MyTable.Select(e => e.MyCounter).Max()) ?? 0;

Bir MaxOrDefaultuzatma yöntemi çaldım . Çok fazla bir şey yok, ancak Intellisense'deki varlığı, Maxboş bir dizide istisnaya neden olacağına dair faydalı bir hatırlatmadır . Ayrıca, yöntem gerekirse varsayılanın belirtilmesine izin verir.

    public static TResult MaxOrDefault<TSource, TResult>(this 
    IQueryable<TSource> source, Expression<Func<TSource, TResult?>> selector,
    TResult defaultValue = default (TResult)) where TResult : struct
    {
        return source.Max(selector) ?? defaultValue;
    }

Entity Framework ve Linq to SQL için bunu, yönteme Expressiongeçirilen bir modifiye eden bir uzantı yöntemi tanımlayarak başarabiliriz IQueryable<T>.Max(...):

static class Extensions
{
    public static TResult MaxOrDefault<T, TResult>(this IQueryable<T> source, 
                                                   Expression<Func<T, TResult>> selector)
        where TResult : struct
    {
        UnaryExpression castedBody = Expression.Convert(selector.Body, typeof(TResult?));
        Expression<Func<T, TResult?>> lambda = Expression.Lambda<Func<T,TResult?>>(castedBody, selector.Parameters);
        return source.Max(lambda) ?? default(TResult);
    }
}

Kullanımı:

int maxId = dbContextInstance.Employees.MaxOrDefault(employee => employee.Id);
// maxId is equal to 0 if there is no records in Employees table

Oluşturulan sorgu aynıdır, tıpkı IQueryable<T>.Max(...)yönteme normal bir çağrı gibi çalışır , ancak kayıt yoksa bir istisna atmak yerine T türünün varsayılan değerini döndürür

Benzer bir sorun yaşadım, birim testlerim Max () kullanarak geçti ancak canlı bir veritabanına karşı çalıştırıldığında başarısız oldu.

Benim çözüm, sorgu tek bir sorguda katılmak değil, gerçekleştirilen mantık ayırmak oldu.
Canlı bir ortamda yürütürken Linq-objects (Linq-objects Max () nulls ile çalışır) ve Linq-sql kullanarak birim testleri çalışmak için bir çözüm gerekiyordu.

(Testlerimde Select () ile alay ediyorum)

var requiredDataQuery = _dataRepo.Select(x => new { x.NullableDate1, .NullableDate2 }); 
var requiredData.ToList();
var maxDate1 = dates.Max(x => x.NullableDate1);
var maxDate2 = dates.Max(x => x.NullableDate2);

Daha az verimli mi? Muhtemelen.

Uygulamam bir dahaki sefere düşmediği sürece umurumda mı? Hayır!