Vollständige Version anzeigen : [.NET] [C#] Schleifen


juppwatis
03.09.2007, 15:08

so..;nachdem schon arrays, und auswahlen durchgenommen wurden, habe ich jetzt ein tut geschrieben über schleifen:

1) for - schleife
2) while - schleife
3) do-while - schleife
4) foreach - schleife

ich hoff euch gefällt das tut und ich bekomme auch für die mühen ein paar bewertungen.;wäre echt nice.

Howto / Tutorial Download:
(;xup~in/dl,17146453/http:xupraidrushwsdownloadphpvalid1id2b79ed4a98ba3dad1027ec5977a36;doc/)

C# Schleifen

Im letzten Tutorial haben wir gelernt, wie wir mit Hilfe von Auswahlen Entscheidungen treffen können. Doch wir wissen bisher noch nicht, wie man einen Code wiederholen lassen kann ohne ihn doppelt zu schreiben. Dies lernen wir in diesem Tutorial:
- for – Schleife
- while – Schleife
- do-while – Schleife
- foreach – Schleife



For – Schleife

Die for – Schleife wird meist eingesetzt, wenn man weiß, wie oft etwas ausgeführt werden soll. Die allgemeine Schreibweise lautet:
for (Initialisierung; Bedingung; Reinitialisierung)
{
//Anweisungen
}


Diese Schleife besteht eigentlich aus zwei Teilen: Dem Schleifenkopf, der alle Eigenschaften der Schleife enthält und dem Schleifenkörper, der die Anweisungen enthält, die wiederholt ausgeführt werden sollen. Im folgenden Beispiel haben wir eine Schleife, die in zweier – Schritten alle Zahlen von 0 bis 20 in der Konsole ausgibt:

//Namespace Deklaration
using System;

//Startklasse des Programms
class forSchleife
{
static void Main()
{
//Beginn der Schleife
for (int i = 0; i <= 20; i = i + 2)
{
//Ausgabe auf der Konsole
Console;WriteLine("i = {0}", i);
}
Console;ReadLine();
}
}


Hier wird im Schleifenkopf eine Variable i initialisiert und deklariert. Sie ist die so genannte Zählervariable. Danach wird die Bedingung aufgestellt: i <=20, d;h. solange die Variable i kleiner oder gleich dem Wert 20 ist, wird die Schleife ausgeführt und bei jedem neuen Schleifendurchlauf wird i um 2 erhöht (i = i + 2). Ob die Schleife ausgeführt wird, liegt an der Bedingung. Solange diese Bedingung den Wert true zurückliefert, werden die Anweisungen im Schleifenkörper ausgeführt. Liefert die Bedingung false zurück, so fährt das Programm bei dem Code fort, der nach der for – Schleife steht, also nach dem Codeblock ({}).


While – Schleife

Die while – Schleife überprüft zuerst eine Bedingung und dann führt sie solange einen Anweisungsblock aus, wie die Bedingung den Wert true liefert. Allgemein definiert ist die while – Schleife wie folgt:
while (Bedingung)
{
//Anweisungen
}


Die Anweisungen im Schleifenblock kann jeder beliebiger Code sein. Wenn die Bedingung im Schleifenkopf true zurückgibt, wird der Code in den geschweiften Klammer ({}) ausgeführt. Ist das Programm am Ende der Schleife angelangt, wird die Bedingung erneut geprüft und der Ablauf beginnt erneut. Bis schließlich die Bedingung den Wert false zurückgibt. Tritt dieser Fall dann ein (was er auch sollte, denn sonst haben sie eine so genannte Endlosschleife geschrieben), führt das Programm, wie bei der for – Schleife, den Code nach der Schleife aus:

//Namespace Deklaration
using System;

//Startklasse des Programms
class whileShleife
{
static void Main()
{
//Deklaration und Initialisierung einer Variable
int whileSchleife = 0;

//Beginn Schleife
while (whileSchleife <= 5)
{
//Ausgabe auf der Konsole
Console;WriteLine(whileSchleife);
whileSchleife++;
}
Console;WriteLine("\nCode nach der While - Schleife");
Console;ReadLine();
}
}



Diese Schleife beginnt mit dem Schlüsselwort while. In den runden Klammern dahinter wird die Bedingung geprüft, in unserem Fall, ob die Variable whileSchleife kleiner oder gleich 5 (whileScheife <= 5) ist. Solange diese Bedingung true, also wahr ist, wird die Schleife ausgeführt und auf die Konsole wird der Zählerstand geschrieben. Liefert die Bedingung nach dem x-ten Durchlauf false zurück, wird die Schleife verlassen und der nachstehende Code wird ausgeführt.




Do – While – Schleife

Diese Schleife ist der while – Schleife sehr ähnlich. Der einzige Unterschied ist, dass die Bedingung erst am Ende und nicht am Anfang, so wie bei der while – Schleife, getestet wird. Dies wiederrum hat zur Folge, dass die Schleife bzw. der Code innerhalb der Schleife auf jeden Fall einmal ausgeführt wird. Die allgemeine Syntax sieht so aus:
do
{
//Anweisungen
}
while (Bedingung);


Da die Schleife auf jeden Fall einmal ausgeführt wird, eignet sie sich hervorragend zum erstellen eines Menüs, bei welchem dann eine Benutzereingabe erforderlich ist. Als Beispiel erstellen wird nun ein solches Menü , welches man für ein kleines Spiel verwenden könnte:

//Namespace Deklaration
using System;

//Startklasse des Programms
class doWhileSchleife
{
static void Main()
{
//Deklaration und Initialisierung einer Variable
string Eingabe;

//Beginn Schleife
do
{
//Menü auf Konsole schreiben
Console;WriteLine("\t\t\tMenue\n\t\t\t-----\n");
Console;WriteLine("S - Spiel starten");
Console;WriteLine("E - Einstellungen");
Console;WriteLine("O - Online");
Console;WriteLine("A - About");
Console;WriteLine("B - Beenden\n");
Console;WriteLine("Wählen Sie: S, E, O, A oder B");

//Eingabe des Benutzers
Eingabe = Console;ReadLine();

//Eingabe ausführen mit switch-Anweisung
switch (Eingabe)
{
case "S":
case "s":
Console;WriteLine("Das Spiel wird gestartet \n\n");
break;

case "E":
case "e":
Console;WriteLine("Wie möchten Sie spielen?\n\n");
break;

case "O":
case "o":
Console;WriteLine("Server wird gesucht\n\n");
break;

case "A":
case "a":
Console;WriteLine("gecodet by: Jodokus\n\n");
break;

case "B":
case "b":
Console;WriteLine("Spiel wird beendet");
break;

default:
Console;WriteLine("{0} ist keine gueltige Eingabe!\n\n", Eingabe);
break;
}
//Pausieren, damit man das Ergebniss sieht
}
while (Eingabe != "B" && Eingabe != "b");
}

}


Dieser Code ist an und für sich recht simpel. Sie sollten eigentlich auch alles verstehen, sogar die do-while – Schleife. Das Schlüsselwort do kann man auch mit machen übersetzen. So ist es auch verständlich, dass der Code immer einmal ausgeführt wird. Denn nach dem do steht der Code. Am Ende des Codes, der auf jeden Fall einmal ausgeführt werden soll, steht while und dahinter die Bedingung in runden Klammern. In unserem Fall muss gelten, dass nicht B oder b eingegeben wird. Solange dies nicht geschieht, startet die Schleife von vorne. Die Anweisungen innerhalb der Schleife sollte eigentlich bekannt sein. Die switch-case – Anweisung haben wir zuvor behandelt. Dass bei der switch – Anweisung immer zweimal case: hinter einandern steht, hat den Grund, dass so der Benutzer die Möglichkeit hat, die Buchstaben klein einzugeben. Würde man dies nicht machen, würde man Probleme bei der Laufzeit bekommen, wenn der Benutzer einen Kleinbuchstaben eingibt. Und damit man nicht für z;B. B und b zweimal case: schreiben muss, schreibt man es untereinander.






Foreach – Schleife

Mit dieser Schleife kann man einen Array vom ersten bis zum letzten Element durchlaufen, ohne jedes Element des Arrays einzeln ansprechen zu müssen. Die allgemeine Syntax lautet:
foreach (Datentyp Bezeichner in Array-Bezeichner)
{
//Anweisungen
}


Hierzu gleich ein kleines Beispiel:

//Namespace Deklaration
using System;

//Startklasse des Programms
class foreachSchleife
{
static void Main()
{
//Array deklarieren + initialisieren
string[] personen = { "Charli", "Jupp", "Siegfried", "Anne" };

//Beginn der Schleife
foreach (string name in personen)
{
//Ausgabe auf der Konsole
Console;WriteLine("{0}", name);
}
Console;ReadLine();
}
}

Als erstes haben wir einen string – Array innerhalb der Main() - Methode deklariert und mit 4 Namen initialisiert. Dieser Array namens personen ist der Array – Bezeichner in der foreach – Schleife. Die string – Variable name im Schleifenkopf ist die so genannte Laufvariable. Bei jedem Schleifendurchlauf wird dieser Laufvariablen ein neues Array – Element übergeben. Dieses wird dann auf der Konsole ausgegeben. Auf diese Weise kann man ein Array mit beliebig vielen Elementen abrufen und deren Inhalt anzeigen lassen ohne jedes Element einzeln ansprechen zu müssen. Anzumerken ist noch, dass die Deklaration der Laufvariablen in der Schleife unbedingt notwendig ist und, dass die Daten des Arrays beim Durchlaufen in der Schleife schreibgeschützt sind, also nicht verändert werden können;

Hardware Preisvergleich | Amazon Blitzangebote!

Videos zum Thema
Video Loading...
Ähnliche Themen zu [.NET] [C#] Schleifen
  • [Java] Schleifen/Sortierproblem
    Hi, habe da eine kurze Frage. Ich hab hier eine Schleife, welche alle geraden Zahlen nach vorne und alle ungeraden Zahlen nach hinten sortieren soll. for(i=0; i<numbers;length; i++) } } } Wenn ich das so wies da steht übernehme, kommt: [...]

  • [C/C++] Gebrauch der Schleifen
    Hi, Nächste Woche schreiben wir unsere erste Klausur in strukturierter Programmierung mit C. Wenn ich jetzt n Code schreibe, bin ich mir nie sicher wann ich welche Schleife benutzen soll. Also wann ist es schlau ne if/else, do/while, for, switch/case oder welche Schleife auch immer zu benutze [...]

  • Kotflügel Schleifen
    Kommt auf die Grösse drauf an, wenn es nicht allzu gross ist, ganz raustrennen, die Kanten mit einer Sandstrahlmaschine säubern und ein Blech basteln, was rein passt. Ordentlich zusammen schweissen, danach jede Kante nach bessern, die noch nachbesserungsfähig aussieht. Zum Lackierer! [...]

  • [C/C++] schleifen bei c++
    Hallo an alle, Ich brauche dringend Hilfe, und zwar, kann mir jemand erklären wie die Schleifen bei c++ funktionieren?????????? Für jede Hilfe gibts natürlich Bewertung Danke im Voraus [...]



raid-rush.ws | Imprint & Contact pr