static string GebeMirWochentagInEnglisch(Wochentag wochentag)
{
switch (wochentag)
{
case Wochentag.Montag:
return("Monday");
case Wochentag.Dienstag:
return("Tuesday");
case Wochentag.Mittwoch:
return("Wendesday");
case Wochentag.Donnerstag:
return("Thursday");
case Wochentag.Freitag:
return("Friday");
case Wochentag.Samstag:
return("Saturday");
case Wochentag.Sonntag:
return("Sunday");
default:
return("Error");
}
}
static void Main(string[] args)
{
//Deklaration und Initialisierung einer Variablen vom Enumerator-Typ
Wochentag heute = Wochentag.Dienstag;
Console.WriteLine(heute);
//Cast: Int -> Wochentag
heute = (Wochentag)4545;
Console.WriteLine(heute);
//For-Schleife über die möglichen Zustande des Enumerators
Console.WriteLine("Wähle den heutigen Wochentag:");
for (int i = 1; i <= Enum.GetValues(typeof(Wochentag)).Length; i++)
{
Console.WriteLine($"{i}: {(Wochentag)i}");
}
//Speichern einer Benutzereingabe (Int) als Enumerator
heute = (Wochentag)int.Parse(Console.ReadLine());
Console.WriteLine(heute);
//SWITCHs sind eine verkürzte Schreibweise für IF-ELSE-Blöcke. Mögliche Zustände der übergebenen Variablen werden
//in den CASES definiert
switch (heute)
{
case Wochentag.Montag:
Console.WriteLine("Einen schönen Wochenanfang");
//Jeder speziell definierte CASE muss mit einer BREAK-Anweisung beendet werden
break;
//Wenn in einem CASE keine Anweisungen geschrieben stehen kann auf den BREAK-Befehl verzichtet werden. In diesem Fall
//springt das Programm in diesem CASE zum Nachfolgenden
case Wochentag.Dienstag:
case Wochentag.Mittwoch:
case Wochentag.Donnertag:
Console.WriteLine("Schöne Woche");
break;
//Wenn die übergebene Variable keinen der vordefinierten Zustände erreicht, wird der DEFAULT-Fall ausgeführt
default:
Console.WriteLine("Schönes Wochenende");
break;
}
//Mittels des WHEN-Stichworts kann auf Eigenschaften des betrachteten Objekts näher eingegangen werden
string a = "Hallo";
switch (a)
{
case string b when b.Length > 4:
Console.WriteLine(b);
break;
default:
break;
}
//Programmpause
Console.ReadKey();
}
static void Main(string[] args)
{
// create variable from enum
Wochentag day = Wochentag.Montag;
Console.WriteLine("Es ist " + day); // Write es ist montag
Console.WriteLine(day + " hat den Wert " + (int)day); // take value from montag
Console.ReadKey();
}
static void Main(string[] args)
{
//Deklaration und Initialisierung einer Variablen vom Enumerator-Typ
Wochentag heutigerTag = Wochentag.Dienstag;
heutigerTag = (Wochentag)5;
//Cast: Int -> Wochentag
Console.WriteLine((Wochentag)5);
Console.WriteLine("Welchen Tag haben wir heute?");
//For-Schleife über die möglichen Zustande des Enumerators
for (int i = 1; i <= 7; i++)
{
Console.WriteLine($"{i}: {(Wochentag)i}");
}
//Speichern einer Benutzereingabe (Int) als Enumerator
heutigerTag = (Wochentag)int.Parse(Console.ReadLine());
//SWITCHs sind eine verkürzte Schreibweise für IF-ELSE-Blöcke. Mögliche Zustände der übergebenen Variablen werden
//in den CASES definiert
switch (heutigerTag)
{
case Wochentag.Montag:
Console.WriteLine("Schönen Wochenstart");
//Jeder speziell definierte CASE muss mit einer BREAK-Anweisung beendet werden
break;
//Wenn in einem CASE keine Anweisungen geschrieben stehen kann auf den BREAK-Befehl verzichtet werden. In diesem Fall
//springt das Programm in diesem CASE zum Nachfolgenden
case Wochentag.Dienstag:
case Wochentag.Mittwoch:
case Wochentag.Donnerstag:
Console.WriteLine("Schöne Woche");
break;
case Wochentag.Freitag:
case Wochentag.Samstag:
case Wochentag.Sonntag:
Console.WriteLine("Schönes Wochenende");
break;
//Wenn die übergebene Variable keinen der vordefinierten Zustände erreicht, wird der DEFAULT-Fall ausgeführt
default:
Console.WriteLine("Irgendwas ist da falsch gelaufen!");
break;
}
//Programmpause
Console.ReadKey();
}
static void Main(string[] args)
{
//Enum in einer Variablen verwenden und initialisieren
Wochentag tag = Wochentag.Fr;
WochentagAutomatisch freitag = WochentagAutomatisch.Fr;
//einen Enum in den zugewiesenen Zahlenwert konvertieren
int wochentag = (int)tag; // 5
int wochentagAuto = (int)freitag; //4, da die automatische Zuweisung bei 0 beginnt
//einen Zahlenwert in den zugewiesenen Enum konvertieren
Wochentag tag3 = (Wochentag)3; //Mi
Wochentag tag8 = (Wochentag)8; //8, da dem Zahlenwert 8 kein Enumerationsmembers zugewiesen wurde
//mehrere Enums (mit Flags) einer Variable zuweisen
Fruechte fruchtkorb = Fruechte.Banane | Fruechte.Kirsche | Fruechte.Apfel | Fruechte.Pflaume;
Fruechte lieblingsFruechte = Fruechte.Birne | Fruechte.Orange | Fruechte.Kirsche | Fruechte.Banane;
//die Schnittmengen von zwei Auswahlmoeglichkeiten kombinieren
Console.WriteLine($"Im Fruchtkorb sind meine lieblings Fruechte {fruchtkorb & lieblingsFruechte}");
//"Im Fruchtkorb sind meine lieblings Fruechte Kirsche, Banane"
//auf einzelne Enumerationsmember pruefen
bool istOrangeImFruchtkorb = (fruchtkorb & Fruechte.Orange) == Fruechte.Orange;
Console.WriteLine($"Gibt es im Fruchtkorb Orangen: {istOrangeImFruchtkorb}");
//"Gibt es im Fruchtkorb Orangen: False"
//Enum ueber eine switch-Anweisung ueberpruefen lassen
string hinweis;
switch (tag)
{
case Wochentag.Mo:
case Wochentag.Di:
case Wochentag.Mi:
case Wochentag.Do:
case Wochentag.Fr:
hinweis = "Leider ist noch kein Wochenende..";
break;
case Wochentag.Sa:
case Wochentag.So:
hinweis = "Wuhu! Endlich Wochenende!";
break;
default:
break;
}
}
static void Main(string[] args)
{
Wochentag tag = Wochentag.Sonntag;
switch (tag)
{
case Wochentag.Montag:
Console.WriteLine("Es ist Montag");
break;
case Wochentag.Dienstag:
Console.WriteLine("Es ist Dienstag");
break;
default:
Console.WriteLine("Es ist ein anderer Tag");
break;
}
Console.ReadKey();
}
private void DemonstrateEnumerator()
{
int eingabe = WeekdaysCombi.SelectedIndex;
// Int-Variablen können in den Typ Wochentag umgewandelt werden
// Weil die Werte vom Enumerator indexiert sind (Mo = 0, Di = 1, ...)
// In den runden Klammern wird bei Type-Casting der gewünschte Typ gestellt
// Falls die Typen kompatibel sind, findet die Typumwandlung statt
Wochentag tag = (Wochentag)eingabe;
// const string mo = "Mo";
switch (tag)
{
case Wochentag.Mo:
ausgabeTextBlock.Text = "Pizza";
break;
case Wochentag.Di:
ausgabeTextBlock.Text = "Königsberger Klöpse";
break;
case Wochentag.Mi:
ausgabeTextBlock.Text = "Spaghetti Carbonara";
break;
case Wochentag.Do:
ausgabeTextBlock.Text = "Pilzenpfanne";
break;
case Wochentag.Fr:
ausgabeTextBlock.Text = "Fisch mit Kartoffeln";
break;
case Wochentag.Sa:
case Wochentag.So:
ausgabeTextBlock.Text = "20 % auf alle Gerichte";
break;
}
}
public Unterrichtsstunde GetStunde(Wochentag w, int Stunde)
{
return Stunden.Where(x => x.Stunde == Stunde && x.Tag == w).FirstOrDefault();
}
static void Main(string[] args)
{
//Punkt bei Kommzahlen
CultureInfo customCulture = (CultureInfo)Thread.CurrentThread.CurrentCulture.Clone();
customCulture.NumberFormat.NumberDecimalSeparator = ".";
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
for (int i = 1; i < 8; i++)
{
Console.WriteLine($"{i}: {(Wochentag)i}");
}
Console.ReadKey();
DinnerItems myOrder = DinnerItems.Appetizer | DinnerItems.Entree |
DinnerItems.Beverage | DinnerItems.Dessert;
DinnerItems flagValue = DinnerItems.Entree | DinnerItems.Beverage;
Console.WriteLine("{0} includes {1}: {2}",
myOrder, flagValue, myOrder.HasFlag(flagValue));
//BitMask
//https://docs.microsoft.com/de-de/dotnet/api/system.enum.hasflag?view=netframework-4.8
//System.Environment.Exit(0);
#region switch Sample
//SWITCHs sind eine verkürzte Schreibweise für IF-ELSE-Blöcke. Mögliche Zustände der übergebenen Variablen werden
//in den CASES definiert
Wochentag heute = Wochentag.Freitag;
switch (heute)
{
case Wochentag.Montag:
Console.WriteLine("beliebtester Tag der Woche");
break;
//Wenn in einem CASE keine Anweisungen geschrieben stehen kann auf den BREAK-Befehl verzichtet werden.
//In diesem Fall
//springt das Programm in diesem CASE zum Nachfolgenden
case Wochentag.Dienstag:
case Wochentag.Mittwoch:
case Wochentag.Donnerstag:
Console.WriteLine("Nicht überarbeiten!");
break;
case Wochentag.Freitag:
Console.WriteLine("Bald ist Wochenende!");
break;
default:
Console.WriteLine("Endlich Wochenende");
break;
}
//Advanced Beispiel
//Mittels des WHEN-Stichworts kann auf Eigenschaften des betrachteten Objekts näher eingegangen werden
int a = 11;
switch (a)
{
case 5:
Console.WriteLine("Irgendwas");
break;
//a wird in b eingelegt (zu überprüfende Variable wir für Bedingungsprüfung vorbereitet)
//und mittels when auf eine Eigenschaft geprüft
case int b when b > 10:
Console.WriteLine("a ist größer als 10");
break;
default:
break;
}
Console.ReadKey();
#endregion
}
static void Main(string[] args)
{
int a = 25;
int b = 30;
#region if-Statement
//if + Tab + Tab Shortcut
if (a < b)
{
Console.WriteLine("A ist kleiner als B");
}
else if (a > b)
{
Console.WriteLine("B ist kleiner als A");
}
else
{
Console.WriteLine("A und B sind gleich");
}
#endregion
#region if -shortcut version
//Kurznotation:
//(Bedingung) ? TrueAusgabe : FalseAusgabe
string ergebnis = (a == b) ? "A ist gleich B" : " A ist ungleich B";
#endregion
#region for-Schleife
//Zählergesteuerte Schleife
StreamWriter sw = new StreamWriter("zahlen.txt");
for (int i = 0; i < 100; i++)
{
sw.WriteLine(i);
if (i < 50)
{
continue;
}
Console.WriteLine(i);
}
sw.Close();
Console.WriteLine("+++ Schreiben in Datei ist fertig +++");
Console.ReadKey();
//Kopfgesteuerten Schleife
StreamReader sr = new StreamReader("zahlen.txt");
int summe = 0;
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
Console.WriteLine(line);
summe += int.Parse(line);
}
sr.Close();
Console.WriteLine($"Ergebnis: {summe}");
Console.ReadKey();
#endregion
#region do while
a = 1;
do
{
a *= 2;
continue;
//Console.WriteLine("Wird niemals ausgeführt");
} while (a < 100);
#endregion
#region Array
// indexbereich 0 - 6 | zahlenArray.Legth = 7
//deklarieren eines Array mit gleichzeitiger Initialisierung
int[] zahlenArray = { 2, 4, 56, 45, 32, 64, 23 };
//Array ohne Initialisierung anlegen
int[] zweitesZahlenArray = new int[5];
//Index beginnt immer bei dem Wert 0
zweitesZahlenArray[0] = 2; // Indexposition 0
zweitesZahlenArray[1] = 5;
zweitesZahlenArray[2] = 34;
zweitesZahlenArray[3] = 12;
zweitesZahlenArray[4] = 54;
List <string> alleFarben = new List <string>();
alleFarben.Add("Blue");
alleFarben.Add("White");
alleFarben.Add("Orange");
alleFarben.Add("Red");
alleFarben.Add("Yellow");
List <string> weitereFarben = new List <string>();
weitereFarben.Add("green");
weitereFarben.Add("Black");
alleFarben.AddRange(weitereFarben.ToArray());
//Hier würde eine OutOfRange Exception entstehen!!!!
//zweitesZahlenArray[5] = 44;
string einWort = "Wahnsinn!";
char buchstabe;
for (int i = 0; i < einWort.Length; i++)
{
buchstabe = einWort[i];
Console.WriteLine(buchstabe);
}
Console.WriteLine("Weitere Ausgabe");
foreach (var c in einWort)
{
Console.WriteLine(c);
}
Console.ReadKey();
if (zahlenArray.Contains(32))
{
// Der Wert 32 wurde im Array gefunden
}
int hoechsterWertDesArrays = zahlenArray.Max();
int niedrigsterWertDesArrays = zahlenArray.Min();
int gesamteSummeEinesArrays = zahlenArray.Sum();
int erstesElement = zahlenArray.First();
int letztesElement = zahlenArray.Last();
#endregion
#region Enums
string[] wTag = new string[7];
wTag[0] = "Montag";
wTag[1] = "Dienstag";
Wochentag ausgewaehlterTag = Wochentag.Samstag;
Type weekdays = typeof(Wochentag);
int TagInDerWoche = (int)ausgewaehlterTag;
for (int i = 0; i < 7; i++)
{
Console.WriteLine($"{i}: {(Wochentag)i}");
}
//Bitmask
//https://www.oreilly.com/library/view/c-cookbook/0596003390/ch04s05.html
Console.ReadKey();
switch (ausgewaehlterTag)
{
case Wochentag.Montag:
break;
case Wochentag.Dienstag:
break;
case Wochentag.Mittwoch:
break;
case Wochentag.Donnerstag:
break;
case Wochentag.Freitag:
break;
default:
Console.WriteLine("Wochenende");
break;
}
;
int colorValue = 0;
colorValue += (int)Colors.Red;
colorValue += (int)Colors.Blue;
colorValue += (int)Colors.Yellow;
//ADVANCED -> Nicht für Anfänger
//Mittels des WHEN-Stichworts kann auf Eigenschaften des betrachteten Objekts näher eingegangen werden
int a1 = 11;
switch (a1)
{
case 5:
Console.WriteLine("Irgendwas");
break;
//a wird in b eingelegt (zu überprüfende Variable wir für Bedingungsprüfung vorbereitet)
//und mittels when auf eine Eigenschaft geprüft
case int b1 when b1 > 10 && b1 < 20:
Console.WriteLine("a ist größer 10");
break;
default:
break;
}
Console.ReadKey();
#endregion
}
//Enum muss außer der Methoden deklariert werden
static void Main(string[] args)
{
#region M2
Console.WriteLine("\n ### declaration of enums ###");
Console.WriteLine("\n ### calling of enums ###");
Pizzagröße PiGr = Pizzagröße.Mittel;
Console.WriteLine("Ich hab Pizza der Größe {0} gewählt.", PiGr);
Pizzagröße PiGr2 = (Pizzagröße)(2);
Console.WriteLine("- und ich hab {0} gewählt.", PiGr2);
// ===========================================================
#endregion
///Enumeratoren sind selbst-definierte Datentypen mit festgelegten möglichen Zuständen.
///Jeder Zustand ist dabei an einen Int-Wert gekoppelt (Casting möglich).
///
//Variablen von dem Datentyp Pizzagröße dürfen nur die aufgelisteten Werte bekommen.
// ############################################################################
// #############################################################################
// #############################################################################
#region M3
Console.Write("Geben Sie Wochentag ein:");
Wochentag WoTag = (Wochentag)(int.Parse(Console.ReadLine()));
// Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot {PiGr}");
switch (WoTag)
{
case Wochentag.Mo:
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot {PiGr}");
break;
case Wochentag.Di:
case Wochentag.Mi:
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot {PiGr2}");
break;
case Wochentag.Fr:
Pizzagröße PiGr3 = (Pizzagröße)(3);
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot {PiGr3}");
break;
default:
Console.WriteLine("Die Preise etscprechen den PGr");
break;
}
#endregion
#region MORE FANCY STUFF
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
#endregion
Console.ReadKey();
}
static void Main(string[] args)
{
//Vor der Zeit des Enum, wurden Wochentage so dargstellt
//Mit dem Nachteil, dass die Übersicht verloren geht, an welchen Index, welcher Wert steht
string[] Wochentage = new string[7];
Wochentage[0] = "Montag";
Wochentage[1] = "Dienstag";
Wochentage[2] = "Mittwoch";
Wochentage[3] = "Donnerstag";
Wochentage[4] = "Freitag";
Wochentage[5] = "Samstag";
Wochentage[6] = "Sonntag";
//Deklaration und Initialisierung einer Variablen vom Enumerator-Typ
Wochentag heute = Wochentag.Dienstag;
Console.WriteLine($"Heute ist {heute}");
//Casten von Integer Werten auf Enums, mithilfe einer Zählschleife
for (int i = 1; i < 8; i++)
{
Console.WriteLine($"{i}: {(Wochentag)i}");
}
// Casten von Integer Werten auf Enums, mithilfe einer Benutzereingabe
heute = (Wochentag)int.Parse(Console.ReadLine());
// Enum & BitMask -> https://docs.microsoft.com/de-de/dotnet/api/system.enum.hasflag?view=netframework-4.8
if (heute == Wochentag.Montag)
{
}
else if (heute == Wochentag.Dienstag)
{
}
else if (heute == Wochentag.Mittwoch)
{
}
else if (heute == Wochentag.Donnerstag)
{
}
else if (heute == Wochentag.Freitag)
{
//
}
else if (heute == Wochentag.Samstag)
{
MacheWasDirAmSamstagGefaellt();
}
else
{
}
//1) switch + tab + tab
//2) eingabe der enum variable heute
//3) [Enter] [Enter]
switch (heute)
{
case Wochentag.Montag:
break;
case Wochentag.Dienstag:
break;
case Wochentag.Mittwoch:
break;
case Wochentag.Donnerstag:
break;
case Wochentag.Freitag:
break;
case Wochentag.Samstag:
MacheWasDirAmSamstagGefaellt();
break;
case Wochentag.Sonntag:
break;
default:
break;
}
string englischeBeschreibung = GebeMirWochentagInEnglisch(heute);
Console.WriteLine(englischeBeschreibung);
string eingabe = string.Empty;
eingabe = Console.ReadLine();
switch (eingabe)
{
case "Optionen":
//Gehe ins Menü Optionen
break;
case "Info":
//Gehe in das Infofesten
break;
default:
//Gehe nochmals in Menü und frage nochmal nach der Eingabe
break;
}
int a = 11;
switch (a)
{
case 5:
Console.WriteLine("Irgendwas");
break;
//a wird in b eingelegt (zu überprüfende Variable wir für Bedingungsprüfung vorbereitet)
//und mittels when auf eine Eigenschaft geprüft
case int b when b > 10 || b < 3:
Console.WriteLine("a ist größer als 10");
break;
case int b when b > 10 && b < 3:
Console.WriteLine("a ist größer als 10");
break;
case int b when b > 10:
Console.WriteLine("a ist größer als 10");
break;
}
Console.ReadKey();
}
static void Main(string[] args)
{
#region M2
// ===========================================================
Console.WriteLine("\n ### declaration of enums ###");
// siehe den Code über der Main-Methode
// ===========================================================
Console.WriteLine("\n ### calling of enums ###");
Pizzagröße PiGr = Pizzagröße.Mittel;
Console.WriteLine("Ich hab mir ne Pizza von der Größe {0} gewählt.", PiGr);
Pizzagröße PiGr2 = (Pizzagröße)(2);
Console.WriteLine("- Und ich hab {0} genommen", PiGr2);
#endregion
#region M3
// switch
Console.Write("Geben Sie Wochentag ein");
Wochentag WoTag = (Wochentag)(int.Parse(Console.ReadLine()));
switch (WoTag)
{
case Wochentag.Mo:
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot {PiGr}");
break;
case Wochentag.Di:
case Wochentag.Mi:
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot {PiGr2}");
break;
case Wochentag.Do:
case Wochentag.Fr:
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot {Pizzagröße.Klein}");
break;
case Wochentag.Sa:
case Wochentag.So:
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot {Pizzagröße.Family}");
break;
default:
Console.WriteLine("Die Preise entsprechen den Pizzagrößen");
break;
}
//Mittels des WHEN-Stichworts kann auf Eigenschaften des betrachteten Objekts näher eingegangen werden
int a = 11;
switch (a)
{
case 5:
Console.WriteLine("a = 5");
break;
//a wird in b eingelegt (zu überprüfende Variable wir für Bedingungsprüfung vorbereitet)
//und mittels when auf eine Eigenschaft geprüft
case int b when b > 10:
Console.WriteLine("a > 10");
break;
default:
Console.WriteLine("a ist irgendwas");
break;
}
#endregion
// #############################################################################
// #############################################################################
// #############################################################################
#region MORE FANCY STUFF
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
#endregion
Console.ReadKey();
}
public List<Fach> Fächer(Wochentag Tag)
{
return (
from s in Stunden
where s.Tag == Tag
orderby s.Stunde
select s.Fach).ToList();
}
public Stunde(StundeSaveObject s)
{
this.customanfangszeit = s.customanfangszeit;
this.customendzeit = s.customendzeit;
this.Tag = s.Tag;
this.woche = s.woche;
this.zeit = s.zeit;
this.zimmernummer = s.zimmernummer;
this.fach = s.fach;
}
static void Main(string[] args)
{
//Deklaration und Initialisierung einer Variablen vom Enumerator-Typ
Wochentag heute = Wochentag.Dienstag;
Console.WriteLine($"Heute ist {heute}.");
//For-Schleife über die möglichen Zustande des Enumerators
Console.WriteLine("Welcher Wochentag ist heute?");
for (int i = 1; i <= Enum.GetValues(typeof(Wochentag)).Length; i++)
{
Console.WriteLine($"{i}: {(Wochentag)i}");
}
//Speichern einer Benutzereingabe (Int) als Enumerator
//Cast: Int -> Wochentag
heute = (Wochentag)int.Parse(Console.ReadLine());
Console.WriteLine($"Heute ist also ein {heute}.");
//SWITCHs sind eine verkürzte Schreibweise für IF-ELSE-Blöcke. Mögliche Zustände der übergebenen Variablen werden
//in den CASES definiert
switch (heute)
{
case Wochentag.Montag:
//Jeder speziell definierte CASE muss mit einer BREAK-Anweisung beendet werden
Console.WriteLine("Schönen Wochenstart");
break;
//Wenn in einem CASE keine Anweisungen geschrieben stehen kann auf den BREAK-Befehl verzichtet werden. In diesem Fall
//springt das Programm in diesem CASE zum Nachfolgenden
case Wochentag.Dienstag:
case Wochentag.Mittwoch:
case Wochentag.Donnerstag:
Console.WriteLine("Schönen Arbeitstag");
break;
case Wochentag.Freitag:
Console.WriteLine("Fast geschafft");
break;
//Wenn die übergebene Variable keinen der vordefinierten Zustände erreicht, wird der DEFAULT-Fall ausgeführt
default:
Console.WriteLine("Schönes Wochenende");
break;
}
//Mittels des WHEN-Stichworts kann auf Eigenschaften des betrachteten Objekts näher eingegangen werden
int a = 11;
switch (a)
{
//a wird in b eingelegt (zu überprüfende Variable wir für Bedingungsprüfung vorbereitet)
//und mittels when auf eine Eigenschaft geprüft
case int b when b > 10:
Console.WriteLine("Hallo");
break;
default:
break;
}
Console.ReadKey();
}
static void Main(string[] args)
{
#region M2
// ===========================================================
Console.WriteLine("\n ### declaration of enums ###");
// siehe den Code über der Main-Methode
// ===========================================================
Console.WriteLine("\n ### calling of enums ###");
Pizzagröße PiGr = Pizzagröße.Mittel;
Console.WriteLine("Ich hab mir ne Pizza von der Größe {0} gewählt.", PiGr);
Pizzagröße PiGr2 = (Pizzagröße)(2);
Console.WriteLine("- Und ich hab {0} genommen.", PiGr2);
#endregion
#region M3
Console.Write("Geben Sie den Wochentag als Zahl 1 bis 7 ein ");
Wochentag WoTag = (Wochentag)(int.Parse(Console.ReadLine()));
switch (WoTag)
{
case Wochentag.Mo:
PiGr = (Pizzagröße)(2);
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot gibt es die Größe {PiGr} zum Preis der Größe Klein");
break;
case Wochentag.Di:
case Wochentag.Mi:
case Wochentag.Do:
PiGr = (Pizzagröße)(1);
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot gibt es die Größe {PiGr} zum Preis der Größe Klein");
break;
case Wochentag.Fr:
PiGr = (Pizzagröße)(3);
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot gibt es die Größe {PiGr} zum Preis der Größe Klein");
break;
default:
Console.WriteLine("Am Wochenende gibt es keine Angebote");
break;
}
Console.ReadKey();
#endregion
// #############################################################################
// #############################################################################
// #############################################################################
#region MORE FANCY STUFF
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
#endregion
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Bitte geben Sie eine Zahl ein:");
// Schnellvariante: int zahl = Convert.ToInt32(Console.ReadLine());
string eingabe = Console.ReadLine(); // Eingabe als string gespeichert
int zahl = Convert.ToInt32(eingabe); // Zeichenkette zu einer Zahl konvertiert
// IF - Codeblock:
// if(BEDINGUNG)
if (zahl < 50)
{
// Codeblock wird ausgeführt, wenn die Zahl kleiner als 50 ist
Console.WriteLine("Die Zahl '{0}' ist kleiner als 50", zahl);
}
// Alternative: Wird überprüft, wenn die erste Bedingung nicht stimmt
// else if (BEDINGUNG)
else if (zahl < 100)
{
Console.WriteLine("Die Zahl '{0}' ist kleiner als 100", zahl);
}
// "Letzte Möglichkeit" -> Wenn alles andere "false" ist
// else
else
{
Console.WriteLine("Die Zahl '{0}' ist größer als 100", zahl);
}
// Vergleich von Zeichenketten :
// string.Compare
// Verknüpfungsoperator:
// Logisches AND &&
// Logisches OR ||
// Logisches XOR ^
// Invertieren !
// Situation: Zahl zwischen 0 und 100
if (zahl > 0 && zahl < 100)
{
Console.WriteLine("Die Zahl ist größer als 0 und kleiner als 100");
}
// Bedinungsgesteuerte Schleife:
int demoZahl = 10;
while (demoZahl < 100)
{
demoZahl++;
Console.WriteLine("Zahl {0} ist kleiner als 100", demoZahl);
}
string passwort = "";
while (passwort != "geheim")
{
Console.WriteLine("Bitte geben Sie Ihr Passwort ein:");
passwort = Console.ReadLine();
}
// Arrays:
// Schreibweise Variante 1:
int[] zahlen1 = new int[5]; // Index: 0,1,2,3,4
zahlen1[0] = 5;
zahlen1[1] = 10; // Befüllen
// ...
// Schreibweise Variante 2:
int[] zahlen2 = new int[] { 5, 10, 15 }; // Größe: 3 , Index: 0,1,2
// Schreibweise Variante 3:
int[] zahlen3 = { 12, 99, 7, 4 }; // Größe: 4, Index: 0,1,2,3
// Starten F5
// Haltepunkt F9
// Einzelschritt: F10 oder F11
// in ein Array hineinschreiben
zahlen1[3] = 55;
// ein Array auslesen
Console.WriteLine(zahlen1[3]);
// For - Schleife:
// for + TAB + TAB
for (int i = 0; i < 100; i++)
{
Console.WriteLine(i);
}
for (int i = 0; i < zahlen3.Length; i++)
{
Console.WriteLine(zahlen3[i]);
}
// Schleifen steuern:
for (int i = 0; i < 10000; i++)
{
// Schleife früher beenden:
if (i == 99)
{
break; // beendet die Schleife
}
}
for (int i = 0; i < 10000; i++)
{
// Schleifenschritt überspringen:
if (i % 2 == 0) // gerade Zahl
{
continue; // gehe zum nächsten durchgang
}
Console.WriteLine(i); // nur ungerade Zahlen ausgeben
}
// Enum verwenden:
Wochentag heute = Wochentag.Montag;
if (heute == Wochentag.Montag)
{
Console.WriteLine("Juhu es ist Montag !!!");
}
else if (heute == Wochentag.Dienstag)
{
; // .....
}
else if (heute == Wochentag.Mittwoch)
{
; // ....
}
// Switch: Switch + TAB + TAB
switch (heute)
{
case Wochentag.Montag:
case Wochentag.Dienstag:
case Wochentag.Mittwoch:
case Wochentag.Donnerstag:
Console.WriteLine("Unter der Woche");
break;
case Wochentag.Freitag:
Console.WriteLine("Fast-Wochenende");
break;
case Wochentag.Samstag:
case Wochentag.Sonntag:
Console.WriteLine("Wochenende");
break;
default: // Quasi der "else"-Fall
break;
}
Console.WriteLine("----ENDE----");
Console.ReadKey();
}
static void Main(string[] args)
{
#region M02
Console.WriteLine("\n # Declaration of Enums #");
// Siehe den Code über der Main Methode
// ===========================================================
Console.WriteLine("\n ### Calling of enums ###");
Pizzagröße PiGr = Pizzagröße.Mittel;
Console.WriteLine($"Ich habe mir eine Pizza von der Größe {PiGr} gegönnt.");
Pizzagröße PiGr2 = (Pizzagröße)(2);
Console.WriteLine($" - Und ich habe {PiGr2} genommen.");
#endregion
#region M03
Console.WriteLine("\n # Switch #");
// ===========================================================
Console.WriteLine("\n ### Anlage Wochentag###");
Console.Write("Geben Sie den Wochentag ein :");
Wochentag WoTag = (Wochentag)(int.Parse(Console.ReadLine()));
Console.WriteLine($"Der gewählte Tag ist {WoTag}, im Angebot {PiGr}");
Console.WriteLine("\n ### Switch ###");
switch (WoTag)
{
case Wochentag.Mo:
case Wochentag.Di:
Console.WriteLine($"Der gewählte Tag ist {WoTag} und im Angebot {Pizzagröße.Family}.");
break;
case Wochentag.Mi:
case Wochentag.Do:
Console.WriteLine($"Der gewählte Tag ist {WoTag} und im Angebot {Pizzagröße.Groß}.");
break;
case var TestWoTag when(TestWoTag > Wochentag.Do): //Case When mit Pattern Matching
Console.WriteLine($"Das Wochenendangebot sind Pizzas der Größe {Pizzagröße.Mittel}.");
break;
}
#endregion
// #############################################################################
// #############################################################################
// #############################################################################
#region MORE FANCY STUFF
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
// ===========================================================
#endregion
Console.ReadKey();
}
