C# Language
looping

Looping stilar

Medan

Den mest triviala slingtypen. Enda nackdelen är att det inte finns någon grundläggande ledtråd att veta var du är i slingan.

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

Do

Liknar while men villkoret utvärderas i slutet av slingan istället för början. Detta resulterar i körning av slingorna minst en gång.

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

För

En annan trivial slingerstil. Medan looping av ett index ( i ) blir ökat och du kan använda det. Det används vanligtvis för hantering av matriser.

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

För varje

Moderniserat sätt att IEnumarable genom IEnumarable objekt. Bra att du inte behöver tänka på objektets index eller listans artikelantal.

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

Foreach-metod

Medan de andra stilarna används för att välja eller uppdatera elementen i samlingar, används den här stilen vanligtvis för att kalla en metod direkt för alla element i en samling.

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

Det är viktigt att notera att den här metoden endast finns i List<T> instanser och som en statisk metod på Array - den är inte en del av Linq.

Linq Parallel Foreach

Precis som Linq Foreach, förutom att denna gör jobbet på ett parallellt sätt. Vilket innebär att alla objekt i samlingen kör den angivna åtgärden samtidigt.

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

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

ha sönder

Ibland bör slingkondition kontrolleras i mitten av slingan. Den förstnämnda är utan tvekan mer elegant än den senare:

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

    if (should_end_loop)
        break;

    // do something
}

Alternativ:

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

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

Obs: I kapslade slingor och / eller switch måste använda mer än bara en enkel break .

Foreach Loop

foreach kommer att iterera över alla objekt i en klass som implementerar IEnumerable (notera att IEnumerable<T> ärver från den). Sådana objekt inkluderar vissa inbyggda sådana, men begränsar inte till: List<T> , T[] (matriser av vilken typ som helst), Dictionary<TKey, TSource> , samt gränssnitt som IQueryable och ICollection , etc.

syntax

foreach(ItemType itemVariable in enumerableObject)
    statement;

anmärkningar

1. Typen ItemType behöver inte matcha den exakta typen av objekt, den behöver bara tilldelas utifrån typen av objekt
2. Istället för ItemType alternativt var kan användas som sluta sig till poster typ från enumerableObject genom att inspektera den generiska argument för IEnumerable genomförandet
3. Uttalandet kan vara ett block, ett enda uttalande eller till och med ett tomt uttalande ( ; )
4. Om enumerableObject inte implementerar IEnumerable kommer koden inte att sammanställas
5. Under varje iteration kastas det aktuella objektet till ItemType (även om detta inte specificeras men kompilator-inferred via var ) och om objektet inte kan kastas kommer en InvalidCastException att kastas.

Tänk på detta exempel:

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

är ekvivalent med:

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

Medan slinga

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

Produktion:

0
1
2
3
4

IEnumeratorer kan itereras med en stundslinga:

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

Provutgång:

Tokyo / Yokohama
New York Metro
Sao Paulo
Seoul / Incheon

För slinga

A For Loop är bra för att göra saker en viss tid. Det är som en While Loop men steget ingår i villkoret.

A For Loop är konfigurerad så här:

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

Initialisering - Skapar en ny lokal variabel som endast kan användas i slingan.
Villkor - loopen körs bara om villkoret är sant.
Ökning - Hur variabeln ändras varje gång slingan körs.

Ett exempel:

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

Produktion:

0
1
2
3
4

Du kan också lämna utrymmen i For Loop, men du måste ha alla semikolon för att den ska fungera.

int input = Console.ReadLine();    

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

Utgång för 3:

3
5
7
9
11

Gör - medan slingan

Det liknar en while slinga, med undantag av att den testar tillståndet vid slutet av slingan. Do-While-loopen kör slingan en gång oavsett om villkoret är sant eller inte.

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

Kapslade öglor

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

Fortsätta

Förutom att break , finns det också nyckelordet continue . Istället för att helt bryta slingan kommer det helt enkelt att hoppa över den aktuella iterationen. Det kan vara användbart om du inte vill att någon kod ska köras om ett visst värde är inställt.

Här är ett enkelt exempel:

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

    Console.WriteLine(i);
}

Kommer att resultera i:

9
10

Obs: Continue är ofta mest användbart i loppar medan-eller-gör-medan. For-slingor, med väl definierade utgångsförhållanden, kanske inte gynnar lika mycket.