การจัดการคำเตือนสำหรับการนับ IEnumerable ที่เป็นไปได้หลายรายการ

ในรหัสของฉันจำเป็นต้องใช้IEnumerable<>หลายครั้งจึงได้รับข้อผิดพลาด Resharper ของ "เป็นไปได้หลายการนับIEnumerable"

รหัสตัวอย่าง:

public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null || !objects.Any())
        throw new ArgumentException();

    var firstObject = objects.First();
    var list = DoSomeThing(firstObject);        
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);

    return list;
}

• ฉันสามารถเปลี่ยนobjectsพารามิเตอร์ให้เป็นListแล้วหลีกเลี่ยงการนับหลายที่เป็นไปได้ แต่จากนั้นฉันไม่ได้รับวัตถุสูงสุดที่ฉันสามารถจัดการได้
• สิ่งที่ฉันสามารถทำได้ก็คือการแปลงIEnumerableไปListที่จุดเริ่มต้นของวิธีการ:

 public List<object> Foo(IEnumerable<object> objects)
 {
    var objectList = objects.ToList();
    // ...
 }

แต่นี้เป็นเพียงที่น่าอึดอัดใจ

คุณจะทำอะไรในสถานการณ์นี้

ปัญหาในการรับIEnumerableพารามิเตอร์คือมันบอกผู้โทรว่า "ฉันต้องการแจกแจงสิ่งนี้" มันไม่ได้บอกพวกเขาว่าคุณต้องการแจกแจงกี่ครั้ง

ฉันสามารถเปลี่ยนพารามิเตอร์วัตถุเป็นรายการแล้วหลีกเลี่ยงการนับหลายที่เป็นไปได้ แต่จากนั้นฉันไม่ได้รับวัตถุสูงสุดที่ฉันสามารถจัดการได้

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

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

โดยการเปลี่ยนวิธีการเป็นIList/ ICollectionอย่างน้อยคุณจะทำให้ชัดเจนกับผู้โทรสิ่งที่คุณคาดหวังและพวกเขาสามารถหลีกเลี่ยงข้อผิดพลาดค่าใช้จ่าย

ไม่เช่นนั้นนักพัฒนาส่วนใหญ่ที่ดูวิธีการอาจคิดว่าคุณทำซ้ำเพียงครั้งเดียว หากการรับIEnumerableเป็นสิ่งที่สำคัญมากคุณควรพิจารณาดำเนินการ.ToList()เมื่อเริ่มต้นวิธีการ

มันน่าละอาย. NET ไม่มีอินเทอร์เฟซที่เป็น IEnumerable + Count + Indexer โดยไม่ต้องเพิ่ม / ลบ ฯลฯ วิธีซึ่งเป็นสิ่งที่ฉันสงสัยว่าจะแก้ปัญหานี้ได้

หากข้อมูลของคุณจะสามารถทำซ้ำได้เสมอไม่ต้องกังวล อย่างไรก็ตามคุณสามารถเปิดใช้งานได้เช่นกัน - ซึ่งเป็นประโยชน์อย่างยิ่งหากข้อมูลขาเข้าอาจมีขนาดใหญ่ (ตัวอย่างเช่นการอ่านจากดิสก์ / เครือข่าย):

if(objects == null) throw new ArgumentException();
using(var iter = objects.GetEnumerator()) {
    if(!iter.MoveNext()) throw new ArgumentException();

    var firstObject = iter.Current;
    var list = DoSomeThing(firstObject);  

    while(iter.MoveNext()) {
        list.Add(DoSomeThingElse(iter.Current));
    }
    return list;
}

หมายเหตุฉันเปลี่ยน semantic ของ DoSomethingElse นิดหน่อย แต่นี่ส่วนใหญ่จะแสดงการใช้งานที่ไม่ได้ควบคุม ตัวอย่างเช่นคุณสามารถใส่ตัววนซ้ำได้ คุณสามารถทำให้เป็นบล็อกตัววนซ้ำได้เช่นกันซึ่งอาจดี จึงไม่มีlist- และคุณต้องการyield returnรายการต่าง ๆ ที่คุณได้รับมากกว่าที่จะเพิ่มในรายการที่จะถูกส่งคืน

การใช้IReadOnlyCollection<T>หรือIReadOnlyList<T>ในลายเซ็นเมธอดแทนIEnumerable<T>มีข้อดีของการทำให้ชัดเจนว่าคุณอาจต้องตรวจสอบจำนวนก่อนที่จะวนซ้ำหรือซ้ำหลายครั้งด้วยเหตุผลอื่น

อย่างไรก็ตามพวกเขามีข้อเสียอย่างมากที่จะทำให้เกิดปัญหาหากคุณพยายามปรับโครงสร้างรหัสของคุณให้ใช้อินเทอร์เฟซอีกครั้งเพื่อให้สามารถทดสอบได้และเป็นมิตรกับพร็อกซี่แบบไดนามิกมากขึ้น จุดสำคัญคือสิ่งที่IList<T>ไม่ได้รับสืบทอดIReadOnlyList<T>และในทำนองเดียวกันสำหรับคอลเลกชันอื่น ๆ และอินเทอร์เฟซแบบอ่านอย่างเดียวที่เกี่ยวข้อง (โดยย่อนี่เป็นเพราะ. NET 4.5 ต้องการรักษาความเข้ากันได้ของ ABI กับรุ่นก่อนหน้าแต่พวกเขาไม่ได้ใช้โอกาสในการเปลี่ยนแปลงใน. NET core )

ซึ่งหมายความว่าหากคุณได้รับIList<T>จากบางส่วนของโปรแกรมและต้องการส่งต่อไปยังส่วนอื่นที่คาดหวังIReadOnlyList<T>คุณจะไม่สามารถ! แต่คุณสามารถผ่านการIList<T>IEnumerable<T>เป็น

ในท้ายที่สุดIEnumerable<T>เป็นอินเทอร์เฟซแบบอ่านอย่างเดียวเท่านั้นที่ได้รับการสนับสนุนโดยคอลเลกชัน. NET ทั้งหมดรวมถึงอินเทอร์เฟซการรวบรวมทั้งหมด ทางเลือกอื่น ๆ จะกลับมากัดคุณเมื่อคุณตระหนักว่าคุณล็อคตัวเองจากตัวเลือกสถาปัตยกรรมบางอย่าง ดังนั้นฉันคิดว่ามันเป็นประเภทที่เหมาะสมที่จะใช้ในฟังก์ชันลายเซ็นเพื่อแสดงว่าคุณเพียงแค่ต้องการคอลเลกชันแบบอ่านอย่างเดียว

(โปรดทราบว่าคุณสามารถเขียนIReadOnlyList<T> ToReadOnly<T>(this IList<T> list)วิธีการขยายที่ให้ค่าคงที่ได้ง่ายหากประเภทที่รองรับรองรับทั้งสองอินเตอร์เฟส แต่คุณต้องเพิ่มมันด้วยตนเองทุกครั้งเมื่อทำการเปลี่ยนโครงสร้างซึ่งIEnumerable<T>เข้ากันได้เสมอ)

เช่นนี้ไม่แน่นอนหากคุณกำลังเขียนรหัสฐานข้อมูลหนักซึ่งการนับจำนวนโดยไม่ตั้งใจจะเป็นความเสียหายคุณอาจชอบการแลกเปลี่ยนที่ต่างออกไป

หากเป้าหมายคือการป้องกันไม่ให้มีการแจกแจงจำนวนมากเกินกว่าคำตอบของ Marc Gravell คือการอ่าน แต่การคงไว้ซึ่งความหมายเดียวกันคุณสามารถลบซ้ำซ้อนAnyและการFirstโทรออกด้วย:

public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null)
        throw new ArgumentNullException("objects");

    var first = objects.FirstOrDefault();

    if (first == null)
        throw new ArgumentException(
            "Empty enumerable not supported.", 
            "objects");

    var list = DoSomeThing(first);  

    var secondList = DoSomeThingElse(objects);

    list.AddRange(secondList);

    return list;
}

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

ฉันมักจะเกินวิธีการของฉันกับ IEnumerable และ IList ในสถานการณ์นี้

public static IEnumerable<T> Method<T>( this IList<T> source ){... }

public static IEnumerable<T> Method<T>( this IEnumerable<T> source )
{
    /*input checks on source parameter here*/
    return Method( source.ToList() );
}

ฉันระมัดระวังที่จะอธิบายในความคิดเห็นสรุปของวิธีการที่เรียก IEnumerable จะดำเนินการ. ToList ()

โปรแกรมเมอร์สามารถเลือกที่จะ. ToList () ในระดับที่สูงขึ้นหากมีการดำเนินการหลายอย่างพร้อมกันแล้วเรียก IList overload หรือให้ IEnumerable overload ของฉันจัดการได้

หากคุณต้องการตรวจสอบองค์ประกอบแรกคุณสามารถดูได้โดยไม่ต้องวนซ้ำคอลเลกชันทั้งหมด:

public List<object> Foo(IEnumerable<object> objects)
{
    object firstObject;
    if (objects == null || !TryPeek(ref objects, out firstObject))
        throw new ArgumentException();

    var list = DoSomeThing(firstObject);
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);

    return list;
}

public static bool TryPeek<T>(ref IEnumerable<T> source, out T first)
{
    if (source == null)
        throw new ArgumentNullException(nameof(source));

    IEnumerator<T> enumerator = source.GetEnumerator();
    if (!enumerator.MoveNext())
    {
        first = default(T);
        source = Enumerable.Empty<T>();
        return false;
    }

    first = enumerator.Current;
    T firstElement = first;
    source = Iterate();
    return true;

    IEnumerable<T> Iterate()
    {
        yield return firstElement;
        using (enumerator)
        {
            while (enumerator.MoveNext())
            {
                yield return enumerator.Current;
            }
        }
    }
}

ก่อนอื่นคำเตือนนั้นไม่ได้มีความหมายมากนัก ฉันมักจะปิดการใช้งานหลังจากทำให้แน่ใจว่าไม่ใช่คอขวดประสิทธิภาพ มันหมายถึงการIEnumerableประเมินสองครั้งซึ่งมักจะไม่เป็นปัญหาเว้นแต่ว่าevaluationตัวเองจะใช้เวลานาน แม้ว่าจะใช้เวลานาน แต่ในกรณีนี้คุณจะใช้เพียงองค์ประกอบเดียวในครั้งแรก

ในสถานการณ์นี้คุณสามารถใช้ประโยชน์จากวิธีการขยาย linq ที่มีประสิทธิภาพมากยิ่งขึ้น

var firstObject = objects.First();
return DoSomeThing(firstObject).Concat(DoSomeThingElse(objects).ToList();

มีความเป็นไปได้ที่จะประเมินเพียงIEnumerableครั้งเดียวในกรณีนี้ด้วยความยุ่งยาก แต่โปรไฟล์ก่อนและดูว่ามันเป็นปัญหาหรือไม่