Làm cách nào để triển khai IEn Countable <T>

Tôi biết cách triển khai IEnumerable không chung chung, như thế này:

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

Tuy nhiên tôi cũng nhận thấy rằng IEnumerable có phiên bản chung IEnumerable<T>, nhưng tôi không thể tìm ra cách triển khai nó.

Nếu tôi thêm using System.Collections.Generic;vào chỉ thị của mình bằng cách sử dụng, và sau đó thay đổi:

class MyObjects : IEnumerable

đến:

class MyObjects : IEnumerable<MyObject>

Và sau đó nhấp chuột phải vào IEnumerable<MyObject>và chọn Implement Interface => Implement Interface, Visual Studio bổ sung một cách hữu ích khối mã sau đây:

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

Trả về đối tượng IEnumerable không chung chung từ GetEnumerator();phương thức này không hoạt động lần này, vậy tôi phải đặt gì ở đây? CLI bây giờ bỏ qua việc triển khai không chung chung và đi thẳng vào phiên bản chung khi nó cố gắng liệt kê qua mảng của tôi trong vòng lặp foreach.

Nếu bạn chọn sử dụng một bộ sưu tập chung chung, chẳng hạn như List<MyObject>thay vì ArrayList, bạn sẽ thấy rằng nó List<MyObject>sẽ cung cấp cả các liệt kê chung và không chung chung mà bạn có thể sử dụng.

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

Bạn có thể không muốn triển khai rõ ràngIEnumerable<T> (đó là những gì bạn đã thể hiện).

Các mô hình thông thường là để sử dụng IEnumerable<T>là GetEnumeratortrong việc thực hiện rõ ràng của 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();
    }
}

Tại sao bạn làm nó bằng tay? yield returntự động hóa toàn bộ quá trình xử lý các vòng lặp. (Tôi cũng đã viết về nó trên blog của mình , bao gồm một cái nhìn về mã trình biên dịch được tạo ra).

Nếu bạn thực sự muốn làm điều đó một mình, bạn cũng phải trả lại một điều tra viên chung chung. Bạn sẽ không thể sử dụng ArrayListthêm nữa vì đó không phải là chung chung. Thay đổi nó để List<MyObject>thay thế. Tất nhiên điều đó giả định rằng bạn chỉ có các đối tượng thuộc loại MyObject(hoặc các loại dẫn xuất) trong bộ sưu tập của bạn.

Nếu bạn làm việc với generic, hãy sử dụng List thay vì ArrayList. Danh sách có chính xác phương thức GetEnumerator mà bạn cần.

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

biến danh sách của tôi thành một List<MyObject>, là một lựa chọn

Lưu ý rằng tất cả đã được IEnumerable<T>triển khai theo System.Collectionscách tiếp cận khác là lấy MyObjectslớp của bạn từ System.Collectionslớp cơ sở ( tài liệu ):

System.Collections: Cung cấp lớp cơ sở cho một bộ sưu tập chung.

Chúng tôi sau đó có thể làm cho implemenation riêng của chúng tôi để ghi đè lên các ảo System.Collectionsphương pháp để cung cấp hành vi tùy chỉnh (chỉ dành cho ClearItems, InsertItem, RemoveItem, và SetItemcùng với Equals, GetHashCodevà ToStringtừ Object). Không giống như List<T>cái không được thiết kế để có thể dễ dàng mở rộng.

Thí dụ:

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

Xin lưu ý rằng lái xe từ collectionchỉ được đề xuất trong trường hợp khi cần hành vi thu thập tùy chỉnh, điều này hiếm khi xảy ra. xem cách sử dụng .