コード例 #1
0
        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");
            }
        }
コード例 #2
0
        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();
        }
コード例 #3
0
        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();
        }
コード例 #4
0
        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();
        }
コード例 #5
0
        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;
            }
        }
コード例 #6
0
ファイル: Program.cs プロジェクト: romacgit/Advanced_CSharp
        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;
            }
        }
コード例 #8
0
ファイル: Stundenplan.cs プロジェクト: Nelvin73/Schule
 public Unterrichtsstunde GetStunde(Wochentag w, int Stunde)
 {
     return Stunden.Where(x => x.Stunde == Stunde && x.Tag == w).FirstOrDefault();
 }
コード例 #9
0
ファイル: Program.cs プロジェクト: ppedvAG/CSharp_Grundlagen_
        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
        }
コード例 #10
0
        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
        }
コード例 #11
0
ファイル: Program.cs プロジェクト: ppedvAG/20200225-cs-gk-ka
        //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();
        }
コード例 #12
0
        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();
        }
コード例 #13
0
ファイル: Denum.cs プロジェクト: ppedvAG/20200225-cs-gk-ka
        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();
        }
コード例 #14
0
ファイル: Stundenplan.cs プロジェクト: Nelvin73/Schule
 public List<Fach> Fächer(Wochentag Tag)
 {
     return (
         from s in Stunden
         where s.Tag == Tag
         orderby s.Stunde
         select s.Fach).ToList();
 }
コード例 #15
0
ファイル: Objects.cs プロジェクト: famoser/Gymoberwil
 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;
 }
コード例 #16
0
        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();
        }
コード例 #17
0
        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();
        }
コード例 #18
0
        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();
        }
コード例 #19
0
ファイル: DEnum.cs プロジェクト: ppedvAG/20200225-cs-gk-ka
        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();
        }