मैं कैसे लागू करते हैं IEnumerable <T>

Question

मुझे पता है कि गैर सामान्य 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 Interface का चयन करें, विजुअल स्टूडियो काम आते हुए निम्नलिखित ब्लॉक कहते हैं कोड:

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

रिटर्न GetEnumerator(); विधि से गैर जेनेरिक आईनेमेरेबल ऑब्जेक्ट इस समय काम नहीं करता है, तो मैं यहां क्या रखूं? सीएलआई अब जेनेरिक संस्करण के लिए गैर सामान्य कार्यान्वयन और सिर को अनदेखा करता है जब यह फोरच लूप के दौरान मेरी सरणी के माध्यम से गणना करने का प्रयास करता है।

धन्यवाद

Answer 1

आप इस तरह के ArrayList के बजाय List<MyObject> के रूप में एक सामान्य संग्रह का उपयोग करने के लिए चुनते हैं, तो आप पाएंगे कि 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(); 
    } 
} 

Answer 2

आप इसे मैन्युअल रूप से क्यों करते हैं? yield return इटरेटर को संभालने की पूरी प्रक्रिया को स्वचालित करता है। (मैंने इसके बारे में on my blog भी लिखा, जिसमें संकलक उत्पन्न कोड पर एक नज़र शामिल है)।

यदि आप वास्तव में इसे स्वयं करना चाहते हैं, तो आपको भी एक सामान्य गणनाकर्ता वापस करना होगा। आप गैर-जेनेरिक के बाद से ArrayList का उपयोग करने में सक्षम नहीं होंगे। इसे इसके बजाय List<MyObject> पर बदलें। यह निश्चित रूप से मानता है कि आपके संग्रह में केवल MyObject (या व्युत्पन्न प्रकार) के प्रकार हैं। एक List<MyObject> में

Answer 3

मेकअप MyList, एक ही विकल्प

Answer 4

आप शायद नहीं है एक स्पष्टIEnumerable<T> के कार्यान्वयन (जो कि तुम क्या दिखाया है) चाहते हैं।

सामान्य पैटर्न IEnumerable की स्पष्ट कार्यान्वयन में IEnumerable<T> के GetEnumerator उपयोग करने के लिए है:

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

Answer 5

आप जेनरिक, उपयोग ArrayList के बजाय सूची के साथ काम करते हैं। सूची में आपको वास्तव में GetEnumerator विधि की आवश्यकता है।

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