LINQ: Không phải bất kỳ vs Tất cả Đừng

Thường thì tôi muốn kiểm tra xem giá trị được cung cấp có khớp với một trong danh sách không (ví dụ: khi xác thực):

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

Gần đây, tôi nhận thấy ReSharper yêu cầu tôi đơn giản hóa các truy vấn này để:

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

Rõ ràng, điều này là giống hệt nhau về mặt logic, có lẽ dễ đọc hơn một chút (nếu bạn đã làm rất nhiều toán học), câu hỏi của tôi là: điều này có dẫn đến kết quả thực hiện không?

Nó có cảm giác như vậy (nghĩa là .Any()nghe có vẻ ngắn mạch, trong khi .All()âm thanh thì không), nhưng tôi không có gì để chứng minh điều này. Có ai có kiến ​​thức sâu hơn về việc các truy vấn sẽ giải quyết giống nhau không, hoặc liệu ReSharper có khiến tôi lạc lối không?

Việc thực hiện Alltheo ILSpy (như tôi thực sự đã đi và xem, thay vì "tốt, phương pháp đó hoạt động hơi giống ..." Tôi có thể làm nếu chúng ta đang thảo luận về lý thuyết chứ không phải là tác động).

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

Thực hiện Anytheo 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;
}

Tất nhiên, có thể có một số khác biệt tinh tế trong IL được sản xuất. Nhưng không, không có. IL khá giống nhau nhưng đối với sự đảo ngược rõ ràng là trả về true trên kết hợp vị ngữ so với trả về false trên không khớp vị ngữ.

Tất nhiên đây chỉ là linq-for-object. Có thể một số nhà cung cấp linq khác đối xử với một nhà cung cấp tốt hơn nhiều so với nhà cung cấp khác, nhưng nếu đó là trường hợp, thì khá ngẫu nhiên khi một nhà cung cấp triển khai tối ưu hơn.

Dường như quy tắc chỉ xuất phát từ một người nào đó cảm thấy if(determineSomethingTrue)đơn giản và dễ đọc hơn if(!determineSomethingFalse). Và công bằng mà nói, tôi nghĩ rằng họ có một điểm mà tôi thường thấy if(!someTest)khó hiểu * khi có một bài kiểm tra thay thế về tính dài dòng và độ phức tạp tương đương sẽ trở thành sự thật cho điều kiện chúng ta muốn hành động. Tuy nhiên, thực sự, cá nhân tôi thấy không có gì có lợi cho người khác trong hai lựa chọn thay thế mà bạn đưa ra, và có lẽ sẽ hơi nghiêng về phía trước nếu vị ngữ phức tạp hơn.

* Không khó hiểu như tôi không hiểu, nhưng khó hiểu vì tôi lo lắng rằng có một số lý do tinh tế cho quyết định mà tôi không hiểu, và phải mất một vài bước tinh thần để nhận ra rằng "không, họ chỉ quyết định làm Theo cách đó, đợi xem tôi đã xem lại đoạn mã này để làm gì nữa? ... "

Bạn có thể tìm thấy các phương thức mở rộng này làm cho mã của bạn dễ đọc hơn:

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

Bây giờ thay vì ban đầu của bạn

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

bạn có thể nói

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

Cả hai sẽ có hiệu suất giống hệt nhau vì cả hai đều dừng liệt kê sau khi kết quả có thể được xác định - Any()trên mục đầu tiên, vị từ được thông qua sẽ đánh giá truevà All()trên mục đầu tiên mà vị từ ước tính false.

All ngắn mạch trên lần đầu tiên không khớp, vì vậy nó không phải là vấn đề.

Một lĩnh vực của sự tinh tế là

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

Là đúng. Tất cả các mục trong chuỗi là chẵn.

Để biết thêm về phương pháp này, hãy tham khảo tài liệu cho Enumerable.All .

All()xác định xem tất cả các yếu tố của một chuỗi thỏa mãn một điều kiện.
Any()xác định xem bất kỳ phần tử nào của chuỗi thỏa mãn điều kiện.

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

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

Theo liên kết này

Bất kỳ - Kiểm tra ít nhất một trận đấu

Tất cả - Kiểm tra xem tất cả có khớp không

Vì các câu trả lời khác đã được trình bày rõ: đây không phải là về hiệu suất, mà là về sự rõ ràng.

Có nhiều hỗ trợ cho cả hai lựa chọn của bạn:

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

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

Nhưng tôi nghĩ điều này có thể đạt được sự hỗ trợ rộng hơn :

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

Đơn giản chỉ cần tính toán boolean (và đặt tên cho nó) trước khi phủ nhận bất cứ điều gì làm rõ điều này trong tâm trí tôi.

Nếu bạn xem qua Nguồn vô số, bạn sẽ thấy việc triển khai Anyvà Allkhá gần:

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

Không có cách nào mà một phương thức nhanh hơn đáng kể so với phương pháp kia vì sự khác biệt duy nhất nằm ở sự phủ định boolean, vì vậy thích khả năng đọc hơn so với chiến thắng hiệu suất sai.