Compréhension approfondie de l'utilisation du parcours foreach en C#

Le parcours d'une liste via foreach en C# est une méthode fréquemment utilisée, et elle est également pratique à utiliser. L'article suivant vous présente d'abord l'utilisation du parcours foreach en C#, puis présente certaines choses auxquelles il faut prêter attention lors de son utilisation. foreach en C# Oui, l'article le présente en détail à travers un exemple de code, qui a une certaine valeur de référence et d'apprentissage pour tous les amis qui en ont besoin peuvent y jeter un œil ci-dessous.

Préface

Cet article vous présente principalement l'utilisation du parcours foreach en C# et certaines choses que vous devez savoir sur l'utilisation de foreach en C# . Partagez-le. Pour votre référence et votre étude, il n'y a pas grand chose à dire ci-dessous, jetons un coup d'œil à l'introduction détaillée :

1.

La boucle foreach est utilisée pour énumérer tous les éléments de la collection. L'expression dans l'instruction foreach se compose de deux éléments séparés par le mot-clé in. L'élément à droite de in est le nom de la collection et l'élément à gauche de in est le nom de la variable, qui est utilisée pour stocker chaque élément de la collection.

Le processus de fonctionnement de cette boucle est le suivant : à chaque fois qu'elle boucle, une nouvelle valeur d'élément est retirée de l'ensemble. Mettez-le dans une variable en lecture seule. Si l'expression entière entre parenthèses renvoie vrai, l'instruction du bloc foreach peut être exécutée. Une fois que tous les éléments de la collection ont été accédés et que l'expression entière est évaluée à false, le contrôle passe à l'instruction d'exécution qui suit le bloc foreach.

L'instruction foreach est souvent utilisée avec des tableaux. L'exemple suivant lira la valeur du tableau via l'instruction foreach et l'affichera.

Attributs du tableau : Array.Length Capacité du tableau

En utilisant cet attribut, nous pouvons obtenir la valeur de capacité que l'objet du tableau est autorisé à stocker, et c'est aussi la longueur et le nombre d'éléments du tableau. C'est plus facile à comprendre. Les tableaux ont également d'autres attributs, tels que les dimensions du tableau. L'utilisation des attributs est relativement simple. l'un, les autres formats sont fondamentalement les mêmes. Nous ne donnerons pas d'exemples ici.

Lorsque le tableau a de nombreuses dimensions et capacités, C# fournit l'instruction foreach, qui est spécialement utilisée pour lire tous les éléments de la collection/du tableau. Nous appelons cette fonction traversée. La syntaxe s'écrit comme suit :

Parcourir le tableau : foreach (tapez objName dans collection/Array)

Cette instruction vérifiera tous les éléments du tableau un par un Valeurs de variable stockées et retirez-les une par une, où type est le type de données de l'objet du tableau que vous souhaitez lire et qui sera stocké dans la variable objName, et objName est un nom de variable de type type défini, représentant à chaque fois de la collection et Les éléments obtenus à partir du tableau (collection/Array), collection/Array est l'objet tableau auquel accéder. De cette façon, il vous suffit d'écrire un foreach pour parcourir des tableaux de toutes les dimensions, à l'exception des tableaux irréguliers.

Remarque : Le type de données de objName doit être identique ou supérieur au type de l'objet collection/Array.

Ci-dessous, nous donnons un exemple d'utilisation de foreach et for pour parcourir un tableau de règles, qui implique une méthode d'obtention des dimensions d'un tableau, et comparons les avantages de foreach pour parcourir le tableau de règles en même temps .

int[,,] a = new int[2, 2, 2] { {{ 1, 2 }, { 3,4}},{{ 5, 6 }, { 7,8}} };// 定义一个2行2列2纵深的3维数组a
for (int i = 0; i < a.GetLength (0) ;i++ ) //用Array.GetLength(n)得到数组[0,1,,,n]上的维数的元素数，0代表行，1列，n代表此数组是n+1维
{
 for (int j = 0; j < a.GetLength(1); j++)
 {
 for (int z = 0; z < a.GetLength(2);z++ )//2代表得到纵深上的元素数，如果数组有n维就得写n个for循环
 {
 Console.WriteLine(a[i,j,z]);
 }
 }
}

Utilisez une boucle foreach pour parcourir un tableau à la fois

int[,,] a = new int[2, 2, 2] { {{ 1, 2 }, { 3,4}},{{ 5, 6 }, { 7,8}} };//定义一个2行2列2纵深的3维数组a
foreach(int i in a)
{
 Console .WriteLine (i);
}

Les résultats de l'exécution de ces deux codes sont les mêmes. Il y a un élément dans chaque ligne, un total de 8 lignes. Les éléments sont 1 2 3 4 5 6 7 8

Allons. faites un autre exemple.Un exemple d'utilisation des boucles for et foreach pour accéder aux éléments du tableau. Tout d'abord, l'utilisateur est invité à entrer le nombre d'étudiants, puis le nombre d'étudiants est utilisé comme nombre d'éléments dans les noms de tableau qui stockent les étudiants. noms. Une boucle for est utilisée pour commencer à partir de 0 selon l'index i du tableau. Le bit commence à boucler et à afficher l'invite "Entrez le nom de l'étudiant" et stocke le nom de l'étudiant entré par l'utilisateur dans le tableau des noms en fonction de son nom. index dans le tableau

, et la valeur maximale du nombre de boucles for (c'est-à-dire la valeur maximale de l'index) passe par l'attribut du tableau names[i] Nous avons dit que la relation entre la capacité et l'index est. .Length. Cette question est la valeur maximale de i index=Array.Length-1

Il faut noter que : Avec foreach, vous ne pouvez récupérer que les éléments dedans. le tableau un par un, et vous ne pouvez pas utiliser cette instruction pour modifier les éléments stockés dans le tableau.

using System;
class Program
{
 static void Main()
 {
 int count;
 Console.WriteLine("输入要登记的学生数");
 count = int.Parse(Console.ReadLine());
 string[]names = new string[count];
 for (int i = 0; i < names.Length; i++)
 {
 Console.WriteLine("请输入第{0}个学生的姓名", i + 1);
 names[i] = Console.ReadLine();
 }
 Console.WriteLine("已登记的学生如下");
 foreach (string name in names)
 {
 Console.WriteLine("{0}", name);
 }
 Console.ReadKey();
 }
}

2. C#

Parcourir une liste via foreach est une méthode couramment utilisée en C#. Elle est facile à utiliser et les performances ne sont pas très différentes de celles de for ; Regardons d'abord la phrase suivante : Il existe une relation directe entre la quantité de mémoire allouée et le temps nécessaire pour terminer le test. Rien qu’à y regarder, l’allocation de mémoire n’est pas très coûteuse. Cependant, des problèmes surviennent lorsque le système de mémoire ne nettoie qu'occasionnellement la mémoire inutilisée, et la fréquence du problème est proportionnelle à la quantité de mémoire à allouer. Par conséquent, plus vous allouez de mémoire, plus la mémoire sera fréquemment récupérée et plus les performances de votre code se détérioreront.

从上面那些话可以看到内存的回收是非常损耗资源，那我们再看下一些.net内部类型的实现。

Array:

// System.Array

public IEnumerator GetEnumerator()

{

int lowerBound = this.GetLowerBound(0);

if (this.Rank == 1 && lowerBound == 0)

{

return new Array.SZArrayEnumerator(this);

}

return new Array.ArrayEnumerator(this, lowerBound, this.Length);

}

List8742468051c85b06f0a0af9e3e506b5c:

// System.Collections.Generic.List<T>

public List<T>.Enumerator GetEnumerator()

{

return new List<T>.Enumerator(this);

}

Dictionaryb6842da76bed01162354d37c4f2d3464：

// System.Collections.Generic.Dictionary<TKey, TValue>

public Dictionary<TKey, TValue>.Enumerator GetEnumerator()

{

return new Dictionary<TKey, TValue>.Enumerator(this, 2);

}

从以上代码来看，我们再进行foreach操作以上对象的时候都会构建一个Enumerator；也许有人会认为这点东西不需要计较，不过的确很多情况是不用关心;但如果通过内存分析到到的结果表明构建Enumerator的数量排在前几位，那就真的要关心一下了。很简单的一个应用假设你的应用要处理几W的并发，而每次都存在几次foreach那你就能计算出有多少对象的产生和回收?

看下一个简单的分析图，这里紧紧是存在一个List'1如果组件内部每个并发多几个foreach又会怎样？

改成for的结果又怎样呢

总结

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!