Может ли кто-нибудь объяснить мне IEnumerable и IEnumerator?[закрыто]

StackOverflow https://stackoverflow.com/questions/558304

  •  05-09-2019
  •  | 
  •  

Вопрос

Может ли кто-нибудь объяснить мне IEnumerable и IEnumerator?

например, когда использовать его вместо foreach?в чем разница между IEnumerable и IEnumerator?Почему нам нужно его использовать?

Это было полезно?

Решение

например, когда использовать его вместо foreach?

Вы не используете IEnumerable "над" foreach.Реализация IEnumerable заставляет использовать foreach возможный.

Когда вы пишете код типа:

foreach (Foo bar in baz)
{
   ...
}

это функционально эквивалентно написанию:

IEnumerator bat = baz.GetEnumerator();
while (bat.MoveNext())
{
   bar = (Foo)bat.Current
   ...
}

Под «функциональным эквивалентом» я имею в виду то, во что на самом деле компилятор превращает код.Вы не можете использовать foreach на baz в этом примере пока не baz реализует IEnumerable.

IEnumerable Значит это baz реализует метод

IEnumerator GetEnumerator()

А IEnumerator объект, возвращаемый этим методом, должен реализовывать методы

bool MoveNext()

и

Object Current()

Первый метод переходит к следующему объекту в IEnumerable объект, создавший перечислитель, возвращающий false если это сделано, а второй возвращает текущий объект.

Все, что вы можете перебирать в .Net, реализует IEnumerable.Если вы создаете свой собственный класс, и он еще не наследуется от класса, реализующего IEnumerable, вы можете сделать свой класс пригодным для использования в foreach заявления путем реализации IEnumerable (и создав класс перечислителя, который его новый GetEnumerator метод вернется).

Другие советы

Интерфейсы 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);
}

Хотя может показаться, что только типы массивов могут использовать эту конструкцию, истина в том, что любой тип, поддерживающий метод с именем getEnumerator (), может быть оценена с помощью Foreach Construct. Чтобы проиллюстрировать, следуйте за мной!

Предположим, у нас есть класс Garage:

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

В идеале, было бы удобно итерации по подтогам гаражного объекта, используя конструкцию Foreach, как и массив значений данных:

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

К сожалению, компилятор сообщает вам, что класс гаража не реализует метод с именем getenumerator ().Этот метод формализуется интерфейсом IEnumerable, который находится в пространстве имен System.Collections.Классы или структуры, которые поддерживают это поведение, рекламируют, что они могут разоблачить, содержали подразделения для вызывающего абонента (в этом примере само ключевое слово Foreach).Вот определение этого стандартного интерфейса .NET:

// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
   IEnumerator GetEnumerator();
}

Как видите, метод getEnumerator () возвращает ссылку на еще один интерфейс с именем System.collections.Ienumerator.Этот интерфейс предоставляет инфраструктуру, позволяющую вызывающей стороне проходить внутренние объекты, содержащиеся в 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 (), current и reset (), существует более простой способ.Поскольку тип 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();
   }
}

После обновления типа Garage вы можете безопасно использовать этот тип в конструкции foreach C#.Более того, учитывая, что метод 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();
}

Таким образом, пользователь случайного объекта не найдет метод Garage GetEnumerator (), в то время как конструкция Foreach получит интерфейс в фоновом режиме при необходимости.

Адаптировано из Pro C# 5.0 и .NET 4.5 Framework

Реализация IEnumerable означает, что ваш класс возвращает объект IEnumerator:

public class People : IEnumerable
{
    IEnumerator IEnumerable.GetEnumerator()
    {
        // return a PeopleEnumerator
    }
}

Реализация IEnumerator означает, что ваш класс возвращает методы и свойства для итерации:

public class PeopleEnumerator : IEnumerator
{
    public void Reset()...

    public bool MoveNext()...

    public object Current...
}

В любом случае, в этом разница.

Объяснение через аналогию + пошаговое руководство по коду

Сначала объяснение без кода, потом добавлю.

Допустим, вы управляете авиакомпанией.И в каждом самолете вы хотите знать информацию о пассажирах, летящих в самолете.По сути, вы хотите иметь возможность «пересекать» самолет.Другими словами, вы хотите иметь возможность начать с переднего сиденья, а затем продвигаться к задней части самолета, спрашивая у пассажиров некоторую информацию:кто они, откуда и т. д.Самолет может это сделать только в том случае, если он:

  1. счетный, и
  2. если у него есть счетчик.

Почему эти требования? Потому что этого требует интерфейс.

Если это информационная перегрузка, все, что вам нужно знать, это то, что вы хотите иметь возможность задать вопросы каждому пассажиру в самолете, начиная с первого и добираясь до последнего.

Что значит счетный?

Если авиакомпания «подсчитывается», это означает, что в самолете ДОЛЖЕН присутствовать бортпроводник, единственная работа которого — считать, и этот бортпроводник ДОЛЖЕН считать очень специфическим образом:

  1. Стойка/бортпроводник ДОЛЖНЫ начать перед первым пассажиром (перед всеми, где они демонстрируют безопасность, как надевать спасательный жилет и т. д.).
  2. Он/она (т.бортпроводник) ДОЛЖЕН «идти дальше» по проходу к первому месту.
  3. Затем он/она должен записать:(i) кто находится на месте человека и (ii) его текущее местоположение в проходе.

Процедуры подсчета

Капитан авиакомпании хочет получить отчет о каждом пассажире, когда и когда они будут расследованы или подсчитаны.Таким образом, после разговора с человеком, сидящим на первом сиденье, бортпроводник/стойка затем отчитывается перед капитаном, и когда отчет предоставляется, стойка запоминает его/ее точное положение в проходе и продолжает отсчет с того места, где он/она ушел. выключенный.

Таким образом, капитан всегда может иметь информацию о человеке, в отношении которого ведется расследование.Таким образом, если он узнает, что этому человеку нравится «Манчестер Сити», он сможет предоставить этому пассажиру льготы и т. д.

  • Счетчик продолжает идти, пока он не достигнет конца самолета.

Давайте свяжем это с IEnumerables.

  • Перечисляемое — это просто набор пассажиров в самолете.Закон о гражданской авиации — это, по сути, правила, которым должны следовать все IEnumerables.Каждый раз, когда бортпроводник обращается к капитану с информацией о пассажире, мы по сути «уступаем» пассажира капитану.Капитан, по сути, может делать с пассажиром все, что захочет – кроме перестановки пассажиров в самолете.В этом случае им будут предоставлены льготы, если они последуют за «Манчестер Сити» (тьфу!)

    foreach (Passenger passenger in Plane)
// the airline hostess is now at the front of the plane
// and slowly making her way towards the back
// when she get to a particular passenger she gets some information
// about the passenger and then immediately heads to the cabin
// to let the captain decide what to do with it
{ // <---------- Note the curly bracket that is here.
    // we are now cockpit of the plane with the captain.
    // the captain wants to give the passenger free 
    // champaign if they support manchester city
    if (passenger.supports_mancestercity())
    {
        passenger.getFreeChampaign();
    } else
    {
        // you get nothing! GOOD DAY SIR!
    }
} //  <---- Note the curly bracket that is here!
      the hostess has delivered the information 
      to the captain and goes to the next person
      on the plane (if she has not reached the 
      end of the plane)

Краткое содержание

Другими словами, нечто счетно, если оно есть счетчик.И счетчик должен (в основном):(i) запомнить свое место (состояние), (ii) уметь двигаться дальше, (iii) и знать о текущий человек, с которым он имеет дело.

Enumerable — это просто причудливое слово, обозначающее «счетный».Другими словами, перечисляемое позволяет вам «перечислять» (т.е.считать).

IEnumerable реализует GetEnumerator.При вызове этот метод возвращает IEnumerator который реализует MoveNext, Reset и Current.

Таким образом, когда ваш класс реализует IEnumerable, вы говорите, что можете вызвать метод (GetEnumerator) и получить возвращенный новый объект (IEnumerator), который вы можете использовать в цикле, например foreach.

Реализация IEnumerable позволяет получить IEnumerator для списка.

IEnumerator обеспечивает последовательный доступ к элементам списка в стиле foreach с помощью ключевого слова доходности.

До реализации foreach (например, в Java 1.4) способ перебора списка состоял в том, чтобы получить перечислитель из списка, а затем запросить у него «следующий» элемент в списке до тех пор, пока значение возвращалось как следующий элемент не равен нулю.Foreach просто делает это неявно как функция языка, точно так же, как lock() скрыто реализует класс Monitor.

Я ожидаю, что foreach будет работать со списками, поскольку они реализуют IEnumerable.

  • Объект, реализующий IEnumerable позволяет другим посещать каждый из его элементов (перечислителем).
  • Объект, реализующий IEnumerator это выполнение итерации.Это цикл по перечислимому объекту.

Думайте о перечислимых объектах как о списках, стопках и деревьях.

IEnumerable и IEnumerator (и их универсальные аналоги IEnumerable<T> и IEnumerator<T>) являются базовыми интерфейсами итератор реализации в Коллекции классов .Net Framework Libray.

IEnumerable — это наиболее распространенный интерфейс, который вы можете увидеть в большей части кода.Он включает цикл foreach, генераторы (подумайте урожай), а из-за своего крошечного интерфейса он используется для создания жестких абстракций. IEnumerable зависит от IEnumerator.

IEnumerator, с другой стороны, предоставляет интерфейс итерации немного более низкого уровня.Это называется явный итератор что дает программисту больше контроля над циклом итерации.

IEnumerable

IEnumerable — это стандартный интерфейс, который позволяет перебирать коллекции, которые его поддерживают (фактически, все типы коллекций, о которых я могу думать сегодня, реализуют IEnumerable).Поддержка компилятора позволяет использовать такие языковые функции, как foreach.В общих чертах это позволяет неявная реализация итератора.

цикл foreach

foreach (var value in list)
  Console.WriteLine(value);

Я думаю foreach цикл является одной из основных причин использования IEnumerable интерфейсы. foreach имеет очень краткий синтаксис и его очень легко понять по сравнению с классическим С стиль для циклов, где вам нужно проверить различные переменные, чтобы увидеть, что он делает.

Ключевое слово доходности

Вероятно, менее известная особенность заключается в том, что IEnumerable также позволяет генераторы в C# с использованием yield return и yield break заявления.

IEnumerable<Thing> GetThings() {
   if (isNotReady) yield break;
   while (thereIsMore)
     yield return GetOneMoreThing();
}

Абстракции

Другим распространенным сценарием на практике является использование IEnumerable обеспечить минималистичные абстракции.Поскольку это миниатюрный интерфейс, доступный только для чтения, вам рекомендуется предоставлять свои коллекции как IEnumerable (скорее, чем Список например).Таким образом, вы можете изменить свою реализацию, не нарушая код вашего клиента (измените List на Связанный список например).

Попался

Следует учитывать одно поведение: в реализациях потоковой передачи (например,извлекать данные построчно из базы данных вместо предварительной загрузки всех результатов в память), вы не могу перебирать коллекцию более одного раза.В этом отличие от коллекций в памяти, таких как Список, где вы можете без проблем повторить несколько раз.РеШарпер, например, имеет проверку кода для Возможное множественное перечисление IEnumerable.

IEnumerator

IEnumerator, с другой стороны, представляет собой закулисный интерфейс, который делает IEnumerble-foreach-magic работа.Строго говоря, он позволяет использовать явные итераторы.

var iter = list.GetEnumerator();
while (iter.MoveNext())
    Console.WriteLine(iter.Current);

По моему опыту IEnumerator редко используется в обычных сценариях из-за более подробного синтаксиса и немного запутанной семантики (по крайней мере, для меня;например ПереместитьСледующий() также возвращает значение, о котором имя вообще не предполагает).

Вариант использования IEnumerator

Я использовал только IEnumerator в частности (чуть более низкого уровня) библиотеки и фреймворки, в которых я предоставлял IEnumerable интерфейсы.Одним из примеров является библиотека обработки потоков данных, которая предоставляет ряд объектов в виде foreach цикл, хотя данные собирались «за кулисами» с использованием различных файловых потоков и сериализаций.

Код клиента

foreach(var item in feed.GetItems())
    Console.WriteLine(item);

Библиотека

IEnumerable GetItems() {
    return new FeedIterator(_fileNames)
}

class FeedIterator: IEnumerable {
    IEnumerator GetEnumerator() {
        return new FeedExplicitIterator(_stream);
    }
}

class FeedExplicitIterator: IEnumerator {
    DataItem _current;

    bool MoveNext() {
        _current = ReadMoreFromStream();
        return _current != null;           
    }

    DataItem Current() {
        return _current;   
    }
}

Реализация IEnumerable по сути означает, что объект можно перебирать.Это не обязательно означает, что это массив, поскольку существуют определенные списки, которые нельзя индексировать, но вы можете их перечислить.

IEnumerator — это фактический объект, используемый для выполнения итераций.Он управляет переходом от одного объекта к другому в списке.

Большую часть времени, IEnumerable & IEnumerator используются прозрачно как часть foreach петля.

Различия между IEnumerable и IEnumerator:

  • IEnumerable использует IEnumerator внутри себя.
  • IEnumerable не знает, какой элемент/объект выполняется.
  • Всякий раз, когда мы передаем IEnumerator другой функции, она знает текущую позицию элемента/объекта.

  • Всякий раз, когда мы передаем туалетную коллекцию в другую функцию, она не знает текущей позиции элемента/объекта (не знает, какой элемент его выполняет)

    IEnumerable имеет один метод GetEnumerator()

public interface IEnumerable<out T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}

IEnumerator имеет одно свойство current и два метода Reset и MoveNext (которые полезны для определения текущей позиции элемента в списке).

public interface IEnumerator
{
     object Current { get; }
     bool MoveNext();
     void Reset();
}

Вам будет полезно понимание шаблона «Итератор».Рекомендую прочитать то же самое.

Шаблон итератора

На высоком уровне шаблон итератора можно использовать для обеспечения стандартного способа перебора коллекций любого типа.У нас есть 3 участника шаблона итератора: фактическая коллекция (клиент), агрегатор и итератор.Агрегат — это интерфейсный/абстрактный класс, имеющий метод, возвращающий итератор.Итератор — это интерфейсный/абстрактный класс, который имеет методы, позволяющие нам перебирать коллекцию.

Чтобы реализовать шаблон, нам сначала необходимо реализовать итератор для производства бетона, который может итерации над соответствующей коллекцией (клиентом), тогда коллекция (клиент) реализует агрегатор для возврата экземпляра вышеуказанного итератора.

Вот UML-диаграммаIterator Pattern

Таким образом, в С# IEnumerable — это абстрактный агрегат, а IEnumerator — абстрактный итератор.IEnumerable имеет единственный метод GetEnumerator, отвечающий за создание экземпляра IEnumerator нужного типа.Коллекции, такие как списки, реализуют IEnumerable.

Пример.Предположим, у нас есть метод getPermutations(inputString) который возвращает все перестановки строки и что метод возвращает экземпляр IEnumerable<string>

Чтобы подсчитать количество перестановок, мы могли бы сделать что-то вроде приведенного ниже.

 int count = 0;
        var permutations = perm.getPermutations(inputString);
        foreach (string permutation in permutations)
        {
            count++;
        }

Компилятор C# более или менее преобразует приведенное выше в

using (var permutationIterator = perm.getPermutations(input).GetEnumerator())
        {
            while (permutationIterator.MoveNext())
            {
                count++;
            }
        }

Если у вас есть какие-либо вопросы, пожалуйста, не стесняйтесь спрашивать.

IEnumerable — это блок, содержащий Ienumerator.IEnumerable — базовый интерфейс для всех коллекций.Цикл foreach может работать, если коллекция реализует IEnumerable.В приведенном ниже коде объясняется, как создать собственный перечислитель.Давайте сначала определим наш класс, из которого мы собираемся создать коллекцию.

public class Customer
{
    public String Name { get; set; }
    public String City { get; set; }
    public long Mobile { get; set; }
    public double Amount { get; set; }
}

Теперь мы определим класс, который будет действовать как коллекция для нашего класса Customer.Обратите внимание, что он реализует интерфейс IEnumerable.Итак, нам нужно реализовать метод GetEnumerator.Это вернет наш собственный перечислитель.

public class CustomerList : IEnumerable
{
    Customer[] customers = new Customer[4];
    public CustomerList()
    {
        customers[0] = new Customer { Name = "Bijay Thapa", City = "LA", Mobile = 9841639665, Amount = 89.45 };
        customers[1] = new Customer { Name = "Jack", City = "NYC", Mobile = 9175869002, Amount = 426.00 };
        customers[2] = new Customer { Name = "Anil min", City = "Kathmandu", Mobile = 9173694005, Amount = 5896.20 };
        customers[3] = new Customer { Name = "Jim sin", City = "Delhi", Mobile = 64214556002, Amount = 596.20 };
    }

    public int Count()
    {
        return customers.Count();
    }
    public Customer this[int index]
    {
        get
        {
            return customers[index];
        }
    }
    public IEnumerator GetEnumerator()
    {
        return customers.GetEnumerator(); // we can do this but we are going to make our own Enumerator
        return new CustomerEnumerator(this);
    }
}

Теперь мы собираемся создать наш собственный перечислитель, как показано ниже.Итак, нам нужно реализовать метод MoveNext.

 public class CustomerEnumerator : IEnumerator
    {
        CustomerList coll;
        Customer CurrentCustomer;
        int currentIndex;
        public CustomerEnumerator(CustomerList customerList)
        {
            coll = customerList;
            currentIndex = -1;
        }

        public object Current => CurrentCustomer;

        public bool MoveNext()
        {
            if ((currentIndex++) >= coll.Count() - 1)
                return false;
            else
                CurrentCustomer = coll[currentIndex];
            return true;
        }

        public void Reset()
        {
            // we dont have to implement this method.
        }
    }

Теперь мы можем использовать цикл foreach для нашей коллекции, как показано ниже;

    class EnumeratorExample
    {
        static void Main(String[] args)
        {

            CustomerList custList = new CustomerList();
            foreach (Customer cust in custList)
            {
                Console.WriteLine("Customer Name:"+cust.Name + " City Name:" + cust.City + " Mobile Number:" + cust.Amount);
            }
            Console.Read();

        }
    }

Незначительный вклад.

Как многие из них объясняют, «когда использовать» и «использовать с foreach».Я думал добавить еще один Разница штатов здесь, как и просили, речь идет о разнице между IEnumerable и IEnumerator.

Я создал приведенный ниже пример кода на основе приведенных ниже тем обсуждения.

IEnumerable, IEnumerator против foreach, когда что использовать В чем разница между IEnumerator и IEnumerable?

Enumerator сохраняет состояние (позицию итерации) между вызовами функций, в то время как итерации, с другой стороны, Enumerable, этого не делают.

Вот протестированный пример с комментариями для понимания.

Знатоки, дополните/поправьте меня.

static void EnumerableVsEnumeratorStateTest()
{
    IList<int> numList = new List<int>();

    numList.Add(1);
    numList.Add(2);
    numList.Add(3);
    numList.Add(4);
    numList.Add(5);
    numList.Add(6);

    Console.WriteLine("Using Enumerator - Remembers the state");
    IterateFrom1to3(numList.GetEnumerator());

    Console.WriteLine("Using Enumerable - Does not Remembers the state");
    IterateFrom1to3Eb(numList);

    Console.WriteLine("Using Enumerable - 2nd functions start from the item 1 in the collection");
}

static void IterateFrom1to3(IEnumerator<int> numColl)
{
    while (numColl.MoveNext())
    {
        Console.WriteLine(numColl.Current.ToString());

        if (numColl.Current > 3)
        {
            // This method called 3 times for 3 items (4,5,6) in the collection. 
            // It remembers the state and displays the continued values.
            IterateFrom3to6(numColl);
        }
    }
}

static void IterateFrom3to6(IEnumerator<int> numColl)
{
    while (numColl.MoveNext())
    {
        Console.WriteLine(numColl.Current.ToString());
    }
}

static void IterateFrom1to3Eb(IEnumerable<int> numColl)
{
    foreach (int num in numColl)
    {
        Console.WriteLine(num.ToString());

        if (num>= 5)
        {
            // The below method invokes for the last 2 items.
            //Since it doesnot persists the state it will displays entire collection 2 times.
            IterateFrom3to6Eb(numColl);
        }
    }
}

static void IterateFrom3to6Eb(IEnumerable<int> numColl)
{
    Console.WriteLine();
    foreach (int num in numColl)
    {
        Console.WriteLine(num.ToString());
    }
}

Я заметил эти различия:

А.Мы перебираем список по-разному: foreach можно использовать для IEnumerable, а цикл while для IEnumerator.

Б.IEnumerator может запомнить текущий индекс, когда мы переходим от одного метода к другому (он начинает работать с текущим индексом), но IEnumerable не может запомнить индекс и сбрасывает индекс в начало.Подробнее в этом видео https://www.youtube.com/watch?v=jd3yUjGc9M0

IEnumerable и IEnumerator оба являются интерфейсами в C#.

IEnumerable это интерфейс, определяющий один метод GetEnumerator() который возвращает IEnumerator интерфейс.

Это работает для доступа только для чтения к коллекции, которая реализует это. IEnumerable может использоваться с foreach заявление.

IEnumerator имеет два метода, MoveNext и Reset.У него также есть свойство под названием Current.

Ниже показана реализация IEnumerable и IEnumerator.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Enudemo
{

    class Person
    {
        string name = "";
        int roll;

        public Person(string name, int roll)
        {
            this.name = name;
            this.roll = roll;
        }

        public override string ToString()
        {
            return string.Format("Name : " + name + "\t Roll : " + roll);
        }

    }


    class Demo : IEnumerable
    {
        ArrayList list1 = new ArrayList();

        public Demo()
        {
            list1.Add(new Person("Shahriar", 332));
            list1.Add(new Person("Sujon", 333));
            list1.Add(new Person("Sumona", 334));
            list1.Add(new Person("Shakil", 335));
            list1.Add(new Person("Shruti", 336));
        }

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



    class Program
    {
        static void Main(string[] args)
        {
            Demo d = new Demo();  // Notice here. it is simple object but for 
                                //IEnumerator you can get the collection data

            foreach (Person X in d)
            {
                Console.WriteLine(X);
            }

            Console.ReadKey();
        }
    }
}
/*
Output : 

Name : Shahriar  Roll : 332
Name : Sujon     Roll : 333
Name : Sumona    Roll : 334
Name : Shakil    Roll : 335
Name : Shruti    Roll : 336
  */
Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top