วิธีการนับทรัพย์สินเทียบกับจำนวน ()?

การทำงานกับคอลเลกชันฉันมีสองวิธีในการนับวัตถุ Count(คุณสมบัติ) และCount()(วิธีการ) ไม่มีใครรู้ว่าความแตกต่างที่สำคัญคืออะไร?

ฉันอาจจะผิด แต่ฉันมักจะใช้Countคุณสมบัติในคำสั่งเงื่อนไขใด ๆ เพราะฉันสมมติว่าCount()เมธอดใช้แบบสอบถามบางประเภทกับคอลเลกชันโดยที่Countต้องได้รับมอบหมายก่อนที่ฉันจะ 'รับ' แต่นั่นเป็นการเดา - ฉันไม่รู้ว่าประสิทธิภาพจะได้รับผลกระทบหรือไม่ถ้าฉันผิด

แก้ไข: ด้วยความอยากรู้อยากเห็นจะทำให้Count()เกิดข้อยกเว้นหากคอลเล็กชันเป็นโมฆะ? เพราะฉันค่อนข้างมั่นใจว่าCountคุณสมบัติจะคืนค่าเป็น 0

การแยกแหล่งที่มาสำหรับCount()วิธีการขยายเผยให้เห็นว่ามันทดสอบว่าวัตถุนั้นเป็นICollection(ทั่วไปหรืออย่างอื่น) และถ้าเป็นเช่นนั้นเพียงแค่ส่งคืนพื้นฐานCountคุณสมบัติ :

ดังนั้นหากรหัสของคุณเข้าถึงCountแทนการโทรCount()คุณสามารถข้ามการตรวจสอบประเภท - ประโยชน์ด้านประสิทธิภาพตามทฤษฎี แต่ฉันสงสัยว่ามันจะเป็นสิ่งที่เห็นได้ชัดเจน!

// System.Linq.Enumerable
public static int Count<TSource>(this IEnumerable<TSource> source)
{
    checked
    {
        if (source == null)
        {
            throw Error.ArgumentNull("source");
        }
        ICollection<TSource> collection = source as ICollection<TSource>;
        if (collection != null)
        {
            return collection.Count;
        }
        ICollection collection2 = source as ICollection;
        if (collection2 != null)
        {
            return collection2.Count;
        }
        int num = 0;
        using (IEnumerator<TSource> enumerator = source.GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                num++;
            }
        }
        return num;
    }
}

ประสิทธิภาพเป็นเพียงเหตุผลเดียวในการเลือกอย่างใดอย่างหนึ่ง การเลือก.Count()หมายความว่ารหัสของคุณจะเป็นแบบทั่วไปมากขึ้น ฉันเคยมีบางครั้งที่ฉันปรับโครงสร้างโค้ดบางส่วนที่ไม่ได้สร้างคอลเลกชันอีกต่อไป แต่แทนที่จะเป็นสิ่งที่ธรรมดากว่าเช่น IE ที่สามารถนับได้ แต่โค้ดอื่น ๆ ก็พังเพราะมันขึ้นอยู่กับ.Countและฉันต้องเปลี่ยนเป็น.Count(). ถ้าฉันชี้ให้ใช้.Count()ทุกที่โค้ดน่าจะใช้ซ้ำและบำรุงรักษาได้มากกว่า โดยปกติแล้วการเลือกใช้อินเทอร์เฟซทั่วไปหากคุณสามารถหลีกเลี่ยงได้ถือเป็นทางออกที่ดีที่สุดของคุณ โดยทั่วไปแล้วฉันหมายถึงอินเทอร์เฟซที่เรียบง่ายกว่าซึ่งมีการใช้งานตามประเภทต่างๆมากขึ้นและทำให้คุณสามารถใช้งานร่วมกันได้ระหว่างโค้ด

ฉันไม่ได้บอกว่า.Count()ดีกว่าฉันแค่บอกว่ามีข้อควรพิจารณาอื่น ๆ ที่เกี่ยวข้องกับการใช้ซ้ำของโค้ดที่คุณกำลังเขียนมากกว่า

.Count()วิธีการอาจจะฉลาดพอหรือรู้เกี่ยวกับประเภทในคำถามและถ้าเป็นเช่นนั้นก็อาจใช้อ้างอิง.Countสถานที่ให้บริการ

จากนั้นอีกครั้งมันอาจจะไม่

ฉันจะบอกว่ามันปลอดภัยที่จะสมมติว่าหากคอลเลกชันมี.Countคุณสมบัตินั้นจะเป็นทางออกที่ดีที่สุดของคุณเมื่อพูดถึงประสิทธิภาพ

หาก.Count()เมธอดไม่ทราบเกี่ยวกับคอลเลกชันก็จะแจกแจงมากกว่าซึ่งจะเป็นการดำเนินการ O (n)

Count()method เป็นวิธีการขยายที่วนซ้ำแต่ละองค์ประกอบของ an IEnumerable<>และส่งกลับจำนวนองค์ประกอบที่มี หากอินสแตนซ์ของIEnumerableเป็น a จริงList<>ดังนั้นจึงได้รับการปรับให้ส่งคืนCountคุณสมบัติแทนที่จะทำซ้ำองค์ประกอบทั้งหมด

Count()มีวิธีการขยายจาก LINQ หรือไม่ - CountคือคุณสมบัติบนLists วัตถุคอลเลกชัน. NET จริง

ด้วยเหตุนี้Count()จะช้าลงเกือบตลอดเวลาเนื่องจากจะระบุวัตถุคอลเลกชัน / แบบสอบถาม ในรายการคิว, สแต็ค ฯลฯ Countการใช้งาน หรือสำหรับอาร์เรย์ - Length.

เวอร์ชันสั้น: หากคุณมีทางเลือกระหว่างCountคุณสมบัติและไฟล์Count()วิธีการให้เลือกคุณสมบัติเสมอ

ความแตกต่างส่วนใหญ่อยู่ที่ประสิทธิภาพของการดำเนินการ คอลเลกชัน BCL ทั้งหมดที่เปิดเผยCountคุณสมบัติทำในลักษณะ O (1) Count()วิธี แต่สามารถและมักจะมีค่าใช้จ่าย O (N) มีการตรวจสอบบางอย่างที่ต้องลองและนำไปที่ O (1) สำหรับการใช้งานบางอย่าง แต่ก็ไม่มีการรับประกัน

หากมีCountหรือLengthคุณสมบัติคุณควรเลือกCount()วิธีนี้เสมอซึ่งโดยทั่วไปจะวนซ้ำคอลเลกชันทั้งหมดเพื่อนับจำนวนองค์ประกอบที่อยู่ภายใน ข้อยกเว้นจะเกิดขึ้นเมื่อCount()เมธอดขัดกับแหล่งข้อมูล LINQ ถึง SQL หรือ LINQ ไปยังเอนทิตีซึ่งในกรณีนี้จะดำเนินการเคียวรีนับกับแหล่งข้อมูล ถึงอย่างนั้นหากมีCountทรัพย์สินคุณก็ต้องการที่จะชอบเพราะมันมีงานให้ทำน้อยกว่า

Count()วิธีเป็นวิธี LINQ IEnumerable<>ที่ทำงานใด ๆ คุณคาดหวังว่าไฟล์Count()วิธีการนี้จะวนซ้ำในคอลเลกชันทั้งหมดเพื่อค้นหาการนับ แต่ฉันเชื่อว่าโค้ด LINQ มีการปรับให้เหมาะสมเพื่อตรวจสอบว่ามีคุณสมบัติ Count อยู่หรือไม่และหากเป็นเช่นนั้นให้ใช้

ดังนั้นทั้งคู่ควรทำสิ่งที่เหมือนกันเกือบทั้งหมด คุณสมบัติ Count น่าจะดีกว่าเล็กน้อยเนื่องจากไม่จำเป็นต้องมีการเช็คอินประเภทนั้น