Lädt...

Iterating

Behalte eine List<int> namens bag. Füge 3 hinzu, dann 8. Schreibe eine foreach-Schleife, die jeden Wert in bag ausgibt. Behalte die Arbeit in Pine mit Main. Unter using System; behalte using System.Collections.Generic;. Starte mit dotnet run. Der Bildschirm soll zwei Zeilen zeigen: 3 dann 8. foreach läuft die Sammlung Wert für Wert ab. Die Schleifenvariable hält den aktuellen Wert. Schreibe für diesen Lauf nicht von Hand bag[0] und bag[1]. Behalte den öffentlichen Startklassennamen Pine.

Jeden Wert der Reihe nach

Auf der hashset-Seite hast du eindeutige Tags ergänzt und Count gelesen. Diese Seite läuft Werte einzeln durch. Eine foreach-Schleife besucht jedes Element einer Sammlung. Bei List<int> namens bag liefert jeder Schritt das nächste int. Bei HashSet<string> namens tags liefert jeder Schritt die nächste Zeichenkette. Die Reihenfolge beim Set-Lauf ist hier nicht der Lehrfokus — jeder ausgegebene Wert reicht.
Öffne die Pine-Datei. Der Startklassenname bleibt Pine. Diese Seite benennt den Starter nicht um. Lösche Überbleibsel, die nur tags.Count nach drei Add ohne foreach ausgeben. Lösche Dictionary-Indexer-Überbleibsel. Lösche jede ReadLine-Zeile. Die Datei, die du behältst, wartet nicht auf Eingabe. Ein sauberes Main macht den zweizeiligen foreach-Bildschirm verlässlich.
Oben behalte using System;. Behalte using System.Collections.Generic;. In Main schreibe List<int> bag = new List<int>();, dann bag.Add(3);. Für den ersten Check schreibe:
foreach (int n in bag)
{
Console.WriteLine(n);
}
Speichere und starte diese kurze Form, erweitere dann auf zwei Add in der behaltenen Demo. Der Ein-Add-Lauf ist nur eine Kontrollstelle; die behaltene Antwort der Seite bleibt 3 dann 8.
Das Wort nach foreach in Klammern ist Typ und Name der Schleifenvariable, dann in, dann die Sammlung. Erfinde hier nicht for (int i = 0; ...) als Pflicht — bleib bei foreach für den Lauf.

foreach one Add

csharp
using System;
using System.Collections.Generic;

public class Pine
{
    public static void Main()
    {
        List<int> bag = new List<int>();
        bag.Add(3);
        foreach (int n in bag)
        {
            Console.WriteLine(n);
        }
    }
}

Pine läuft zwei Listenwerte durch

In Main, nach der leeren Liste, schreibe bag.Add(3); dann bag.Add(8);. Behalte denselben Block foreach (int n in bag), der n ausgibt. Auf dieser Seite gibst du nicht nur tags.Count aus. Die behaltene Demo läuft die Liste durch und zeigt jede Zahl.

foreach two Adds

csharp
using System;
using System.Collections.Generic;

public class Pine
{
    public static void Main()
    {
        List<int> bag = new List<int>();
        bag.Add(3);
        bag.Add(8);
        foreach (int n in bag)
        {
            Console.WriteLine(n);
        }
    }
}

Lies die behaltene Datei von oben. using System; bereitet Konsolennamen vor. using System.Collections.Generic; bereitet List vor. public class Pine ist der Starter. public static void Main() startet die Laufzeit. new List<int>() baut eine leere Liste. Die zwei Add-Aufrufe speichern 3 dann 8. foreach besucht zuerst 3, dann 8. Jeder Besuch schreibt eine Zeile. Der Bildschirm zeigt 3 dann 8.
Starte mit dotnet run. Das Programm schreibt zwei Zeilen und stoppt. Es wartet nicht auf Tippen. Wenn dotnet run wartet, ist noch ReadLine in der Datei. Lösche die Zeile und behalte die foreach-Arbeit. Der Bildschirm zeigt 3 dann 8. Bei nur 2 läuft vielleicht noch eine Count-only-hashset-Demo. Findet der Build List nicht, setze using System.Collections.Generic; zurück.
Schreibst du nur Console.WriteLine(bag[0]); ohne foreach, verpasst du absichtlich den zweiten Wert in dieser Lektion — behalte die Schleife. Ist die Liste leer, schreibt foreach nichts. Füge in der behaltenen Demo die Werte vor der Schleife hinzu.

foreach auch auf einem HashSet

Dieselbe Schleifenform funktioniert auf einem Set. Erstelle HashSet<string> tags, füge "oak" und "pine" hinzu, dann foreach (string t in tags) und gib t aus. Jedes Tag steht in eigener Zeile. Die Reihenfolge kann von einer Liste abweichen; die Seite verlangt nur beide Wörter. Nutze das als zweite Kontrollstelle, kehre dann zur Listen-foreach-Datei zurück, wenn du 3 dann 8 für das Quiz brauchst.

foreach HashSet tags

csharp
using System;
using System.Collections.Generic;

public class Pine
{
    public static void Main()
    {
        HashSet<string> tags = new HashSet<string>();
        tags.Add("oak");
        tags.Add("pine");
        foreach (string t in tags)
        {
            Console.WriteLine(t);
        }
    }
}

Starte die HashSet-foreach-Datei mit dotnet run. Du solltest oak und pine je eine Zeile sehen (Reihenfolge kann variieren). Bei nur 2 hast du noch Count-only-Überbleibsel — wechsle zum foreach-Rumpf. foreach ersetzt nicht jeden Count-Check. Count sagt weiterhin wie viele. foreach antwortet, indem es jeden Wert besucht.
foreach (int n in bag) bei bag als HashSet<string> schlägt beim Build fehl — der Schleifentyp muss zum Werttyp der Sammlung passen. Behalte int mit List<int> und string mit HashSet<string> auf dieser Seite.

Im Vergleich zu nur Count und Index-Gewohnheit

tags.Count nach Add zeigt die Länge. Der Lauf mit foreach zeigt die Werte selbst. Eine Count-only-hashset-Demo ist eine andere Kontrollstelle. Auf dieser Seite behalte foreach, das jeden Wert schreibt.
Du hast schon Index-Lesungen wie bag[0] auf der Listen-Seite genutzt. foreach braucht keine handgebauten Indizes für einen vollen Lauf. Diese Seite verbietet Indizes nicht; sie zeigt die Schleife, die jeden gespeicherten Wert der Reihe nach besucht. Bleib bei kleinen Sammlungen, damit der Bildschirm lesbar bleibt.

Was für nullable übrig bleibt

Diese Seite läuft Liste und Set mit foreach durch. Die nächste Seite — nullable — behandelt Werttypen, die keinen Wert halten können, mit ? und null-Checks. Bleib hier beim Iterieren von Sammlungen. Erfinde auf dieser Seite keine nullable-Syntax; das Lernziel ist der Lauf selbst. Wenn dotnet run aus der Listen-foreach-Datei 3 dann 8 ausgibt, hast du die Kontrollstelle dieser Seite.
Verschachtele kein zweites Main. Lass Count-only-Demos nicht als einzigen Lehrpfad stehen. Zeigt der Bildschirm nur eine Zahl, prüfe, dass WriteLine im foreach-Rumpf steht. Behalte using System.Collections.Generic; für List und HashSet.

Du kannst List<int> bag = new List<int>(); schreiben, bag.Add(3); und bag.Add(8); aufrufen, dann foreach (int n in bag) { Console.WriteLine(n); }. Starte mit dotnet run. Der Bildschirm zeigt 3 dann 8. Die Schleife hat jeden Wert besucht. Dasselbe funktioniert bei HashSet<string> mit foreach (string t in tags). Denk an foreach als Gang entlang der Sammlung: ein Schritt, ein Wert, eine Ausgabe. Pine bleibt die Tür, die du mit dotnet run öffnest. Die nächste Seite ist nullable, wo ein Werttyp auch «kein Wert» bedeuten kann.
Behalte using System.Collections.Generic;. Halte Count-only-hashset-Demos aus der behaltenen Listen-foreach-Datei fern, damit der Bildschirm nicht versehentlich nur 2 zeigt. Diese Gewohnheiten sind die Kontrollstelle vor dem Weitergehen.

🧠 Testen Sie Ihr Wissen

Bereit zum Start

Testen Sie Ihr Wissen

Fordern Sie sich mit diesem interaktiven Quiz heraus und sehen Sie, wie gut Sie das Thema verstehen

❓
5
Fragen
🎯
70%
Zum Bestehen
♾️
∞
Zeit
🔄
∞
Versuche

📝 Anweisungen

  • Lesen Sie jede Frage sorgfältig
  • Wählen Sie die beste Antwort für jede Frage
  • Sie können das Quiz so oft wiederholen, wie Sie möchten
  • Ihr Fortschritt wird oben angezeigt