C# Language
Pętla

Zapętlanie stylów

Podczas

Najbardziej trywialny typ pętli. Jedyną wadą jest to, że nie ma wewnętrznej wskazówki, aby wiedzieć, gdzie jesteś w pętli.

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

Robić

Podobne do while , ale warunek jest oceniany na końcu pętli zamiast na początku. Powoduje to wykonanie pętli co najmniej raz.

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

Dla

Kolejny trywialny styl pętli. Podczas zapętlania zwiększa się indeks ( i ) i można go używać. Jest zwykle używany do obsługi tablic.

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

Dla każdego

Zmodernizowany sposób zapętlania obiektów IEnumarable . Dobrze, że nie musisz myśleć o indeksie elementu ani liczbie elementów na liście.

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

Metoda Foreach

Podczas gdy inne style są używane do wybierania lub aktualizowania elementów w kolekcjach, ten styl jest zwykle używany do natychmiastowego wywołania metody dla wszystkich elementów w kolekcji.

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

Ważne jest, aby pamiętać, że ta metoda dostępna tylko w List<T> przypadkach i jako metody statycznej na Array - nie jest częścią Linq.

Linq Parallel Foreach

Podobnie jak Linq Foreach, tyle że ten wykonuje tę pracę równolegle. Oznacza to, że wszystkie elementy w kolekcji będą jednocześnie uruchamiać daną akcję.

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

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

przerwa

Czasami stan pętli należy sprawdzić w środku pętli. Ten pierwszy jest prawdopodobnie bardziej elegancki niż drugi:

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

    if (should_end_loop)
        break;

    // do something
}

Alternatywny:

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

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

Uwaga: W zagnieżdżonych pętlach i / lub switch należy użyć czegoś więcej niż zwykłego break .

Foreach Loop

foreach będzie iterować po dowolnym obiekcie klasy, który implementuje IEnumerable (zwróć uwagę, że IEnumerable<T> dziedziczy po nim). Takie obiekty obejmują niektóre wbudowane, ale nie ograniczają się do: List<T> , T[] (tablice dowolnego typu), Dictionary<TKey, TSource> , a także interfejsów takich jak IQueryable i ICollection itp.

składnia

foreach(ItemType itemVariable in enumerableObject)
    statement;

uwagi

1. Typ ItemType nie musi odpowiadać dokładnemu typowi przedmiotów, wystarczy przypisać go na podstawie rodzaju przedmiotów
2. Zamiast ItemType można alternatywnie zastosować zmienną var która będzie wywnioskować typ elementu z enumerableObject poprzez sprawdzenie ogólnego argumentu implementacji IEnumerable
3. Instrukcja może być blokiem, pojedynczą instrukcją lub nawet pustą instrukcją ( ; )
4. Jeśli enumerableObject nie implementuje IEnumerable , kod nie zostanie skompilowany
5. Podczas każdej iteracji aktualna pozycja jest odlewana do ItemType (nawet jeśli nie jest określony, ale kompilator wywnioskować poprzez var ) i jeżeli rzecz nie można rzutować InvalidCastException zostanie wyrzucony.

Rozważ ten przykład:

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

jest równa:

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

Podczas pętli

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

Wynik:

0
1
2)
3)
4

IEnumerators można iterować za pomocą pętli 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);
}

Przykładowe dane wyjściowe:

Tokio / Jokohama
Metro w Nowym Jorku
San Paulo
Seul / Incheon

Dla pętli

Pętla For świetnie nadaje się do robienia rzeczy przez określony czas. To jest jak pętla While, ale przyrost jest wliczony w warunek.

A For Loop jest skonfigurowany w następujący sposób:

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

Inicjalizacja - tworzy nową zmienną lokalną, której można używać tylko w pętli.
Warunek - pętla działa tylko wtedy, gdy warunek jest spełniony.
Przyrost - jak zmienna zmienia się przy każdym uruchomieniu pętli.

Przykład:

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

Wynik:

0
1
2)
3)
4

Możesz również pominąć spacje w pętli For, ale musisz mieć wszystkie średniki, aby mogła ona działać.

int input = Console.ReadLine();    

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

Wyjście dla 3:

3)
5
7
9
11

Do - While Loop

Jest ona podobna do while pętli, oprócz tego, że testuje to stan na koniec ciała pętli. Pętla Do - While wykonuje pętlę jeden raz, niezależnie od tego, czy warunek jest spełniony, czy nie.

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

Pętle zagnieżdżone

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

kontyntynuj

Oprócz break istnieje również słowo kluczowe continue . Zamiast całkowicie zerwać pętlę, po prostu pominie bieżącą iterację. Może to być przydatne, jeśli nie chcesz, aby jakiś kod był wykonywany, jeśli ustawiono określoną wartość.

Oto prosty przykład:

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

    Console.WriteLine(i);
}

Spowoduje to:

9
10

Uwaga: Continue jest często najbardziej przydatna w pętlach while i do-while. Pętle For, z dobrze określonymi warunkami wyjścia, mogą nie odnieść tak dużych korzyści.