Introduction aux itérateurs en C #
Les itérateurs sont la méthode utilisée pour récupérer les éléments et effectuent l'itération un par un dans les tableaux, la liste, etc. L'instruction yield return est utilisée avec la méthode iterator pour renvoyer l'élément de la collection et yield break 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 d'objet IEnumerable et IEnumerator sont le type de retour de rendement. Dans cette rubrique, nous allons en savoir plus sur les itérateurs en C #.
Méthodes d'itérateurs C #
Voici des exemples pour montrer l'itération avec diverses méthodes comme la boucle, la boucle foreach et les énumérateurs.
1. Pour boucle
Exemple 1
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 condition qui est une expression booléenne. Après cela, l'itérateur est exécuté pour modifier la valeur de la variable initialisée. Ce processus de boucle continue jusqu'à ce que la condition soit fausse et lorsqu'elle est fausse, la boucle se termine.
La sortie du code ci-dessus est
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 de sorte que le nombre de foreach aura lieu trois fois et affichera les valeurs.
La sortie du code ci-dessus est
3. Énumérateurs
Exemple 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Iterators
(
class Iterator
(
public static IEnumerable 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 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 yield est utilisée pour renvoyer l'é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.
La sortie du code ci-dessus est
Exemple # 2
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Iterators
(
class Iterator
(
public static IEnumerable GetList()
(
List list = new List();
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 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 yield est utilisée pour renvoyer l'é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.
La sortie du code ci-dessus est
Exemple # 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 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 Fibonacci est générée et l'itérateur est utilisé dans un opérateur. L'implémentation de ce même que nous avons utilisé des itérateurs dans une méthode, sauf que dans ce opérateurs est utilisé pour retourner des choses.
La sortie du code ci-dessus est
Exemple # 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 list = new List();
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.Enumerator a = list.GetEnumerator();
Write(a);
)
static void Write(IEnumerator 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. Cette 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 alors que le courant est utilisé pour récupérer l'élément actuel.
La sortie du code ci-dessus est
Avantages et inconvénients d'itérateur
Certains des avantages sont mentionnés ci-dessous:
- Les itérateurs peuvent être utilisés comme méthode et obtenir un accesseur.
- Il peut être utilisé comme opérateur ou comme propriété.
- Les itérateurs sont faciles à lire et à mettre en œuvre.
- Les itérateurs sont utilisés avec les collections génériques et non génériques.
Certains des inconvénients sont mentionnés ci-dessous:
- Les itérateurs ne sont pas utiles dans le retour en arrière d'une liste.
- Comme l'itérateur stocke la position, vous ne pouvez pas mettre à jour la structure itérée.
- Les itérateurs ne sont pas utilisés dans le constructeur statique, le finaliseur statique et le constructeur d'instance.
Conclusion - Itérateurs en C #
Ainsi, pour parcourir la séquence de valeurs, les itérateurs peuvent être utilisés avec l'instruction foreach. Le rendement peut être utilisé plusieurs fois avec l'itérateur pour renvoyer les éléments. Il est facile à mettre en œuvre et assez pratique.
Articles recommandés
Ceci est un guide des itérateurs en C #. Ici, nous discutons des exemples pour montrer l'itération avec diverses méthodes comme la boucle, la boucle foreach et les énumérateurs. Vous pouvez également consulter l'article suivant pour en savoir plus-
- Destructeur en C #
- Série Fibonacci en C #
- Remplacement de méthode en C #
- C # pour boucle
- Surcharge en Java
- Méthodes de travail et Top 3 Enum en C #