C# Language
Bucle

Estilos de bucle

Mientras

El tipo de bucle más trivial. El único inconveniente es que no hay una pista intrínseca para saber dónde se encuentra en el bucle.

/// loop while the condition satisfies
while(condition)
{
    /// do something
}

Hacer

Similar a while , pero la condición se evalúa al final del bucle en lugar del principio. Esto resulta en la ejecución de los bucles al menos una vez.

do
{
    /// do something
} while(condition) /// loop while the condition satisfies

por

Otro estilo de bucle trivial. Mientras se hace un bucle en un índice ( i ) aumenta y puede usarlo. Se suele utilizar para la manipulación de matrices.

for ( int i = 0; i < array.Count; i++ )
{
    var currentItem = array[i];
    /// do something with "currentItem"
}

Para cada

Manera modernizada de bucle a través de objetos IEnumarable . Menos mal que no tienes que pensar en el índice del artículo o en el recuento de elementos de la lista.

foreach ( var item in someList )
{
    /// do something with "item"
}

Método Foreach

Mientras que los otros estilos se usan para seleccionar o actualizar los elementos de las colecciones, este estilo se usa generalmente para llamar a un método de inmediato para todos los elementos de una colección.

list.ForEach(item => item.DoSomething());

// or
list.ForEach(item => DoSomething(item));

// or using a method group
list.ForEach(Console.WriteLine);

// using an array
Array.ForEach(myArray, Console.WriteLine);

Es importante señalar que este método sólo está disponible en List<T> casos y también como un método estático en la Array - no es parte de LINQ.

Linq paralelo foreach

Al igual que Linq Foreach, excepto que este hace el trabajo de manera paralela. Lo que significa que todos los elementos de la colección ejecutarán la acción dada al mismo tiempo, simultáneamente.

collection.AsParallel().ForAll(item => item.DoSomething());

/// or
collection.AsParallel().ForAll(item => DoSomething(item));

descanso

A veces, la condición del bucle se debe verificar en el medio del bucle. El primero es posiblemente más elegante que el segundo:

for (;;)
{
    // precondition code that can change the value of should_end_loop expression

    if (should_end_loop)
        break;

    // do something
}

Alternativa:

bool endLoop = false;
for (; !endLoop;)
{
    // precondition code that can set endLoop flag

    if (!endLoop)
    {
        // do something
    }
}

Nota: en los bucles anidados y / o el switch debe usar más que un simple break .

Foreach Loop

foreach iterará sobre cualquier objeto de una clase que implemente IEnumerable (tenga en cuenta que IEnumerable<T> hereda de él). Dichos objetos incluyen algunos incorporados, pero no se limitan a: List<T> , T[] (arreglos de cualquier tipo), Dictionary<TKey, TSource> , así como interfaces como IQueryable e ICollection , etc.

sintaxis

foreach(ItemType itemVariable in enumerableObject)
    statement;

observaciones

1. El tipo ItemType no necesita coincidir con el tipo exacto de los elementos, solo necesita ser asignable del tipo de los elementos.
2. En lugar de ItemType , alternativamente se puede usar var ItemType el tipo de elementos del objeto enumerable al inspeccionar el argumento genérico de la implementación IEnumerable
3. La declaración puede ser un bloque, una sola instrucción o incluso una declaración vacía ( ; )
4. Si enumerableObject no implementa IEnumerable , el código no se compilará
5. Durante cada iteración, el elemento actual se ItemType en ItemType (incluso si no se especifica, pero el compilador se deduce a través de var ) y si el elemento no se puede convertir, se lanzará una InvalidCastException .

Considera este ejemplo:

var list = new List<string>();
list.Add("Ion");
list.Add("Andrei");
foreach(var name in list)
{
    Console.WriteLine("Hello " + name);
}

es equivalente a:

var list = new List<string>();
list.Add("Ion");
list.Add("Andrei");
IEnumerator enumerator;
try
{
    enumerator = list.GetEnumerator();
    while(enumerator.MoveNext())
    {
        string name = (string)enumerator.Current;
        Console.WriteLine("Hello " + name);
    }
}
finally
{
    if (enumerator != null)
        enumerator.Dispose();
}

Mientras bucle

int n = 0;
while (n < 5) 
{
    Console.WriteLine(n);
    n++;
}

Salida:

0
1
2
3
4

IEnumerators se puede iterar con un bucle while:

// Call a custom method that takes a count, and returns an IEnumerator for a list
// of strings with the names of theh largest city metro areas.
IEnumerator<string> largestMetroAreas = GetLargestMetroAreas(4);

while (largestMetroAreas.MoveNext())
{
    Console.WriteLine(largestMetroAreas.Current);
}

Salida de muestra:

Tokio / Yokohama
Metro de nueva york
Sao Paulo
Seúl / Incheon

En bucle

A For Loop es ideal para hacer cosas durante un cierto tiempo. Es como un bucle While, pero el incremento se incluye con la condición.

A For Loop se configura así:

for (Initialization; Condition; Increment)
{
    // Code
}

Inicialización: crea una nueva variable local que solo se puede utilizar en el bucle.
Condición: el bucle solo se ejecuta cuando la condición es verdadera.
Incremento: cómo cambia la variable cada vez que se ejecuta el bucle.

Un ejemplo:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

Salida:

0
1
2
3
4

También puede dejar espacios en For Loop, pero debe tener todos los puntos y coma para que funcione.

int input = Console.ReadLine();    

for ( ; input < 10; input + 2)
{
    Console.WriteLine(input);
}

Salida para 3:

3
5
7
9
11

Do - While Loop

Es similar a un while bucle, excepto que prueba la condición en el extremo del cuerpo del bucle. El bucle Do - While ejecuta el bucle una vez, independientemente de si la condición es verdadera o no.

int[] numbers = new int[] { 6, 7, 8, 10 };
    
// Sum values from the array until we get a total that's greater than 10,
// or until we run out of values.
int sum = 0;
int i = 0;
do
{
    sum += numbers[i];
    i++;
} while (sum <= 10 && i < numbers.Length);
    
System.Console.WriteLine(sum); // 13

Bucles anidados

// Print the multiplication table up to 5s
for (int i = 1; i <= 5; i++)
{
    for (int j = 1; j <= 5; j++)
    {
        int product = i * j;
        Console.WriteLine("{0} times {1} is {2}", i, j, product);
    }
}

continuar

Además de break , también está la palabra clave continue . En lugar de romper por completo el bucle, simplemente saltará la iteración actual. Podría ser útil si no desea que se ejecute algún código si se establece un valor particular.

Aquí hay un ejemplo simple:

for (int i = 1; i <= 10; i++)
{
    if (i < 9)
        continue;

    Console.WriteLine(i);
}

Resultará en:

9
10

Nota: Continue es a menudo más útil en los bucles while o do-while. Los bucles for, con condiciones de salida bien definidas, pueden no beneficiarse tanto.