LINQ: Tidak Ada vs Semua Jangan

Seringkali saya ingin memeriksa apakah nilai yang diberikan cocok dengan satu dalam daftar (mis. Ketika memvalidasi):

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

Baru-baru ini, saya perhatikan ReSharper meminta saya untuk menyederhanakan pertanyaan ini menjadi:

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

Jelas, ini identik secara logis, mungkin sedikit lebih mudah dibaca (jika Anda telah melakukan banyak matematika), pertanyaan saya adalah: apakah ini menghasilkan hit kinerja?

Rasanya seperti itu seharusnya (yaitu .Any()terdengar seperti itu arus pendek, sedangkan .All()terdengar seperti itu tidak), tapi saya tidak punya apa-apa untuk membuktikan hal ini. Adakah yang memiliki pengetahuan yang lebih dalam tentang apakah pertanyaan akan menyelesaikan hal yang sama, atau apakah ReSharper membuat saya tersesat?

Implementasi Allmenurut ILSpy (seperti pada saya benar-benar pergi dan melihat, daripada "well, metode itu bekerja sedikit seperti ..." Saya mungkin lakukan jika kita membahas teori daripada dampaknya).

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

Implementasi Anymenurut ILSpy:

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

Tentu saja, mungkin ada beberapa perbedaan halus dalam IL yang dihasilkan. Tapi tidak, tidak ada. IL hampir sama tetapi untuk inversi yang jelas untuk mengembalikan true pada pertandingan predikat versus kembali salah pada predikat mismatch.

Ini hanya linq-untuk-objek saja. Mungkin saja beberapa penyedia linq lain memperlakukan satu jauh lebih baik daripada yang lain, tetapi kemudian jika itu yang terjadi, itu cukup acak mana yang mendapat implementasi yang lebih optimal.

Tampaknya aturan itu hanya berlaku untuk seseorang yang merasa if(determineSomethingTrue)lebih sederhana dan lebih mudah dibaca daripada if(!determineSomethingFalse). Dan dalam keadilan, saya pikir mereka sedikit banyak titik di mana saya sering menemukan if(!someTest)* membingungkan ketika ada tes alternatif dengan verbositas dan kompleksitas yang sama yang akan kembali benar untuk kondisi yang ingin kita tindak lanjuti. Namun sungguh, secara pribadi saya tidak menemukan apa pun untuk mendukung salah satu dari dua alternatif yang Anda berikan, dan mungkin akan sedikit condong ke yang pertama jika predikatnya lebih rumit.

* Tidak membingungkan karena saya tidak mengerti, tetapi membingungkan karena saya khawatir ada beberapa alasan halus untuk keputusan yang saya tidak mengerti, dan butuh beberapa lompatan mental untuk menyadari bahwa "tidak, mereka hanya memutuskan untuk melakukan dengan begitu, tunggu apa lagi yang saya cari dengan kode ini? ... "

Anda mungkin menemukan metode ekstensi ini membuat kode Anda lebih mudah dibaca:

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

Sekarang alih-alih yang asli

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

Anda bisa mengatakan

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

Keduanya akan memiliki kinerja yang identik karena keduanya menghentikan pencacahan setelah hasilnya dapat ditentukan - Any()pada item pertama yang lulus predikat dievaluasi ke truedan All()pada item pertama predikat dievaluasi false.

All sirkuit pendek pada pertandingan pertama yang tidak cocok, jadi itu tidak masalah.

Satu bidang kehalusan adalah itu

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

Adalah benar. Semua item dalam urutan adalah genap.

Untuk lebih lanjut tentang metode ini, lihat dokumentasi untuk Enumerable .

All()menentukan apakah semua elemen urutan memenuhi suatu kondisi.
Any()menentukan apakah elemen dari urutan memenuhi syarat.

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

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

Menurut tautan ini

Any - Memeriksa setidaknya satu kecocokan

Semua - Memeriksa apakah semua cocok

Karena jawaban lain telah dibahas dengan baik: ini bukan tentang kinerja, ini tentang kejelasan.

Ada banyak dukungan untuk kedua opsi Anda:

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

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

Tetapi saya pikir ini mungkin mencapai dukungan yang lebih luas :

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

Cukup dengan menghitung boolean (dan menamainya) sebelum meniadakan apa pun, ini sangat jelas dalam pikiran saya.

Jika Anda melihat sumber Enumerable Anda akan melihat bahwa implementasi Anydan Allcukup dekat:

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

Tidak ada cara yang satu metode untuk secara signifikan lebih cepat daripada yang lain karena satu-satunya perbedaan terletak pada negasi boolean, jadi lebih suka keterbacaan dibandingkan menang kinerja palsu.