LINQ: ไม่ vs ไม่ได้ทั้งหมด

บ่อยครั้งที่ฉันต้องการตรวจสอบว่าค่าที่มีให้ตรงกับหนึ่งในรายการ (เช่นเมื่อตรวจสอบ):

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

เมื่อเร็ว ๆ นี้ฉันสังเกตเห็น ReSharper ขอให้ฉันทำแบบสอบถามเหล่านี้ให้ง่ายขึ้น:

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

เห็นได้ชัดว่ามันเหมือนกันในเชิงตรรกะบางทีอาจจะอ่านได้มากกว่าเล็กน้อย (ถ้าคุณทำคณิตศาสตร์มามาก) คำถามของฉันคือ: สิ่งนี้ส่งผลให้เกิดผลงานหรือไม่?

มันให้ความรู้สึกเหมือนว่ามันควรจะ (เช่น.Any()ฟังดูเหมือนมันจะลัดวงจรในขณะที่.All()ดูเหมือนว่ามันจะไม่ได้) แต่ฉันไม่มีอะไรจะพิสูจน์เรื่องนี้ ไม่มีใครมีความรู้ในเชิงลึกเกี่ยวกับคำถามที่ว่าจะแก้ไขเหมือนเดิมหรือไม่หรือ ReSharper ทำให้ฉันหลงทาง?

การดำเนินการAllตาม ILSpy (ในขณะที่ฉันไปและมองมากกว่า "ดีวิธีการที่ใช้งานได้เช่น ... " ฉันอาจจะทำอย่างไรถ้าเราพูดถึงทฤษฎีมากกว่าผลกระทบ)

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

การดำเนินการAnyตาม 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;
}

แน่นอนว่าอาจมีความแตกต่างเล็กน้อยในการผลิต IL แต่ไม่ไม่มีไม่มี IL นั้นค่อนข้างเหมือนกัน แต่สำหรับการกลับที่ชัดเจนของการกลับมาจริงในการแข่งขันภาคเปรียบเทียบกับการกลับมาที่ผิดพลาดในภาคที่ไม่ตรงกัน

นี่เป็น linq-for-objects แน่นอน มีความเป็นไปได้ที่ผู้ให้บริการ linq รายอื่นจะปฏิบัติดีกว่าอีกคนหนึ่ง แต่ถ้าเป็นเช่นนั้นจะเป็นการสุ่มที่ดีกว่าคนอื่นที่มีการใช้งานที่เหมาะสมกว่า

มันจะดูเหมือนว่ากฎลงมา แต่เพียงผู้เดียวกับความรู้สึกคนที่ง่ายและสามารถอ่านได้มากกว่าif(determineSomethingTrue) if(!determineSomethingFalse)และในความเป็นธรรมฉันคิดว่าพวกเขามีจุดที่ฉันมักจะพบว่ามีif(!someTest)ความสับสน * เมื่อมีการทดสอบทางเลือกของการใช้คำฟุ่มเฟื่อยและความซับซ้อนที่เท่าเทียมกันซึ่งจะกลับมาจริงสำหรับเงื่อนไขที่เราต้องการ แต่โดยส่วนตัวแล้วฉันไม่พบสิ่งใดที่จะให้ประโยชน์แก่อีกทางเลือกหนึ่งของสองทางเลือกที่คุณให้และอาจจะเอนตัวไปทางอดีตเล็กน้อยหากคำกริยามีความซับซ้อนมากขึ้น

* ไม่สับสนเหมือนที่ฉันไม่เข้าใจ แต่สับสนในขณะที่ฉันกังวลว่ามีเหตุผลบางอย่างสำหรับการตัดสินใจที่ฉันไม่เข้าใจและใช้เวลาไม่กี่จิตที่จะตระหนักว่า "ไม่พวกเขาเพิ่งตัดสินใจที่จะทำ เป็นอย่างนั้นรอสิ่งที่ฉันดูรหัสนี้อีกครั้งหรือไม่ ... "

คุณอาจพบว่าวิธีการขยายเหล่านี้ทำให้โค้ดของคุณอ่านง่ายขึ้น:

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

ตอนนี้แทนที่จะเป็นต้นฉบับของคุณ

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

คุณสามารถพูดได้

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

ทั้งสองฝ่ายจะมีประสิทธิภาพการทำงานที่เหมือนกันเพราะทั้งสองหยุดการแจงนับหลังจากผลที่ได้รับการพิจารณา - Any()ที่รายการแรกที่ผ่านประเมินกริยาไปtrueและที่รายการแรกประเมินเพื่อวินิจฉัยAll()false

All การลัดวงจรของการแข่งขันนัดแรกดังนั้นจึงไม่ใช่ปัญหา

ความบอบบางอย่างหนึ่งก็คือ

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

เป็นความจริง. รายการทั้งหมดในลำดับนั้นเท่ากัน

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการนี้เอกสารประกอบสำหรับEnumerable.All

All()กำหนดว่าองค์ประกอบทั้งหมดของลำดับเป็นไปตามเงื่อนไขหรือไม่
Any()กำหนดว่าองค์ประกอบใด ๆ ของลำดับเป็นไปตามเงื่อนไขหรือไม่

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

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

ตามลิงค์นี้

ใด ๆ - ตรวจสอบการแข่งขันอย่างน้อยหนึ่งครั้ง

ทั้งหมด - ตรวจสอบว่าตรงกันทั้งหมด

เนื่องจากคำตอบอื่น ๆ ได้รับการคุ้มครองอย่างดี: นี่ไม่ได้เกี่ยวกับประสิทธิภาพ แต่เป็นเรื่องที่ชัดเจน

มีการสนับสนุนอย่างกว้างขวางสำหรับตัวเลือกทั้งสองของคุณ:

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

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

แต่ฉันคิดว่าสิ่งนี้อาจบรรลุการสนับสนุนที่กว้างขึ้น :

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

เพียงแค่คำนวณบูลีน (และตั้งชื่อ) ก่อนที่จะลบล้างสิ่งใดก็ตามที่ทำให้สิ่งนี้อยู่ในใจฉันมากมาย

หากคุณดูที่แหล่งที่มานับคุณจะเห็นว่าการดำเนินการAnyและAllอยู่ใกล้มาก:

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

ไม่มีวิธีใดที่วิธีการหนึ่งจะเร็วกว่าวิธีอื่นอย่างมีนัยสำคัญเนื่องจากความแตกต่างเพียงอย่างเดียวคือการปฏิเสธแบบบูลีนดังนั้นจึงควรอ่านมากกว่าการชนะที่ผิดพลาด