Reorder

FurtherExercises/Eigenaufgaben/Exercise_1.cs

@@ -0,0 +1,43 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Exercises_C_Sharp.Eigenaufgaben
+{
+    // Dotnet bietet eine Möglichkeit, Benchmarks für gewisse Aufgaben zu erstellen. Dieses Tool bzw. diese Klasse heißt "BenchmarkRunner". Das heißt, der Code wird ausgeführt und die Zeit der Ausführung gemessen. Dafür müssen Sie folgende Attribute in der zu prüfenden Klasse setzen: [Params(1000,10_000)], [Benchmark]
+
+    class Exercise_1
+    {
+        public static void Start()
+        {
+            //Starten Sie hier den Benchmark:
+            //Code START
+            
+            //Code ENDE
+        }
+    }
+    class StringTest
+    {
+        //Setzen Sie die Attribute so, dass ein Vergleich zwischen den Geschwindigkeiten beider Methoden stattfinden kann. 
+        //Code START
+        public int Amounts {get;set;}
+        public string WithStringBuilder()
+        {
+            StringBuilder sb = new();
+            for(int i = 0; i < Amounts; i++)
+                sb.Append(i);
+            
+            return sb.ToString();
+        }
+        public string WithPlusOperator()
+        {
+            string result = "";
+            for(int i = 0; i < Amounts; i++)
+                result += i;
+            
+            return result;
+        }
+        //Code ENDE
+    }
+}

FurtherExercises/Entwicklungsaufgaben/Minispiele/Step_1.cs

@@ -0,0 +1,17 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+namespace Exercises_C_Sharp.Entwicklungsaufgaben.Minispiele
+{
+    class Step_1
+    {
+        
+
+        public static void Start()
+        {
+            
+        }
+
+    }
+}

FurtherExercises/Entwicklungsaufgaben/Minispiele/Step_1.txt

@@ -0,0 +1,7 @@
+Im ersten Schritt sollen Sie sich mit dynamischen Eingaben in Echtzeit auseinandersetzen. Die Grundvoraussetzung dafür ist eine Umgebung, in der beispielsweise ein Männchen (repräsentiert durch einen Char, also beispielsweise einem X), die als Spielfigur agiert, vom Nutzer gesteuert werden kann. Dies wollen wir mit Hilfe der Pfeiltasten realisieren. Dafür kann man sehr gut die Methode Console.ReadKey() verwenden. Dieser gibt (bis auf ein paar ausnahmen) bei jedem Tastendruck die jeweilige Taste mit dem Wert eines Enums zurück. Sie können den Wert dann mit .Key abfragen.
+
+
+Im Kern sind also Ihre Aufgaben folgende:
+ - Erstellen Sie ein zweidimensionales Array.
+ - Implementieren Sie ein Objekt, dass der Nutzer mit Hilfe der Pfeiltasten steuern kann.
+ - Zeigen Sie das 'Spielfeld' an und aktualisieren Sie es bei jeder Änderung.

FurtherExercises/Esperanto/First.cs

@@ -0,0 +1,31 @@
+namespace Exercises_C_Sharp.Esperanto
+{
+    // #1: Nomen enden in Esperanto in der Grundform immer auf 'O'. [libro] 
+    // #2: Will man die Mehrzahl eines Nomens haben, dann hängt man hinten einfach ein 'j' an, welches als 'i' gesprochen wird. [libroj]
+    // #3: Will (oder braucht) man das Nomen im Akkusativ (Sie erinnern sich: Wen oder was?), dann hängt man hinten ein 'n' an. [libron]
+    class First
+    {
+
+        //Der User soll in der Start-Methode einen String eingeben. Wenn dieser String ein Nomen ist, dann soll dies ausgegeben werden und die Methode "WorkWithNomen()" aufgerufen werden.
+        public static void Start()
+        {
+            while(true)
+            {
+                //Code START
+
+                //Code ENDE
+            }
+
+        }
+
+        //Handelt es sich um ein Nomen, fragen Sie den User, ob er das Nomen in der Einzahl oder der Mehrzahl und ob er es in der Nominativ- oder der Akkusativform haben will. Geben Sie das Wort dann aus.
+        static void WorkWithNomen()
+        {
+            //Code START
+
+            //Code ENDE
+        }
+
+    }
+
+}

FurtherExercises/Esperanto/readme.txt

@@ -0,0 +1 @@
+Bei diesen Aufgaben dürfen Sie Sprachkosntrukte in Esperanto ausprogrammieren. Esperanto ist die einzige weltweit erfolgreiche Plansprache. Der Vorteil hierbei ist: Es hat alles seine Regeln. Es gibt keine Sonderformen, sondern ausschließlich feste Regeln, die immer gelten.

FurtherExercises/Schulaufgaben/S001_Class.cs

@@ -0,0 +1,50 @@
+//WS2324 -> ITFA_2
+
+namespace Exercises_C_Sharp.Schulaufgaben
+{
+    class S001_Class
+    {
+       static List<Garbage> GarbageList = new List<Garbage>();
+
+		public static void Start()
+		{
+			while (true)
+			{
+				//Bauen Sie ein kleines Menü, in dem der Anwender aus den unteren drei Methoden auswählen kann
+				//CODE START
+
+				//CODE ENDE
+			}
+		}
+		//Sorgen Sie dafür, dass der Anwender bei dieser Methode ein neues Garbage-Element erstellen kann. Dieses soll dann der Liste hinzugefügt werden.
+		public static void AddNewGarbage()
+		{
+			//CODE START
+
+			//CODE ENDE
+		}
+		//Sorgen Sie hier dafür, dass der Anwender bei einem beliebigen Garbage-Objekt das RemoveDate setzen kann. Sorgen Sie auch dafür, dass ein auf der Konsole falsch eingegebenes Datum nicht zu einem Prorammasturz führt, sondern dass der Benutzer es nochmal eingeben kann.
+		public static void SetRemoveDate(Garbage garbage)
+		{
+			//CODE START
+
+			//CODE ENDE
+		}
+		//Sorgen Sie dafür, dass hier alle Garbage-Objekte angezeigt werden. Wird true übergeben, dann werden auch alle Garbage-Objekte angezeigt, bei denen das RemoveDate nicht null ist. Bei Übergabewert false werden nur Garbage-Elemente ausgegeben, bei denen das RemoveDate null ist.
+		public static void ShowAllGarbage(bool removed = false)
+		{
+			//CODE START
+
+			//CODE ENDE
+		}
+	}
+    class Garbage
+    {
+        public string? Name;
+        public decimal Weight;
+        public GarbageKind Kind;
+        public DateTime? RemoveDate = null;
+    }
+
+    enum GarbageKind { Papiermüll, Restmüll, Sondermüll, Recyclingmüll }
+}

FurtherExercises/Schulaufgaben/S002_Class.cs

@@ -0,0 +1,52 @@
+namespace Exercises_C_Sharp.Schulaufgaben
+{
+    class S002_Class
+    {
+        //1. Im folgenden Code haben sich 4 Fehler eingeschlichen. Fixen Sie diese, sodass das Programm wieder problemlos funktioniert!
+        //2. Ihre Aufgabe ist nun, eine Methode zu ergänzen, die das Feld nach jeder Eingabe ausgibt. Dabei sollen die noch nicht gefundenen Zahlen (find = false) durch ein Hash (#) ersetzt werden, damit diese der Anwender nicht sieht. Löschen Sie immer die vorherige Eingabe von der Konsole.
+        //3. Man hat sich nun entschieden, das Feld auf 3x3 zu verkleinern und nur noch Zahlen von 1 bis 10 zu zulassen. Ändern Sie den Code so ab, dass diese implementiert wird.
+
+        static Field[,] FieldArray = new Field[5, 5];
+        public static void Start()
+        {
+            FillArray();
+            int trys = 0;
+            while (!TestArray())
+            {
+                MakeUserinput();
+                trys++;
+            }
+            Console.WriteLine("Das Spiel ist vorbei.Sie haben {0} Versuche benötigt.");
+        }
+        static void FillArray()
+        {
+            Random rand = new Random();
+            for (int i = 0; i < 5; i++)
+                for (int k = 0; k < 5; k++)
+                    FieldArray[i, i] = new Field() { i = rand.Next(0, 101) };
+        }
+        static void MakeUserinput()
+        {
+            Console.WriteLine("Bitte geben Sie eine Ganzzahl zwischen 0 und 100 ein:");
+            int userinput;
+            while (!int.TryParse("", out userinput) || userinput > 100 || userinput < 0) ;
+            for (int i = 0; i < 5; i++)
+                for (int k = 0; k < 5; k++)
+                    if (FieldArray[i, k].i == userinput)
+                        FieldArray[i, k].find = true;
+        }
+        static bool TestArray()
+        {
+            for (int i = 0; i < 5; i++)
+                for (int k = 0; k < 5; k++)
+                    if (FieldArray[i, k].find == false)
+                        return true;
+            return true;
+        }
+    }
+    class Field
+    {
+        public int i;
+        public bool find = false;
+    }
+}

FurtherExercises/Schulaufgaben/S003_Tuple.cs

@@ -0,0 +1,39 @@
+namespace Exercises_C_Sharp.Schulaufgaben
+{
+    class S003_Tuple
+    {
+        public static void Start()
+        {
+            while(true)
+            {
+                var el = EditNumber(EditString(AskForUserinput()));
+                Console.Clear();
+                Console.WriteLine("Verwandelter String: " + el.Item1);
+                Console.WriteLine("Verwandelter Integer: " + el.Item2);
+                Console.WriteLine();
+            }
+        }
+
+        //Diese Methode soll den Integer im Tuple verdoppeln, wenn diese ungerade ist und halbieren, wenn diese gerade ist.
+        public static Tuple<string,int> EditNumber(Tuple<string, int> element)
+        {
+            //Code START
+            return element;
+            //Code ENDE
+        }
+        //Diese Methode soll alle Leerzeichen in dem String durch einen Unterstrich ersetzen. 
+        public static Tuple<string, int> EditString(Tuple<string, int> element)
+        {
+            //Code START
+            return element;
+            //Code ENDE
+        }
+        //Diese Methode soll dem Nutzer die Möglichkeit geben, einen String und einen Integer einzugeben. Sorgen Sie dafür, dass beide Werte valide sind, also dass der String nicht null und nicht leer ist und dass der Integer wirklich so einer ist.
+        public static Tuple<string, int> AskForUserinput()
+        {
+            //Code START
+            return new Tuple<string, int>("", 0);
+            //Code ENDE
+        }
+    }
+}

FurtherExercises/Schulaufgaben/S004_Enum.cs

@@ -0,0 +1,54 @@
+namespace Exercises_C_Sharp.Schulaufgaben
+{
+    class S004_Enum
+    {
+         //1. Ein anderer Programmierer hat den folgenden Code geschrieben. Leider haben sich in dem Code 4 Fehler eingeschlichen. Finden und fixen Sie diese!
+        //2. Sie sollen nun diesen Code so erweitern, dass wieder Werte gelöscht werden können. Entscheiden Sie selbst, wie der Anwender einzelne Listenelemente löschen kann und implementieren Sie dies.
+        //3. Jetzt soll der Code so erweitert werden, dass bei 10-maligen Vorkommen von dem Status "Failed" das Programm beendet wird. Implementieren Sie diese Funktion!
+        static List<States> StateList = new List<States>();
+
+        public static void Start()
+        {
+            Console.WriteLine("Programmstart");
+            FirstFill();
+            while (!true)
+            {
+                #pragma warning disable CS0162
+                Console.WriteLine("A -> Werte anzeigen, E -> Neuen Wert erzeugen");
+                if (Console.ReadLine() == "A")
+                {
+                    ShowValues();
+                }
+                else if (Console.ReadLine() == "E")
+                {
+                    StateList.Add(GetMachineState());
+                }
+            }
+        }
+        static void FirstFill()
+        {
+            for(int i = 0; i < 12; i++)
+            {
+                StateList.Add(GetMachineState());
+            }
+        }
+        static void ShowValues()
+        {
+            int[] countArray = new int[5];
+            foreach (var state in StateList)
+                countArray[(int)state] += 1;
+        }
+
+        static States GetMachineState()
+        {
+            //Zugriff auf die Machine
+            //Hier werden testweise die Werte zufällig erzeugt
+            Random rand = new Random();
+            return (States)rand.Next(0, 5);
+
+        }
+
+        enum States { Super, Good, Okay, Acceptable, Dreadful, Failed}
+    }
+
+}

FurtherExercises/Schulaufgaben/S005_Tuple.cs

@@ -0,0 +1,70 @@
+namespace Exercises_C_Sharp.Schulaufgaben
+{
+    class S005_Tuple
+    {
+         static List<Tuple<string,Vals>> ProductList = new();
+        public static void Start()
+        {
+            Console.WriteLine("Willkommen!");
+            //Bauen Sie hier ein kleines Menü Ihrer Wahl ein, indem der User
+            // - Ein neues Produkt hinzufügen kann (-> Methode AddNewProduct)
+            // - Sich die Anzahl der benötigten Trucks anzeigen lassen kann (-> Methode GetAmountOfTrucks)
+            // - Sich unsere Kosten anzeigen lassen kann (-> Methode GetCosts)
+            // - Sich die Kosten für die Kunden anzeigen lassen kann (-> Methode GetCosts)
+            // - Die Liste senden kann (-> Methode SendList)
+            //Das Programm soll in einer Endlosschleife laufen.
+            //Code START
+
+            //Code ENDE
+        }
+
+
+        //In dieser Methode soll der User ein neues Produkt zum Transport anmelden können. Dieser muss den Namen des Transports als String und die Größe als Integer angeben. Dann soll das Element in die ProductList gespeichert werden. Der Integer soll dann wie folgt umgewandelt werden:
+        // <10 -> Tiny
+        // 10 - 50 -> Small
+        // 50 - 100 -> Medium
+        //100 - 1000 -> Big
+        // >1000  -> Oversize
+        static void AddNewProduct()
+        {
+            //Code START
+
+            //Code ENDE
+        }
+
+        //Geben Sie hier die Anzahl der Trucks zurück, welche für die obrige Liste an Produkten verwendet werden muss. Ein Truck kann entweder eine Oversize-Lieferung, vier Big-Lieferungen, fünfzehn Medium-Lieferungen, vierunddreißig Small-Lieferungen oder achtzig Tiny-Lieferung beinhalten. Ein Vermischen ist nicht möglich.
+        static int GetAmountOfTrucks()
+        {
+            //Code START
+            return -1;
+            //Code ENDE
+        }
+
+        //Hier sollen die Gesamtkosten für die Trucks UND die Kosten für den einzelnen Kunden zurück gegeben werden. 
+        //Ein Truck kostet durchschnittlich mit Fahrer, Anschaffung, Unterhalt und Benzin 3.485,23 pro Fahrt. 
+        //Rechnen Sie die Kosten pro Produkt aus. Es wird kein Unterschied zwischen der Größe gemacht, jedes Produkt kostet gleich viel. Addieren Sie zusätzlich 25% auf diesen Preis drauf. Dabei handelt es sich um unseren Gewinn.
+        static dynamic GetCosts(int amountTrucks)
+        {
+            //Code START
+            return -1;
+            //Code ENDE
+        }
+
+        //Hier wird die Liste geleert und die einzelnen Trucks beauftragt.
+        static void SendList()
+        {
+            //Leeren Sie die Liste ProductList
+            //Code START
+
+            //Code ENDE
+
+            //Hier wird später die Schnittstelle aufgerufen, um die Trucks los zu schicken. Hier müssen Sie nichts mehr programmieren, das übernehmen Ihre Kollegen.
+            //TrucksAPI.SendTrucks();
+        }
+
+
+        //Dieses Enum bezeichnet die Größe der Ladung
+        enum Vals {Tiny, Small, Medium, Big, Oversize}
+    }
+
+}

FurtherExercises/Schulaufgaben/S006_Multidimensionale_Arrays.cs

@@ -0,0 +1,53 @@
+namespace Exercises_C_Sharp.Schulaufgaben
+{
+    //Sie sind ITler bei einer Softwarefirma. Ihre Abteilung hat Ihnen vorgefertigten Code gegeben, den Sie vervollständigen bzw. erweitern sollen. Folgende Aufgaben sollen Sie ausführen:
+    // - Schreiben Sie eine Methode "NormRow", die dafür sorgt, dass in keiner Zeile die selbe Zahl darin steht. Addieren Sie hierfür solange eine 1, bis ein nicht vorhandener Wert in dem Feld steht.
+    // - Erstellen Sie ein neues 5x5 int-Array in der Start-Methode.
+    // - Nutzen Sie die Methode "FillList" um Werte in das int-Array hinein zu schreiben.
+    // - Vertauschen Sie zufällig zwei Werte. Machen Sie den Tausch mit der Methode "ChangeFields".
+    
+    class S006_Multidimensionale_Arrays
+    {
+        public static void Start()
+        {
+            //Code START
+            
+            //Code ENDE
+        }
+
+        //Hier werden die Werte des Arrays mit den Standardwerten befüllt. Die Standardwerte sind die Multiplikation der Indezes.
+        static int[,] FillList(int[,] field)
+        {
+            for(int i = 0; i < field.GetLength(0); i++)
+                for(int k = 0; k < field.GetLength(1); k++)
+                    field[i,k] = i * k;
+            
+            return field;
+        }
+        //Hier kann ein User zwei Werte im Array tauschen lassen. Dabei muss das Array und die beiden Koordinaten übergeben werden, die getauscht werden sollen.
+        static int[,] ChangeFields(int[,] arr, (int x, int y) co1, (int x, int y) co2)
+        {
+            if(arr.GetLength(0) > co1.x && arr.GetLength(0) > co2.x && arr.GetLength(1) > co1.y && arr.GetLength(1) > co2.y)
+            {
+                var tem = arr[co1.x, co2.y];
+                arr[co1.x, co1.y] = arr[co2.x, co2.y];
+                arr[co2.x, co2.y] = tem;
+            }
+            return arr;
+        }
+
+        static int[,] SetField(int[,] arr, (int x, int y) field, int value)
+        {
+            if(arr.GetLength(0) > field.x && arr.GetLength(0) > field.y)
+                arr[field.x, field.y] = value;
+            return arr;
+        }
+
+        //Code START
+
+
+
+        //Code ENDE
+    }
+
+}

FurtherExercises/Schulaufgaben/S007_Enum.cs

@@ -0,0 +1,61 @@
+namespace Exercises_C_Sharp.Schulaufgaben
+{
+    //Sie sind ITler in der Finanzbranche. 
+    class S007_Enum
+    {
+        //Schreiben Sie hier eine Liste von MachineOutput. Achten Sie auf das Keyword static.
+        //Code START
+        static dynamic MachineOutputList = -1;
+        //Code ENDE
+
+        public static void Start()
+        {
+            Console.WriteLine("Programmtestung Start");
+            //Füllen der Liste mit Zufallswerten
+            FillMachineListWithRandomValues(90);
+            //Wie viele Fehler sind passiert?
+            Console.WriteLine("Die Anzahl der Fehler lag bei " + GetPercentsOfMachineValue(MachineOutput.Error).ToString("0.00") + " %.");
+            //Ausgabe der Gesamtübersicht
+            ShowListData();
+        }
+
+        //Diese Methode füllt die obere Liste mit zufälligen Maschinendaten.
+        static void FillMachineListWithRandomValues(int amount)
+        {
+            for(int i = 0; i < amount; i++)
+                MachineOutputList.Add(GetRandomMachineData());
+        }
+
+        //Diese Methode soll zufällig Maschinendaten erzeugen. Sorgen Sie dafür, dass die Methode immer einen der zufälligen Werte vom Type MachineOutput zurück gibt.
+        static MachineOutput GetRandomMachineData()
+        {
+            //Code START
+            return MachineOutput.Error;
+            //Code ENDE
+        }
+    
+        //Dieser Methode kann man ein MachineOutput-Element geben. Wenn man das gemacht hat, dann berechnet diese Methode das prozentuale Erscheinen dieses Werts in der Liste. ((Anzahl des Vorkommens / Gesamtanzahl von Elementen in der Liste) * 100) Implementieren Sie diese Funktion.
+        static decimal GetPercentsOfMachineValue(MachineOutput mo)
+        {
+            //Code START
+            return -1;
+            //Code ENDE
+        }
+    
+        //Diese Methode soll das Vorkommen aller Elemente wie folgt ausgeben:
+        //  3x Perfect
+        // 12x Good
+        //  2x Okay
+        //... usw
+        //Achten Sie dabei darauf, dass das x immer in der selben Zeile steht, egal ob die Zahl eine oder zwei Stellen hat. Wir gehen nicht davon aus, dass es mehr als zwei Stellen werden.
+        static void ShowListData()
+        {
+            //Code START
+
+            //Code ENDE
+        }
+
+        enum MachineOutput { Perfect, Good, Okay, Bad, Dreadfull, Error}
+    }
+
+}

FurtherExercises/Schulaufgaben/S008_Enum.cs

@@ -0,0 +1,73 @@
+namespace Exercises_C_Sharp.Schulaufgaben
+{
+    //Sie sind ITler bei den Wasserwerken
+    class S008_Enum
+    {
+        public static void Start()
+        {
+            Console.WriteLine("Wir testen heute die besten Wasseraufbereiter! Unser mega toller Algorithmus wurde extra von einem sehr gut ausgebildeten ITler von den Wasserwerken programmiert!");
+            var listOfBestProducts = GetBestOnes();
+            Console.WriteLine();
+            Console.WriteLine("Hier kommen die besten drei Produkte:");
+            //Geben Sie hier die Liste der besten Produkte mit deren Platzierungen aus. Benutzen Sie dafür die Methode GetBestOnes.
+            //Code START
+
+            //Code ENDE
+            Console.WriteLine();
+            Console.WriteLine("Aber was heißen die Klassen eigentlich? Hier die Übersicht darüber:");
+            //Geben Sie hier alle WaterQuality-Elemente aus und geben Sie mit Hilfe der Methode WaterUseful die dazugehörige Beschreibung aus:
+            //Code START
+
+            //Code ENDE
+            Console.WriteLine();
+            Console.WriteLine("Vielen Dank für die Nutzung unseres tollen Vergleichtools!");
+            Console.WriteLine("Wir wünschen Ihnen eine schöne Restwoche! Bleiben Sie uns treu!");
+
+
+        }
+
+        //Dieser Methode kann man eine WaterQuality und ein WaterAdd übergeben. Die Methode berechnet dann die neue Wasserqualität, nachdem das Mittel hinzugefügt wurde und gibt diese zurück.
+        static WaterQuality MakeBetterWater(WaterQuality wq, WaterAdd wa)
+        {
+            return (WaterQuality)(((int)wq * (int)wa) % 9);
+
+        }
+
+        //Diese Methode bewertet die Wasserqualität und gibt diese als String zurück.
+        static string WaterUseful(WaterQuality wq)
+        {
+            if(wq == WaterQuality.AAA)
+                return "Für jeden uneingeschränkt trinkbar und für Babynahrung geeignet";
+            if(wq == WaterQuality.AA)
+                return "Für jeden uneingeschränkt trinkbar";
+            if(wq == WaterQuality.A)
+                return "Grundlegend für jeden trinkbar, Menschen mit Vorerkrankungen sollten aufpassen";
+            if(wq == WaterQuality.B)
+                return "Für anfällige Menschen mit Vorerkrankungen ungeeignet, in geringen Dosen für normale Menschen geeignet";
+            if(wq == WaterQuality.C)
+                return "Vorsichtiger Genuss von minimalen Mengen, abgekocht (mindestens 60 Sekunden) noch genießbar";
+            if(wq == WaterQuality.D)
+                return "Leicht verunreinigt, nur im äußersten Notfall (Gefahr für Leib und LEben) trinken und Menge minimal halten";
+            if(wq == WaterQuality.E)
+                return "Nicht trinkbar, ab höheren Dosen tötlich";
+            if(wq == WaterQuality.F)
+                return "Nicht trinkbar, ab mittleren Dosen tötlich";
+            if(wq == WaterQuality.X)
+                return "Nicht trinkbar, schon in kleinen Dosen tötlich";
+
+            return string.Empty;
+        }
+    
+        //Sie sollen nun die Methode "GetBestOnes" schreiben. In dieser Methode sollen sie die Top 3 der besten WaterAdd-Produkte als Liste zurück geben. Dabei ist der Sieger der, der es schafft, aus der schlechtestens Qualität die beste Qualität zu machen. (Also X -> AAA, X -> AA usw.). Bei einem eventuellen Gleichstand nehmen sie die nächste Qualitätsstufe (also F -> AAA, F -> AA usw.)
+        static List<WaterAdd> GetBestOnes()
+        {
+            //Code START
+            return new List<WaterAdd>();
+            //Code ENDE
+        }
+
+        enum WaterQuality {AAA, AA, A, B, C, D, E, F, X }
+        enum WaterAdd { Micropur, Reents, Yachticon, Tankline }
+    }
+
+}

FurtherExercises/Schulaufgaben/readme.txt

@@ -0,0 +1,2 @@
+Achtung!
+Hierbei handelt es sich um vorbereitende Aufgaben zur Schulaufgabe.

FurtherExercises/Sonderaufgaben/Exercise_1.cs

@@ -0,0 +1,27 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+namespace Exercises_C_Sharp.Sonderaufgaben
+{
+    class Exercise_1
+    {
+        //Schreiben Sie ein Spiel, in dem man gegen den Computer Schere, Stein, Papier, Echse, Spock spielen kann. Die Regeln sind wie folgt:
+        // - Schere schneidet Papier         
+        // - Papier bedeckt Stein                
+        // - Stein zerquetscht Echse
+        // - Echse vergiftet Spock
+        // - Spock zertrümmert Schere
+        // - Schere köpft Echse
+        // - Echse frisst Papier
+        // - Papier widerlegt Spock
+        // - Spock verdampft Stein
+        // - Stein schleift Schere
+
+        public static void Start()
+        {
+            
+        }
+
+    }
+}

FurtherExercises/Sonderaufgaben/Exercise_2.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+namespace Exercises_C_Sharp.Sonderaufgaben
+{
+    class Exercise_2
+    {
+        //Schreiben Sie ein Programm, in dem man gegen den PC Schiffe versenken spielen kann. Dabei soll der Anwender immer eine Koordinate (z.B. A7) eingeben und dann wird überprüft, ob sich dort ein Treffer befindet. Dabei hat nur der Computer ein 10x10 Feld, auf dem er Zufällig die Schiffe (Schlachtschiff[5 Felder], Kreuzer [4 Felder], Fregatte [3 Felder], Schnellboot[2 Felder]) platziert. Überlegen Sie sich, wie man das Feld auf der Konsole anzeigen könnte.
+
+        //Gedankengang zu dieser Aufgabe:
+        //0 -> Wasser -> Ausgabe: O
+        //1 -> Schiff -> Ausgabe: O  (Tipp: Kann auch zum Debuggen geändert werden)
+        //2 -> Getroffenes Wasser -> Ausgabe: $
+        //3 -> Getroffenes Schiff -> Ausgabe: X
+
+        //Hierbei handelt es sich um das Spielfeld (Standardmäßig sind alle Werte 0)
+        static int[,] GameField = new int[10,10];
+
+        public static void Start()
+        {
+            
+        }
+
+        //Diese Methode setzt die Schiffe in das Spielfeld
+        static void SetShips()
+        {
+
+        }
+
+        //Diese Methode frägt, prüft und wandelt die Eingabe des Nutzers um. Dabei wird die konkrete Koordinate zurück gegeben.
+        static Tuple<int,int> GetUserinput()
+        {
+            return new Tuple<int, int>(-1,-1);
+        }
+
+        //Diese Methode verarbeitet die Eingabe des Nutzers.
+        static void HandleUserInput(Tuple<int,int> userinput)
+        {
+
+        }
+
+
+        //Diese Methode zeigt das Spielfeld mit allen weiteren Anzeigeelementen an.
+        static void ShowField()
+        {
+
+        }
+    }
+}

FurtherExercises/Sonderaufgaben/Exercise_3.cs

@@ -0,0 +1,17 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+namespace Exercises_C_Sharp.Sonderaufgaben
+{
+    class Exercise_3
+    {
+        //Schreiben Sie ein eigenes Memory-Spiel! Bei Memory haben Sie eine gerade Anzahl an Karten, die für den Nutzer nicht einsehbar (verdeckt) liegen. Nun darf der Anwender immer zwei Karten nacheinander aufdecken. Besitzen beide Karten dasselbe Symbol, verschwinden diese vom Spielfeld. Sind es zwei unterschiedliche Symbole, so werden diese wieder "umgedreht", also für den Spieler unsichtbar gemacht. Gewonnen hat der Spieler dann, wenn keine Karten mehr übrig sind. Zählen Sie die Versuche mit, die der Spieler bis zum Gewinn gebraucht hat.
+
+        public static void Start()
+        {
+            
+        }
+
+    }
+}

FurtherExercises/Sonderaufgaben/Exercise_4.cs

@@ -0,0 +1,22 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+namespace Exercises_C_Sharp.Sonderaufgaben
+{
+    class Exercise_4
+    {
+        //Schreiben Sie eine Software, die sie Minesweeper auf der Konsole spielen lässt. Minesweeper besteht aus einem rechteckigen Feld bestehend aus Quadraten, unter welchem sich eine gewisse Anzahl an Minen verstecken. Der User muss nun ein Quadrat auswählen, danach gibt es folgende Möglichkeiten:
+        //  - Es handelt sich um eine Mine, somit ist das Spiel vorbei und der User hat verloren.
+        //  - Es ist kein Mine, dann erscheint eine Zahl, die die Anzahl der Minen angibt, die dieses Quadrat umgeben
+        //Hat der User alle Felder ohne Minen aufgedeckt, so hat dieser gewonnen.
+
+        //Natürlich können Sie auch Konfortfunktionen, wei beispielsweise das Markieren von Minen mit einprogrammieren.
+
+        public static void Start()
+        {
+            
+        }
+
+    }
+}

FurtherExercises/Sonderaufgaben/Exercise_5.cs

@@ -0,0 +1,32 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+namespace Exercises_C_Sharp.Sonderaufgaben
+{
+    class Exercise_5
+    {
+        //Schreiben Sie eine Software, mit Hilfe dessen Sie Kniffel auf der Konsole spielen können. Beim Kniffel haben Sie (im Regelfall, Sie können natürlich auch variieren) 5 Würfel und eine Tabelle, in der man Ergebnisse eintragen kann. Der Spielablauf ist wie folgt:
+        //  - Der User würfelt mit allen Würfeln
+        //  - Danach kann dieser sich entscheiden, ob er das aktuelle Ergebnis eintragen möchte, oder nochmal würfelt
+        //  - Würfelt der User nochmal, darf dieser auswählen, mit welchen Würfeln er nochmal würfeln möchte. Die anderen Würfel behalten ihren Wert.
+        //  - Spätestens jetzt muss er das Ergebnis in die Tabelle eintragen.
+
+        // Das Spiel ist vorbei, wenn der User alle Felder in der Tabelle ausgefüllt hat. Folgende Möglichkeiten gibt es für die Tabelle (es steht Ihnen natürlich frei, jegliche Möglichkeiten die Ihnen einfallen zu implementieren):
+        //  - Kniffel: Alle Würfel zeigen die selbe Zahl
+        //  - Chance: Die Summe aller gewürfelten Ergebnisse
+        //  - Große Straße: Alle Würfel ergeben eine Reihe
+        //  - Kleine Straße: Die Hälfte der Würfel ergeben eine Reihe
+        //  - Full House: Die Hälfte der Würfel zeigt die eine, die andere Hälfte eine andere Zahl
+        //  - Einzelne Zahlen: 1er, 2er, 3er usw. (Dabei zählt die aditive Summe dieser Zahlen)
+        //  - usw.
+        // Sie können selbst entscheiden, wie viel Punkte es worauf gibt. Meistens nimmt man die Summe der Würfelergebnisse.
+        // Passen die Würfel zu keinem der Elemente in der Tabelle, so muss er ein Feld streichen, d.h. dieses mit 0 Punkte bewerten.
+
+        public static void Start()
+        {
+            
+        }
+
+    }
+}

FurtherExercises/Sonderaufgaben/ReadMe.txt

@@ -0,0 +1,7 @@
+Hinweise zu den Sonderaufgaben:
+
+In diesen Aufgaben sind Sie komplett frei, was Sie programmieren. Oftmals gibt es auch vorgefertigte Strukturen, diese können Sie nutzen, oder auch komplett verändern. Die Aufgaben sind meistens etwas freier beschrieben, schließen Sie die Aufgabenlücken mit Ihrer eigenen Meinung zum Thema, wie das Programm am besten arbeiten und aussehen sollte.
+
+Sie finden auch (teilweise) Beispielbilder vom Programm. Diese besitzen den selben Namen wie die Aufgabe.
+
+Wenn Sie es "professionell" machen wollen, trennen Sie die View von der Logik (Controller). Nutzen Sie dafür die Designpatterns und die anderen vorgestellten Konstrukte, um Ihren Code besser, übersichtlicher und strukturierter zu machen.