ฉันจะใช้ IEnumerable <T> ได้อย่างไร

ฉันรู้วิธีใช้ IEnumerable ที่ไม่ใช่แบบทั่วไปเช่นนี้:

using System;
using System.Collections;

namespace ConsoleApplication33
{
    class Program
    {
        static void Main(string[] args)
        {
            MyObjects myObjects = new MyObjects();
            myObjects[0] = new MyObject() { Foo = "Hello", Bar = 1 };
            myObjects[1] = new MyObject() { Foo = "World", Bar = 2 };

            foreach (MyObject x in myObjects)
            {
                Console.WriteLine(x.Foo);
                Console.WriteLine(x.Bar);
            }

            Console.ReadLine();
        }
    }

    class MyObject
    {
        public string Foo { get; set; }
        public int Bar { get; set; }
    }

    class MyObjects : IEnumerable
    {
        ArrayList mylist = new ArrayList();

        public MyObject this[int index]
        {
            get { return (MyObject)mylist[index]; }
            set { mylist.Insert(index, value); }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return mylist.GetEnumerator();
        }
    }
}

อย่างไรก็ตามฉันสังเกตด้วยว่า IEnumerable มีเวอร์ชันทั่วไปIEnumerable<T>แต่ฉันไม่สามารถหาวิธีใช้งานได้

หากฉันเพิ่มusing System.Collections.Generic;คำสั่งการใช้ของฉันแล้วเปลี่ยน:

class MyObjects : IEnumerable

ถึง:

class MyObjects : IEnumerable<MyObject>

จากนั้นคลิกขวาIEnumerable<MyObject>และเลือกImplement Interface => Implement InterfaceVisual Studio ช่วยเพิ่มบล็อกโค้ดต่อไปนี้:

IEnumerator<MyObject> IEnumerable<MyObject>.GetEnumerator()
{
    throw new NotImplementedException();
}

การส่งคืนอ็อบเจ็กต์ IEnumerable ที่ไม่ใช่ทั่วไปจากGetEnumerator();เมธอดไม่ได้ผลในครั้งนี้ฉันจะใส่อะไรที่นี่? ขณะนี้ CLI ละเว้นการใช้งานที่ไม่ใช่แบบทั่วไปและมุ่งตรงไปที่เวอร์ชันทั่วไปเมื่อพยายามระบุผ่านอาร์เรย์ของฉันในระหว่าง foreach loop

หากคุณเลือกใช้คอลเลคชันทั่วไปเช่นList<MyObject>แทนที่จะใช้ArrayListคุณจะพบว่าList<MyObject>จะมีตัวนับทั้งแบบทั่วไปและแบบไม่ใช้ทั่วไปที่คุณสามารถใช้ได้

using System.Collections;

class MyObjects : IEnumerable<MyObject>
{
    List<MyObject> mylist = new List<MyObject>();

    public MyObject this[int index]  
    {  
        get { return mylist[index]; }  
        set { mylist.Insert(index, value); }  
    } 

    public IEnumerator<MyObject> GetEnumerator()
    {
        return mylist.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

คุณอาจไม่ต้องการให้มีการนำไปใช้อย่างชัดเจนIEnumerable<T> (ซึ่งเป็นสิ่งที่คุณได้แสดงไว้)

รูปแบบปกติคือการใช้IEnumerable<T>'s GetEnumeratorในการดำเนินงานที่ชัดเจนของIEnumerable:

class FooCollection : IEnumerable<Foo>, IEnumerable
{
    SomeCollection<Foo> foos;

    // Explicit for IEnumerable because weakly typed collections are Bad
    System.Collections.IEnumerator IEnumerable.GetEnumerator()
    {
        // uses the strongly typed IEnumerable<T> implementation
        return this.GetEnumerator();
    }

    // Normal implementation for IEnumerable<T>
    IEnumerator<Foo> GetEnumerator()
    {
        foreach (Foo foo in this.foos)
        {
            yield return foo;
            //nb: if SomeCollection is not strongly-typed use a cast:
            // yield return (Foo)foo;
            // Or better yet, switch to an internal collection which is
            // strongly-typed. Such as List<T> or T[], your choice.
        }

        // or, as pointed out: return this.foos.GetEnumerator();
    }
}

ทำไมต้องทำด้วยตนเอง? yield returnทำให้กระบวนการทั้งหมดจัดการตัววนซ้ำโดยอัตโนมัติ (ฉันยังเขียนเกี่ยวกับเรื่องนี้ในบล็อกของฉันรวมถึงดูโค้ดที่คอมไพเลอร์สร้างขึ้น)

หากคุณต้องการทำด้วยตัวเองจริงๆคุณต้องส่งคืนตัวแจงนับทั่วไปด้วย คุณจะไม่สามารถใช้งานได้ArrayListอีกต่อไปเนื่องจากไม่ใช่แบบทั่วไป เปลี่ยนเป็นList<MyObject>แทน แน่นอนว่าคุณมีวัตถุประเภทMyObject(หรือประเภทที่ได้รับ) ในคอลเลกชันของคุณเท่านั้น

หากคุณทำงานกับ generics ให้ใช้ List แทน ArrayList รายการมีวิธี GetEnumerator ที่คุณต้องการ

List<MyObject> myList = new List<MyObject>();

ทำให้ mylist เป็น a List<MyObject>เป็นทางเลือกหนึ่ง

โปรดทราบว่าแนวทางอื่นที่IEnumerable<T>ใช้ allready System.Collectionsคือการได้มาMyObjectsจากคลาสของคุณSystem.Collectionsเป็นคลาสฐาน ( เอกสารประกอบ ):

System.Collections: จัดเตรียมคลาสพื้นฐานสำหรับคอลเลกชันทั่วไป

เราสามารถทำให้ต่อมา implemenation ของเราเองเพื่อแทนที่เสมือนSystem.Collectionsวิธีการเพื่อให้พฤติกรรมที่กำหนดเอง (เฉพาะClearItems, InsertItem, RemoveItemและSetItemพร้อมด้วยEquals, GetHashCodeและToStringจากObject) แตกต่างจากList<T>ที่ไม่ได้ออกแบบมาให้ขยายได้ง่าย

ตัวอย่าง:

public class FooCollection : System.Collections<Foo>
{
    //...
    protected override void InsertItem(int index, Foo newItem)
    {
        base.InsertItem(index, newItem);     
        Console.Write("An item was successfully inserted to MyCollection!");
    }
}

public static void Main()
{
    FooCollection fooCollection = new FooCollection();
    fooCollection.Add(new Foo()); //OUTPUT: An item was successfully inserted to FooCollection!
}

โปรดทราบว่าการขับรถจากที่collectionแนะนำเฉพาะในกรณีที่จำเป็นต้องมีพฤติกรรมการเก็บรวบรวมแบบกำหนดเองซึ่งแทบจะไม่เกิดขึ้น ดูการใช้งาน