Itérateurs en C#

Les itérateurs sont la méthode utilisée pour récupérer les éléments et effectue des itérations un par un dans des tableaux, des listes, etc. L'instruction return return est utilisée avec la méthode iterator pour renvoyer l'élément de la collection et le break de rendement est utilisé pour arrêter l'itération. Il stocke toujours l'emplacement actuel et renvoie l'élément suivant lors de la prochaine itération. Les valeurs des objets IEnumerable et IEnumerator sont le type de retour de rendement. Dans cette rubrique, nous allons découvrir les itérateurs en C#.

Méthodes des itérateurs C#

Vous trouverez ci-dessous les exemples illustrant l'itération avec diverses méthodes telles que la boucle, la boucle foreach et les énumérateurs.

1. Pour la boucle

Exemple :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Iterators
{
class Iterator
{
static void Main(string[] args)
{
for (int i = 1; i <= 7; i++)
{
Console.WriteLine( i);
}
Console.WriteLine("Press Enter Key to Exit..");
Console.ReadLine();
}
}
}

Une boucle for se compose de trois instructions. Dans un premier temps, l'initialisation est exécutée, puis la condition qui est une expression booléenne. Après cet itérateur est exécuté pour modifier la valeur de la variable initialisée. Ce processus de boucle for continue jusqu'à ce que la condition soit fausse et lorsqu'elle est fausse, la boucle for se termine.

Sortie :

2. Boucle ForEach

Exemple :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Iterators
{
class Iterator
{
static void Main(string[]args)
{
string[] values = new string[3] { "John", "Bob", "Eva" };
foreach (string name in values)
{
Console.WriteLine(name);
}
Console.WriteLine("Press Enter Key to Exit..");
Console.ReadLine();
}
}
}

Une boucle foreach dans le mot-clé est utilisée pour itérer les éléments. Le mot-clé est utilisé pour sélectionner l'élément à chaque itération. Le premier élément est itéré et stocké dans l'élément après ce deuxième élément et ainsi de suite. Le nombre d'itérations de foreach dépend du nombre d'éléments dans la collection. Dans cet exemple, la collection se compose de trois valeurs donc le nombre de foreach aura lieu trois fois et affichera les valeurs.

Sortie :

3. Recenseurs

Exemple n°1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Iterators
{
class Iterator
{
public static IEnumerable<string> GetArray()
{
int[] array = new int[] { 12, 45, 56, 21, 4 };   // initializing array elements
foreach (var element in array)   // iterating array element
{
yield return element.ToString();   // returning elements
}
}
public static void Main(string[]args)         // main method
{
IEnumerable<string> elements = GetArray();  // storing array element
foreach(var element in elements)
{
Console.WriteLine(element);
Console.ReadKey();
}
}
}
}

Dans cet exemple, il existe un tableau de l'élément qui contient cinq éléments et foreach est utilisé pour l'itération de chaque élément. L'instruction rendement est utilisée pour renvoyer un élément après chaque itération. L'interface IEnumerable stocke chaque élément tandis que foreach est utilisé pour afficher les éléments renvoyés par l'itération. Cet itérateur est utilisé dans une méthode.

Sortie :

Exemple n°2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Iterators
{
class Iterator
{
public static IEnumerable<string> GetList()
{
List<string> list = new List<string>();
list.Add("Sunday");     // adding elements to list
list.Add("Monday");
list.Add("Tuesday");
list.Add("Wednesday");
list.Add("Thursday");
list.Add("Friday");
list.Add("Saturday");
foreach(var element in list)        //iteration of list elements
{
yield return element;               //returning elements after iteration
}
}
public static void Main(string[]args)    // main method
{
IEnumerable<string> elements = GetList();          // storing elements
foreach(var element in elements)
{
Console.WriteLine(element);
Console.ReadKey();
}
}
}
}

Dans cet exemple, la collection de listes est utilisée et la méthode list.add est utilisée pour ajouter des éléments dans la liste. Ici, la liste se compose de sept éléments. Un foreach est utilisé pour l'itération de chaque élément. L'instruction rendement est utilisée pour renvoyer un élément après chaque itération. L'interface IEnumerable stocke chaque élément tandis que foreach est utilisé pour afficher les éléments renvoyés par l'itération.

Sortie :

Exemple n°3

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Iterators
{
class Iterator
{
public static void Main(string[] args)
{
foreach(var item in fib(6))  // iteration of elements
{
Console.WriteLine(item);
}
}
public static IEnumerable<int> fib(int number)
{
int x = 0, y = 1;
// yield return x;
//yield return y;
for (int i=0; i<=number; i++)
{
int temp = x;
x = y;
y = temp + y;
yield return y;        // returning the element
Console.ReadKey();
}
}
}
}

Dans cet exemple, la série de Fibonacci est générée et l'itérateur est utilisé dans un opérateur. L'implémentation de ceci est la même que celle que nous avons utilisée pour les itérateurs dans une méthode, sauf que dans cette méthode, les opérateurs sont utilisés pour renvoyer des choses.

Sortie :

Exemple n°4

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Iterators
{
class Iterator
{
static void Main()
{
List<int> list = new List<int>();
list.Add(10);          // adding elements to list
list.Add(20);
list.Add(30);
list.Add(40);
list.Add(50);
list.Add(60);
list.Add(70);
List<int>.Enumerator a = list.GetEnumerator();
Write(a);
}
static void Write(IEnumerator<int> a)
{
while (a.MoveNext())
{
int value = a.Current;
Console.WriteLine(value);
Console.ReadKey();
}
}
}
}

Dans l'exemple ci-dessus, la collection de listes est utilisée. La méthode List.add est utilisée pour ajouter des éléments dans la liste. Ici, la liste contient sept éléments. MoveNext et Current sont utilisés. MoveNext suit essentiellement si l'élément suivant est présent ou non et renvoie un booléen qui peut être vrai si l'élément est disponible et faux s'il n'y a pas d'élément tandis que le courant est utilisé pour récupérer l'élément actuel.

Sortie :

Avantages et inconvénients de l'itérateur

Les avantages et inconvénients sont expliqués ci-dessous

Avantages

1. Les itérateurs peuvent être utilisés comme méthode et obtenir un accesseur.
2. Il peut être utilisé comme opérateur ou comme propriété.
3. Les itérateurs sont faciles à lire et à mettre en œuvre.
4. Les itérateurs sont utilisés avec les collections génériques et non génériques.

Inconvénients

1. Les itérateurs ne sont pas utiles pour revenir en arrière sur une liste.
2. En tant qu'itérateur stocke la position, vous ne pouvez donc pas mettre à jour la structure itérée.
3. Les itérateurs ne sont pas utilisés dans le constructeur statique, le finaliseur statique et le constructeur d'instance.

Conclusion

Ainsi, pour parcourir la séquence de valeurs, des itérateurs peuvent être utilisés avec l'instruction foreach. Yield peut être utilisé plusieurs fois avec l'itérateur pour renvoyer les éléments. C'est facile à mettre en œuvre et assez pratique.

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!