LINQ: Hiçbiri Yok Hepsi Yok

Genellikle, sağlanan bir değerin bir listedeki değerle eşleşip eşleşmediğini kontrol etmek istiyorum (örn. Doğrulama yaparken):

if (!acceptedValues.Any(v => v == someValue))
{
    // exception logic
}

Son zamanlarda, ReSharper'ın bu sorguları basitleştirmemi istediğini fark ettim:

if (acceptedValues.All(v => v != someValue))
{
    // exception logic
}

Açıkçası, bu mantıksal olarak aynı, belki biraz daha okunabilir (çok fazla matematik yaptıysanız), sorum şu: bu bir performans isabetiyle sonuçlanıyor mu?

Olması gerektiği .Any()gibi geliyor (yani kısa devreler .All()gibi geliyor , oysa öyle değil), ama bunu doğrulayacak hiçbir şeyim yok. Sorguların aynı sorunu çözüp çözmeyeceği veya ReSharper'ın beni yanlış yönlendirip yönlendirmediği konusunda daha derin bilgiye sahip olan var mı?

AllILSpy'a göre uygulanması ( aslında olduğu gibi "iyi, bu yöntem biraz işe yarıyor ..." yerine, teorinin etkisini değil de tartışmayı düşünürsek yapabilirim).

public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    if (predicate == null)
    {
        throw Error.ArgumentNull("predicate");
    }
    foreach (TSource current in source)
    {
        if (!predicate(current))
        {
            return false;
        }
    }
    return true;
}

AnyILSpy'a göre uygulama :

public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    if (predicate == null)
    {
        throw Error.ArgumentNull("predicate");
    }
    foreach (TSource current in source)
    {
        if (predicate(current))
        {
            return true;
        }
    }
    return false;
}

Tabii ki, üretilen IL'de bazı ince farklar olabilir. Ama hayır, hayır yok. IL hemen hemen aynıdır, ancak yüklem eşleşmesinde doğru dönüşün, ters uyumsuzlukta yanlış döndürülmesinin bariz tersine çevrilmesi için.

Bu sadece nesneler için linq'tir. Diğer bazı linq sağlayıcılarının birine diğerinden çok daha iyi davranması mümkündür, ancak bu durumda, hangisinin daha uygun bir uygulamaya sahip olduğu oldukça rasgele.

Kuralın sadece if(determineSomethingTrue)daha basit ve daha okunabilir bir duyguya indiği anlaşılıyor if(!determineSomethingFalse). Ve adalet içinde, sanırım if(!someTest), hareket etmek istediğimiz koşul için doğru olacak alternatif bir eşit ayrıntı ve karmaşıklık testi olduğunda, genellikle kafa karıştırıcı * bulduğum bir nokta var. Yine de, şahsen verdiğiniz iki alternatifin diğerinden birini tercih edecek hiçbir şey bulamıyorum ve eğer yüklem daha karmaşık olsaydı belki de öncekine çok hafif eğilirdim.

* Anlamadığım gibi kafa karıştırıcı değil, ama anladığım gibi kafa karıştırıcı, anlayamadığım karar için ince bir neden olduğundan endişe duyuyorum ve bunu gerçekleştirmek için birkaç zihinsel atlama gerekiyor "hayır, sadece yapmaya karar verdiler bu şekilde bekle, bu kod parçasına tekrar ne bakıyordum? ... "

Aşağıdaki uzantı yöntemlerini kodunuzu daha okunaklı bulabilirsiniz:

public static bool None<TSource>(this IEnumerable<TSource> source)
{
    return !source.Any();
}

public static bool None<TSource>(this IEnumerable<TSource> source, 
                                 Func<TSource, bool> predicate)
{
    return !source.Any(predicate);
}

Şimdi orijinalin yerine

if (!acceptedValues.Any(v => v == someValue))
{
    // exception logic
}

söyleyebilirdin

if (acceptedValues.None(v => v == someValue))
{
    // exception logic
}

- Her iki sonuç sonrasında durdurma numaralandırma belirlenebilir, çünkü aynı özelliklere sahip olur Any()ilk öğeye geçirilen yüklem değerlendirir için trueve All()için öncül değerlendirir ilk öğeye false.

All ilk maçta kısa devreler, bu bir sorun değil.

Bir incelik alanı,

 bool allEven = Enumerable.Empty<int>().All(i => i % 2 == 0); 

Doğru. Dizideki tüm öğeler çifttir.

Bu yöntem hakkında daha fazla bilgi için Numaralandırılabilir belgelerine bakın .

All()sekanstaki tüm elemanların bir koşulu sağlayıp sağlamadığını belirler.
Any()sekanstaki herhangi bir elemanın koşulu karşılayıp karşılamadığını belirler.

var numbers = new[]{1,2,3};

numbers.All(n => n % 2 == 0); // returns false
numbers.Any(n => n % 2 == 0); // returns true

Bu bağlantıya göre

Herhangi biri - En az bir eşleşme olup olmadığını kontrol eder

Tümü - Tümünün eşleştiğini kontrol eder

Diğer cevapların iyi kapsadığı gibi: bu performansla ilgili değil, netlikle ilgilidir.

Her iki seçeneğiniz için de geniş destek var:

if (!acceptedValues.Any(v => v == someValue))
{
    // exception logic
}

if (acceptedValues.All(v => v != someValue))
{
    // exception logic
}

Ancak bunun daha geniş bir destek sağlayabileceğini düşünüyorum :

var isValueAccepted = acceptedValues.Any(v => v == someValue);
if (!isValueAccepted)
{
    // exception logic
}

Herhangi bir şeyi reddetmeden önce sadece boolean'ı hesaplamak (ve adlandırmak) bunu aklımda çok temizler.

Numaralandırılabilir kaynağa bakarsanız , uygulanmasının Anyve Alloldukça yakın olduğunu göreceksiniz :

public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
    if (source == null) throw Error.ArgumentNull("source");
    if (predicate == null) throw Error.ArgumentNull("predicate");
    foreach (TSource element in source) {
        if (predicate(element)) return true;
    }
    return false;
}

public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
    if (source == null) throw Error.ArgumentNull("source");
    if (predicate == null) throw Error.ArgumentNull("predicate");
    foreach (TSource element in source) {
        if (!predicate(element)) return false;
    }
    return true;
}

Tek bir yöntem boolean bir olumsuzlamada yattığından, bir yöntemin diğerinden önemli ölçüde daha hızlı olması mümkün değildir, bu nedenle yanlış performans kazancı yerine okunabilirliği tercih edin.