C# Language
looping

Looping-stijlen

Terwijl

Het meest triviale lustype. Enige nadeel is dat er geen intrinsieke aanwijzing is om te weten waar je bent in de lus.

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

Doen

Vergelijkbaar met while , maar de voorwaarde wordt geëvalueerd aan het einde van de lus in plaats van aan het begin. Dit resulteert in het minimaal één keer uitvoeren van de lussen.

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

Voor

Nog een triviale lusstijl. Tijdens het lussen wordt een index ( i ) verhoogd en u kunt deze gebruiken. Het wordt meestal gebruikt voor het hanteren van arrays.

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

foreach

Gemoderniseerde manier van doorlopen van IEnumarable objecten. Het is maar goed dat u niet hoeft na te denken over de index van het item of het aantal items van de lijst.

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

Foreach-methode

Terwijl de andere stijlen worden gebruikt voor het selecteren of bijwerken van de elementen in collecties, wordt deze stijl meestal gebruikt om meteen een methode aan te roepen voor alle elementen in een collectie.

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

Het is belangrijk op te merken dat deze methode alleen beschikbaar is op List<T> -instanties en als een statische methode op Array - deze maakt geen deel uit van Linq.

Linq Parallel Foreach

Net als Linq Foreach, behalve dat dit het werk op een parallelle manier doet. Dit betekent dat alle items in de verzameling dezelfde actie tegelijkertijd uitvoeren.

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

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

breken

Soms moet de lusvoorwaarde in het midden van de lus worden gecontroleerd. De eerste is aantoonbaar eleganter dan de laatste:

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

    if (should_end_loop)
        break;

    // do something
}

Alternatief:

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

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

Opmerking: in geneste lussen en / of switch moet meer dan alleen een eenvoudige break .

Foreach Loop

foreach zal elk object van een klasse dat IEnumerable implementeert, herhalen ( IEnumerable rekening mee dat IEnumerable<T> overneemt). Dergelijke objecten omvatten enkele ingebouwde objecten, maar zijn niet beperkt tot: List<T> , T[] (arrays van elk type), Dictionary<TKey, TSource> , evenals interfaces zoals IQueryable en ICollection , etc.

syntaxis

foreach(ItemType itemVariable in enumerableObject)
    statement;

opmerkingen

1. Het type ItemType hoeft niet overeen te komen met het precieze type items, het moet alleen worden toegewezen aan het type items
2. In plaats van ItemType , kan alternatief var worden gebruikt die het itemtype uit het ItemType zal afleiden door het generieke argument van de IEnumerable implementatie te inspecteren
3. De instructie kan een blok, een enkele instructie of zelfs een lege instructie zijn ( ; )
4. Als enumerableObject geen IEnumerable implementeert, wordt de code niet gecompileerd
5. Tijdens elke iteratie wordt het huidige item naar ItemType gegoten (zelfs als dit niet is opgegeven, maar compiler is afgeleid via var ) en als het item niet kan worden gegoten, wordt een InvalidCastException gegenereerd.

Beschouw dit voorbeeld:

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

is gelijk aan:

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

Herhalingslus

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

Output:

0
1
2
3
4

IEnumerators kunnen worden herhaald met een while-lus:

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

Voorbeeld output:

Tokyo / Yokohama
New York Metro
Sao Paulo
Seoul / Incheon

For loop

A For Loop is geweldig om dingen een bepaalde tijd te doen. Het is als een While-lus, maar de toename is bij de voorwaarde inbegrepen.

A For Loop is als volgt ingesteld:

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

Initialisatie - Maakt een nieuwe lokale variabele die alleen in de lus kan worden gebruikt.
Voorwaarde - De lus wordt alleen uitgevoerd als de voorwaarde waar is.
Verhogen - Hoe de variabele verandert telkens wanneer de lus wordt uitgevoerd.

Een voorbeeld:

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

Output:

0
1
2
3
4

Je kunt ook spaties weglaten in de For Loop, maar je moet alle puntkomma's hebben om te kunnen functioneren.

int input = Console.ReadLine();    

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

Uitgang voor 3:

3
5
7
9
11

Do - While Loop

Het is vergelijkbaar met een while lus, behalve dat het de toestand aan het einde van het luslichaam test. De lus Do - While voert de lus eenmaal uit, ongeacht of de voorwaarde waar is of niet.

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

Geneste lussen

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

doorgaan met

Naast break is er ook het sleutelwoord continue . In plaats van de lus volledig te doorbreken, slaat deze gewoon de huidige iteratie over. Het kan handig zijn als u niet wilt dat bepaalde code wordt uitgevoerd als een bepaalde waarde is ingesteld.

Hier is een eenvoudig voorbeeld:

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

    Console.WriteLine(i);
}

Zal resulteren in:

9
10

Opmerking: Continue is vaak het handigst in de while- of do-while-loops. For-lussen, met goed gedefinieerde exit-omstandigheden, kunnen minder profiteren.