Enumerator(s)

You've all used the foreach loop in .NET to get the values in a container. The foreach actually uses that objects Enumerator.
In order to allow the use of the foreach on an object the class must implement the IEnumerable.GetEnumerator method which also means you have to implement the IEnumerable interface. Within the GetEnumerator override you need to return an instance of IEnumerator, so you need to create a class that implements the IEnumerator interface. see the code.

This is useful if you class contains a member variable which is an or even a container. Let's say it's an array. When an instance of your class is create the array is also instantiated. But you don't want the array to be visible but you do want clients to be able to use a foreach on your class instance, this can be achieved by implementing the IEnumerable interface and overriding the GetEnumerator method.

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace Enumerator
{


public class Person
{
public Person(string fName, string lName)
{
  this.firstName = fName;
  this.lastName = lName;
}

public string firstName;
public string lastName;
}
public class People : IEnumerable
{
    private Person[] _people;
    public People(Person[] pArray)
    {
        _people = new Person[pArray.Length];

        for (int i = 0; i < position =" -1;" _people =" list;" position =" -1;" peoplearray =" new" peoplelist =" new">

System.Collections.IEnumerable

Yield

This is a keyword in .NET, it's placed before the return value where your implementation of IEnumerable.
When you use yield your actually replacing the requirement for an Enumerator, Yield acts as the Enumerator. So if your iterating through your own type (a class made by yourself) you's usually have to create an implemetation of the IEnumerator interface to tell the foreach for example how to move to the next item in the list i.e. MoveNext(). Now you can use the Yield keyword instead which saves you work.

The Yield actually returns a value from the collection and then goes back to the loop and gets the next value in the loop, remembering the context.

The Yield keyword can be used in your IEnumerable implementations GetEnumerator() method or in the foreach itself.
This can be done in the IEnumerable's GetEnumerator() method
e.g.
public IEnumerator GetEnumerator()
{
for(int i=0;i<_people.length;i++)>
yield return _people[i];
}
instead of
public IEnumerator GetEnumerator(){
return new PeopleEnum(_people);
}
which uses an implementation of IEnumerator, which in turn returns the array of _people, to return the enumerator

If you want to return an Enumerable list from a method i.e. you want to return a list of object which you can iterate through from a method you'll need to use the yield keyword.

The keyword yield is required when returning an IEnumerable object from a method like so


public static IEnumerable DoSomething()
{
int counter = 10;
int result = 1;
while (result <>