IEnumerable और IEnumerator इंटरफेस
मौजूदा .NET इंटरफेस को लागू करने की प्रक्रिया की जांच शुरू करने के लिए, आइए पहले IEnumerable और IEnumerator की भूमिका देखें। याद रखें कि C # foreach नाम के एक कीवर्ड का समर्थन करता है जो आपको किसी भी प्रकार की सामग्री पर पुनरावृति करने की अनुमति देता है:
// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
Console.WriteLine(i);
}
हालांकि ऐसा लग सकता है कि केवल सरणी प्रकार इस निर्माण का उपयोग कर सकते हैं, मामले की सच्चाई किसी भी प्रकार का है जो गेटनेमर (नामक एक विधि का समर्थन करता है) का मूल्यांकन फ़ोरच निर्माण द्वारा किया जा सकता है। उदाहरण के लिए, मेरा अनुसरण करें!
मान लीजिए कि हमारे पास गैराज क्लास है:
// Garage contains a set of Car objects.
public class Garage
{
private Car[] carArray = new Car[4];
// Fill with some Car objects upon startup.
public Garage()
{
carArray[0] = new Car("Rusty", 30);
carArray[1] = new Car("Clunker", 55);
carArray[2] = new Car("Zippy", 30);
carArray[3] = new Car("Fred", 30);
}
}
आदर्श रूप से, यह फॉरेक्स कंस्ट्रक्शन का उपयोग करके गैराज ऑब्जेक्ट के सबिटम्स पर पुनरावृति करने के लिए सुविधाजनक होगा, डेटा मानों की एक सरणी की तरह:
// This seems reasonable ...
public class Program
{
static void Main(string[] args)
{
Console.WriteLine("***** Fun with IEnumerable / IEnumerator *****\n");
Garage carLot = new Garage();
// Hand over each car in the collection?
foreach (Car c in carLot)
{
Console.WriteLine("{0} is going {1} MPH",
c.PetName, c.CurrentSpeed);
}
Console.ReadLine();
}
}
अफसोस की बात है कि कंपाइलर आपको सूचित करता है कि गैराज क्लास गेटनेमर () नाम की एक विधि को लागू नहीं करता है। इस विधि को IEnumerable इंटरफ़ेस द्वारा औपचारिक रूप दिया गया है, जो System.Collections नाम स्थान के भीतर गुप्त पाया जाता है। इस व्यवहार का समर्थन करने वाले वर्ग या संरचनाएं विज्ञापन देती हैं कि वे कॉलगर्ल में निहित उपप्रकारों को उजागर करने में सक्षम हैं (इस उदाहरण में, स्वयं फ़ॉरवर्ड कीवर्ड)। इस मानक .NET इंटरफ़ेस की परिभाषा इस प्रकार है:
// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
जैसा कि आप देख सकते हैं, GetEnumerator () विधि System.Collections.IEVumter नाम के किसी अन्य इंटरफ़ेस के संदर्भ को संदर्भित करता है। यह इंटरफ़ेस IEnumerable- संगत कंटेनर द्वारा निहित आंतरिक ऑब्जेक्ट्स को कॉल करने की अनुमति देने के लिए बुनियादी ढांचा प्रदान करता है:
// This interface allows the caller to
// obtain a container's subitems.
public interface IEnumerator
{
bool MoveNext (); // Advance the internal position of the cursor.
object Current { get;} // Get the current item (read-only property).
void Reset (); // Reset the cursor before the first member.
}
यदि आप इन इंटरफेस का समर्थन करने के लिए गैराज प्रकार को अपडेट करना चाहते हैं, तो आप लंबी सड़क ले सकते हैं और प्रत्येक विधि को मैन्युअल रूप से लागू कर सकते हैं। हालाँकि, आप निश्चित रूप से GetEnumerator (), MoveNext (), करंट, और रीसेट () के अनुकूलित संस्करण प्रदान करने के लिए स्वतंत्र हैं, एक सरल तरीका है। जैसा कि System.Array प्रकार (और साथ ही कई अन्य संग्रह कक्षाएं) पहले से ही IEnumerable और IEnumerator लागू करता है, आप बस System.Array के अनुरोध को निम्न प्रकार से प्रस्तुत कर सकते हैं:
using System.Collections;
...
public class Garage : IEnumerable
{
// System.Array already implements IEnumerator!
private Car[] carArray = new Car[4];
public Garage()
{
carArray[0] = new Car("FeeFee", 200);
carArray[1] = new Car("Clunker", 90);
carArray[2] = new Car("Zippy", 30);
carArray[3] = new Car("Fred", 30);
}
public IEnumerator GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
}
आपके गैराज प्रकार को अपडेट करने के बाद, आप सुरक्षित रूप से C # foreach निर्माण में टाइप का उपयोग कर सकते हैं। इसके अलावा, यह देखते हुए कि GetEnumerator () विधि को सार्वजनिक रूप से परिभाषित किया गया है, ऑब्जेक्ट उपयोगकर्ता IEnumerator प्रकार के साथ भी बातचीत कर सकता है:
// Manually work with IEnumerator.
IEnumerator i = carLot.GetEnumerator();
i.MoveNext();
Car myCar = (Car)i.Current;
Console.WriteLine("{0} is going {1} MPH", myCar.PetName, myCar.CurrentSpeed);
हालाँकि, यदि आप ऑब्जेक्ट स्तर से IEnumerable की कार्यक्षमता को छिपाना पसंद करते हैं, तो बस स्पष्ट इंटरफ़ेस कार्यान्वयन का उपयोग करें:
IEnumerator IEnumerable.GetEnumerator()
{
// Return the array object's IEnumerator.
return carArray.GetEnumerator();
}
ऐसा करने से, आकस्मिक ऑब्जेक्ट उपयोगकर्ता को गैराज का गेटएनीमेटर () विधि नहीं मिलेगी, जबकि फ़ॉरच निर्माण में आवश्यक होने पर पृष्ठभूमि में इंटरफ़ेस प्राप्त होगा।
प्रो सी # 5.0 और .NET 4.5 फ्रेमवर्क से अनुकूलित
