Une brève introduction aux interfaces C# IEnumerable et IEnumerable

Cet article présente principalement les connaissances pertinentes des interfaces IEnumerable et IEnumerable en C#, qui ont une très bonne valeur de référence. Jetons-y un coup d'œil avec l'éditeur

Review. le passé et apprendre le nouveau. Vous pouvez être enseignant. Il est nécessaire de revoir fréquemment les connaissances de base lorsque vous avez le temps, et cela peut approfondir votre compréhension et votre mémoire.

Foreach est souvent utilisé pour parcourir des collections et parcourir des conteneurs qui implémentent l'interface IEnumerable. Je suis parfois un peu confus au sujet des interfaces IEnumerable et IEnumerable. Selon l'explication officielle, IEnumerable est une interface énumérateur et IEnumerable. est un itérateur. Les interfaces ne sont pas très différentes du sens littéral. Analysons-les une par une.

Interface IEnumerable

public interface IEnumerable
{ 
 IEnumerator GetEnumerator();
}

Les classes qui héritent de l'interface IEnumerable doivent implémenter la méthode GetEnumerator() exposée et renvoyer un objet d'interface IEnumerator , il semble que la vraie chose soit IEnumerator F12 pour voir ce que c'est que dans IEnumerator.

Interface IEnumerator

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

L'interface IEnumerator a trois choses, un attributCurrent, renvoie les éléments de la collection actuelle, la méthode MoveNext ( ) pour passer au suivant. Le parcours traversal n'est-il pas en arrière ? Reset() signifie littéralement réinitialisation. C'est facile à comprendre. Faites une hypothèse : Étant donné que l'interface IEnumerable renvoie un itérateur d'interface IEnumerator, un conteneur personnalisé peut-il être implémenté en héritant uniquement de l'interface de l'itérateur IEnumerator ?

Définir une Classe Phone

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

Définir un itérateur nommé MyEnumerator et implémenter son 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);
 }
 }

Le résultat montre :

Comme prévu, ce qui fait vraiment le travail, c'est l'interface IEnumerator, qui peut parcourir le conteneur A personnalisé, mais l'intention initiale est d'utiliser Foreach pour l'accès aux boucles et le parcours. Eh bien, nous ne pouvons alors afficher que l'interface IEnumerable pour le faire. Modifiez légèrement la classe Phone :

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

Le résultat montre :

C'est fait, puis développez-le dans un conteneur universelPhonePackage, héritez simplement de l'interface générique IEnumerable

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

Le résultat montre :

L'interface de l'itérateur IEnumerator est assez verbeuse, et le rendement n'est qu'un sucre de syntaxe qui simplifie le parcours.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!