C# Language
looping

Stili ciclici

Mentre

Il tipo di loop più banale. Unico inconveniente è che non esiste alcun indizio intrinseco per sapere dove ti trovi nel ciclo.

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

Fare

Simile a while , ma la condizione viene valutata alla fine del ciclo anziché all'inizio. Ciò si traduce nell'esecuzione dei loop almeno una volta.

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

Per

Un altro stile di ciclo insignificante. Mentre il ciclo di un indice ( i ) viene aumentato e puoi usarlo. Viene solitamente utilizzato per la gestione di array.

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

Per ciascuno

Modo modernizzato per il looping di oggetti IEnumarable . Meno male che non devi pensare all'indice dell'articolo o al numero di articoli dell'elenco.

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

Metodo Foreach

Mentre gli altri stili vengono utilizzati per selezionare o aggiornare gli elementi nelle raccolte, questo stile viene solitamente utilizzato per chiamare immediatamente un metodo per tutti gli elementi di una raccolta.

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

E 'importante notare che questo metodo in disponibile solo su List<T> casi e come un metodo statico su Array - non è parte di Linq.

Linq Parallelo Foreach

Proprio come Linq Foreach, eccetto questo fa il lavoro in modo parallelo. Significa che tutti gli elementi della collezione eseguiranno l'azione data contemporaneamente, contemporaneamente.

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

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

rompere

A volte la condizione del ciclo dovrebbe essere controllata nel mezzo del ciclo. Il primo è probabilmente più elegante del secondo:

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: nei cicli nidificati e / o switch necessario utilizzare più di una semplice break .

Ciclo Foreach

foreach eseguirà iterazioni su qualsiasi oggetto di una classe che implementa IEnumerable (prendi nota che IEnumerable<T> eredita da esso). Tali oggetti includono alcuni built-in, ma non limitano a: List<T> , T[] (array di qualsiasi tipo), Dictionary<TKey, TSource> , nonché interfacce come IQueryable e ICollection , ecc.

sintassi

foreach(ItemType itemVariable in enumerableObject)
    statement;

osservazioni

1. Il tipo ItemType non ha bisogno di corrispondere al tipo preciso degli articoli, deve solo essere assegnabile dal tipo di elementi
2. Invece di ItemType , in alternativa si può usare var ItemType il tipo di item da enumerableObject esaminando l'argomento generico dell'implementazione IEnumerable
3. L'istruzione può essere un blocco, una singola istruzione o anche un'istruzione vuota ( ; )
4. Se enumerableObject non sta implementando IEnumerable , il codice non verrà compilato
5. Durante ogni iterazione, l'oggetto corrente viene castato su ItemType (anche se questo non è specificato ma inferito dal compilatore tramite var ) e se l'elemento non può essere lanciato verrà lanciata una InvalidCastException .

Considera questo esempio:

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

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

Mentre loop

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

Produzione:

0
1
2
3
4

IEnumeratori possono essere iterati con un ciclo 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);
}

Uscita di esempio:

Tokyo / Yokohama
Metropolitana di New York
San Paolo
Seul / Incheon

Per Loop

A For Loop è ottimo per fare le cose in un certo periodo di tempo. È come un ciclo While, ma l'incremento è incluso nella condizione.

A For Loop è impostato in questo modo:

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

Inizializzazione: crea una nuova variabile locale che può essere utilizzata solo nel ciclo.
Condizione: il ciclo viene eseguito solo se la condizione è vera.
Incremento - Come cambia la variabile ogni volta che viene eseguito il ciclo.

Un esempio:

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

Produzione:

0
1
2
3
4

Puoi anche lasciare spazi nel For Loop, ma devi avere tutti i punti e virgola per farlo funzionare.

int input = Console.ReadLine();    

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

Uscita per 3:

3
5
7
9
11

Do - While Loop

È simile a un ciclo while , tranne che verifica la condizione alla fine del corpo del loop. Il ciclo Do-While esegue il ciclo una volta indipendentemente dal fatto che la condizione sia vera o meno.

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

Anelli nidificati

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

Continua

Oltre alla break , c'è anche la parola chiave continue . Invece di interrompere completamente il ciclo, salterà semplicemente l'iterazione corrente. Potrebbe essere utile se non vuoi che un codice venga eseguito se è impostato un valore particolare.

Ecco un semplice esempio:

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

    Console.WriteLine(i);
}

Risulterà in:

9
10

Nota: Continue è spesso utile nei cicli while o do-while. For-loops, con condizioni di uscita ben definite, potrebbe non essere di beneficio.