A brief introduction to the C# IEnumerable and IEnumerator interfaces

This article mainly introduces the relevant knowledge of the IEnumerable and IEnumerator interfaces in C#, which has a very good reference value. Let’s take a look at it with the editor.

Review the past and learn the new. You can be a teacher. It is necessary to review basic knowledge frequently when you have time, and it can deepen your understanding and memory.

Foreach is often used to iterate through collections and traverse containers that implement the IEnumerable interface. I am sometimes a little confused about the IEnumerable and IEnumerator interfaces. According to the official explanation, IEnumerable is an enumerator interface, and IEnumerator is an iterator. The interfaces are not very different from the literal meaning. Let’s analyze them one by one.

IEnumerable interface

public interface IEnumerable
{ 
 IEnumerator GetEnumerator();
}

Classes that inherit IEnumerable interface need to implement the exposed GetEnumerator() method and return an IEnumerator interface object, see It is IEnumerator that really does the work. F12 to see what the heck there is in IEnumerator.

IEnumerator interface

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

IEnumerator interface has three things, one attributeCurrent, returns the elements in the current collection, and the method MoveNext() moves Going to the next one, isn't traversal all backward traversal? Reset() literally means reset. This is easy to understand. Make a hypothesis: Since the IEnumerable interface returns an IEnumerator interface iterator, can a custom container be implemented by only inheriting the IEnumerator iterator interface?

Define a Phone class

public class Phone 
{
 public string Name;
 public Phone(string name)
 {
  this.Name = name;
 }
}

Define an iterator named MyEnumerator and implement its interface IEnumerator

public class MyEnumerator : IEnumerator
{
 Phone[] p;
 int idx = -1;
 public MyEnumerator(Phone[] t)
 {
  p = t;
 }
 public object Current
 {
  get
  {
  if (idx == -1)
   return new IndexOutOfRangeException();
  return p[idx];
  }
 }
 public bool MoveNext()
 {
  idx++;
  return p.Length > idx;
 }
 public void Reset()
 {
  idx = -1;
 }
}

class Program
 {
 static void Main(string[] args)
 {
 　　　　　　show("-----------IEnumerator------------");
  Phone[] phones = new Phone[] { new Phone("iPhone 7s"), new Phone("iPhone 6s"), new Phone("iPhone 5s") };
  MyEnumerator enumerator = new MyEnumerator(phones);
  while (enumerator.MoveNext())
  {
  Phone p = enumerator.Current as Phone;
  show(p.Name);
  }
  Console.ReadKey();
 }
 static void show(string i)
 {
  Console.WriteLine(i);
 }
 }

The results show:

As expected, what really does the work is the IEnumerator interface, which can loop through a custom container. However, the original intention is I want to use Foreach for loop access and traversal. Well, then we can only display the IEnumerable interface to do it. Slightly transform the Phone class:

public class Phone : IEnumerable
 {
 public string Name ;
 public Phone(string name)
 {
  this.Name = name;
 }
 Phone[] p;
 public Phone(Phone[] t)
 {
  p = t;
 }
 public IEnumerator GetEnumerator()
 {
  return new MyEnumerator(p);
 }
 }

static void Main(string[] args)
 {
  show("-----------IEnumerator------------");
  Phone[] phones = new Phone[] { new Phone("iPhone 7s"), new Phone("iPhone 6s"), new Phone("iPhone 5s") };
  MyEnumerator enumerator = new MyEnumerator(phones);
  while (enumerator.MoveNext())
  {
  Phone p = enumerator.Current as Phone;
  show(p.Name);
  }
  show("-----------IEnumerable------------");
  Phone phoneList = new Phone(phones);
  foreach (Phone p in phoneList)
  {
  show(p.Name);
  }
  Console.ReadKey();
 }

The result shows:

Done, then expand it into a universal container PhonePackage, inherit the generic The IEnumerable interface is sufficient.

public class PhonePackage<T> : IEnumerable<T> 
 {
 private List<T> dataList = null;
 public void Add(T t)
 {
  if (dataList == null)
  dataList = new List<T>();
  dataList.Add(t);
 }
 public IEnumerator<T> GetEnumerator()
 {
  foreach (T t in dataList)
  {
  yield return t;
  }
 }
 IEnumerator IEnumerable.GetEnumerator()
 {
  foreach (T t in dataList)
  {
  yield return t;
  }
 }
 }

static void Main(string[] args)
 {
  show("-----------IEnumerator------------");
  Phone[] phones = new Phone[] { new Phone("iPhone 7s"), new Phone("iPhone 6s"), new Phone("iPhone 5s") };
  MyEnumerator enumerator = new MyEnumerator(phones);
  while (enumerator.MoveNext())
  {
  Phone p = enumerator.Current as Phone;
  show(p.Name);
  }
  show("-----------IEnumerable------------");
  Phone phoneList = new Phone(phones);
  foreach (Phone p in phoneList)
  {
  show(p.Name);
  }
  show("-----------IEnumerable<T>------------");
  PhonePackage<Phone> phonePackage = new PhonePackage<Phone>();
  phonePackage.Add(new Phone("iPhone 7s"));
  phonePackage.Add(new Phone("iPhone 6s"));
  phonePackage.Add(new Phone("iPhone 5s"));
  foreach (Phone p in phonePackage)
  {
  show(p.Name);
  }
  Console.ReadKey();
 }
 static void show(string i)
 {
  Console.WriteLine(i);
 }

The results show:

#The IEnumerator iterator interface is quite verbose, and yield is just syntax sugar that simplifies traversal.

The above is the detailed content of A brief introduction to the C# IEnumerable and IEnumerator interfaces. For more information, please follow other related articles on the PHP Chinese website!