A brief introduction to the C# IEnumerable and IEnumerator interfaces-C#.Net Tutorial-php.cn

A brief introduction to the C# IEnumerable and IEnumerator interfaces

黄舟

Release： 2017-03-21 11:22:48

Original

5369 people have browsed it

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

Copy after login

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

Copy after login

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

Copy after login

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

Copy after login

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

Copy after login

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

Copy after login

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

Copy after login

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

Copy after login

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

Copy after login

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!