Unterricht + Übung Tag 4

.kdev4/wbs-csharp.kdev4

@@ -1,5 +0,0 @@
-[Buildset]
-BuildItems=@Variant(\x00\x00\x00\t\x00\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x00\x01\x00\x00\x00\x14\x00w\x00b\x00s\x00-\x00c\x00s\x00h\x00a\x00r\x00p)
-
-[Project]
-VersionControlSupport=kdevgit

Tag 4/Aufgaben/Aufgabe_1.cs

@@ -0,0 +1,9 @@
+namespace Tag_4_Aufgaben;
+
+public class Aufgabe_1
+{
+	public static void Main()
+	{
+		
+	}
+}

Tag 4/Aufgaben/Program.cs

@@ -1,2 +1,3 @@
-// See https://aka.ms/new-console-template for more information
-Console.WriteLine("Hello, World!");
+using Tag_4_Aufgaben;
+
+Aufgabe_1.Main();

Tag 4/Delegates/Button.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace _15_Delegates
+{
+    // Publisher des Events / Observable
+    internal class Button
+    {
+        public event EventHandler? OnClick; // Um ein Event zu deklarieren wird das 'event'-Schlüsselwort verwendet.
+
+        public string Text { get; set; }
+
+        // Wird auf einen Button geklickt, wird diese Methode ausgeführt:
+        public void Click()
+        {
+            Console.WriteLine("Es wurde auf den Button geklickt...");
+            OnClick?.Invoke(this, EventArgs.Empty); // Das Event wird nach einer Prüfung auf Null mit Invoke() ausgelöst.
+            // Eine Null-Prüfung ist bei Events wichtig, da es sonst zu NullReferenceExceptions kommen kann.
+        }
+    }
+}

Tag 4/Delegates/Delegates.cs

@@ -0,0 +1,96 @@
+using System;
+
+namespace _15_Delegates;
+
+// C# hat für Lambda-Ausdrücke und Methodenreferenzen ein eigenes Konzept: Die Delegates.
+// Das Prinzip dahinter ist ähnlich den "functional Interfaces".
+
+public delegate int Vergleich(int a, int b); // Hier erstellen wir einen neuen Datentypen 'Vergleich', welcher nun int-Methoden mit zwei int-Parametern annehmen kann. Einer Variable dieses Datentyps können wir alle Methoden zuweisen, deren Methodensignatur zum Delegaten passt. Für die Signatur ist wichtig: Rückgabetyp und Parametertypen und -anzahl.
+
+
+internal class Delegates
+{
+    public static void Main(string[] args)
+    {
+        // Mit dem Delegate-Datentypen erzeugen wir eine Variable, der wir einen Lambda-Ausdruck zuweisen.
+        // Der Lambda-Ausdruck ist hier eine anonyme Methode, die festlegt, wie die Sortierreihenfolge eines Sortieralgorithmus sein soll.
+        // Siehe: CompareTo()-Methode
+        Vergleich v = (x, y) =>
+        {
+            if (x > y)
+                return 1;
+            else if (y > x)
+                return -1;
+            else 
+                return 0;
+        };
+
+        int[] array = { 9, 1, 8, 2, 7, 3, 6, 4, 5 };
+
+        BubbleSort(array, v);
+        Console.WriteLine(String.Join(", ", array));
+
+        // Vordefinierte Delegates in C# sind unter anderem:
+        Action<int> action; // Void-Methode mit bis zu 16 Parametern. (Vergleich zum Consumer in Java)
+        Func<int, double> func; // Methode mit beliebigem Return-Typ und bis zu 16 Parametern. (Vergleich zum Function-Interface in Java)
+        Predicate<int> predicate; // Boolean-Methode mit einem Parameter. (Wie Predicate in Java)
+        Comparison<string> comparison; // Integer-Methode mit zwei Parametern vom selben Typ. (Wie Comparator in Java)
+
+        EventHandler eventHandler; // Wird für Events verwendet (Observer Pattern).
+
+        // Beispiel für Events:
+        Button b = new Button();
+        b.Text = "Ich bin ein Button";
+
+        b.OnClick += ButtonClicked; // Das Event wird durch += abonniert. Hier wird dem Delegaten die Referenz auf die ButtonClicked()-Methode zugewiesen.
+        b.OnClick += ButtonClicked;
+        b.OnClick -= ButtonClicked; // Mit -= können Events wieder de-abonniert werden.
+        b.OnClick += (s, e) => Console.WriteLine("Über Lambda-Ausdruck");
+        
+        b.Click(); // Auf den Button klicken...
+
+
+        // Multicast:
+        Action<string> a;
+        a = Console.WriteLine;
+        a += (s) => Console.WriteLine(s.ToUpper());
+        a += (s) => Console.WriteLine(s.Substring(0, s.Length / 2));
+
+        a.Invoke("Hallo, Welt!"); // Alle zugewiesenen Methoden werden nacheinander aufgerufen.
+
+        Delegate[] invocationList = a.GetInvocationList();
+        invocationList[1].DynamicInvoke("Dynamisch aufgerufen");
+    }
+
+    //Ein Sortieralgorithmus, bei dem durch Übergabe des Delegates bestimmt wird, wie sortiert werden soll (Aufsteigend oder Absteigend)
+    public static void BubbleSort(int[] array, Vergleich vergleich)
+    {
+        if (vergleich == null) // Wir prüfen zuerst, ob überhaupt eine Methode übergeben wurde...
+            return;
+
+
+        for (int i = 0; i < array.Length; i++)
+        {
+            for (int j = 0; j < array.Length - 1 - i; j++)
+            {
+                if (vergleich(array[j], array[j + 1]) == 1) // Aufruf der Methode im Delegate. Dazu können wir den Delegate wie eine Methode verwenden.
+                {
+                    // Zwei Elemente tauschen:
+                    /*int temp = array[j];
+                    array[j] = array[j + 1];
+                    array[j + 1] = temp;*/
+
+                    // Der Tausch von zwei Variablen in einem Schritt über Tupel:
+                    (array[j], array[j + 1]) = (array[j + 1], array[j]);
+                }
+            }
+        }
+    }
+
+    // EventHandler-Methode: Diese muss zur Signatur des EventHandler-Delegaten passen.
+    public static void ButtonClicked(object? sender, EventArgs e)
+    {
+        Console.WriteLine((sender as Button)?.Text);
+        Console.WriteLine("Der Klick wurde verarbeitet...");
+    }
+}

Tag 4/Handout/Delegates.md

@@ -0,0 +1,277 @@
+# Delegates und Events in C#
+
+## Ziel dieser Einheit
+
+In dieser Einheit lernst du:
+
+- was Delegates sind  
+- wie Lambda-Ausdrücke in C# funktionieren  
+- wie Delegates in der Praxis eingesetzt werden  
+- was Events sind und wie sie funktionieren  
+- wie mehrere Methoden kombiniert werden können  
+
+---
+
+## 1. Grundidee: Delegates
+
+Delegates sind Datentypen, die Methoden speichern können.
+
+Man kann sich einen Delegate vorstellen wie:
+- eine Variable für Methoden  
+- eine Referenz auf eine Funktion  
+
+Ähnlich zu:
+- Functional Interfaces in Java  
+
+---
+
+## 2. Definition eines Delegates
+
+    public delegate int Vergleich(int a, int b);
+
+Erläuterung:
+
+- neuer Datentyp: Vergleich  
+- speichert Methoden mit:
+  - Rückgabewert: int  
+  - zwei Parametern vom Typ int  
+
+Wichtig:
+- Signatur muss genau passen  
+
+---
+
+## 3. Verwendung mit Lambda-Ausdruck
+
+    Vergleich v = (x, y) =>
+    {
+        if (x > y)
+            return 1;
+        else if (y > x)
+            return -1;
+        else 
+            return 0;
+    };
+
+Erläuterung:
+
+- Lambda-Ausdruck = anonyme Methode  
+- definiert das Verhalten direkt im Code  
+
+---
+
+## 4. Praxisbeispiel: Sortieren mit Delegate
+
+    int[] array = { 9, 1, 8, 2, 7, 3, 6, 4, 5 };
+
+    BubbleSort(array, v);
+
+---
+
+### Methode BubbleSort
+
+    public static void BubbleSort(int[] array, Vergleich vergleich)
+
+Erläuterung:
+
+- Delegate bestimmt die Sortierlogik  
+- flexibel (z.B. aufsteigend / absteigend)  
+
+---
+
+### Aufruf des Delegates
+
+    if (vergleich(array[j], array[j + 1]) == 1)
+
+- Delegate wird wie eine Methode verwendet  
+
+---
+
+### Tauschen von Werten
+
+    (array[j], array[j + 1]) = (array[j + 1], array[j]);
+
+- Tupel-Zuweisung  
+
+---
+
+## 5. Vordefinierte Delegates
+
+C# bietet bereits fertige Delegates:
+
+    Action<int> action;
+    Func<int, double> func;
+    Predicate<int> predicate;
+    Comparison<string> comparison;
+
+Erläuterung:
+
+- Action → keine Rückgabe (void)  
+- Func → mit Rückgabewert  
+- Predicate → bool  
+- Comparison → Vergleich  
+
+---
+
+## 6. Events – Grundidee
+
+Events werden verwendet, um auf Ereignisse zu reagieren.
+
+Beispiel:
+- Button wird geklickt  
+- Methode wird ausgelöst  
+
+Pattern:
+- Publisher (sendet Ereignis)  
+- Subscriber (reagiert darauf)  
+
+---
+
+## 7. Die Button-Klasse
+
+    internal class Button
+    {
+        public event EventHandler? OnClick;
+
+        public string Text { get; set; }
+
+        public void Click()
+        {
+            Console.WriteLine("Es wurde auf den Button geklickt...");
+            OnClick?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+---
+
+### Erläuterung
+
+- event → Event deklarieren  
+- EventHandler → Delegate  
+- Invoke() → Event auslösen  
+
+Wichtig:
+
+- Null-Prüfung ist notwendig  
+- sonst NullReferenceException  
+
+---
+
+## 8. Event abonnieren
+
+    Button b = new Button();
+    b.Text = "Ich bin ein Button";
+
+    b.OnClick += ButtonClicked;
+    b.OnClick += ButtonClicked;
+    b.OnClick -= ButtonClicked;
+
+---
+
+### Erläuterung
+
+- += → hinzufügen  
+- -= → entfernen  
+
+---
+
+## 9. Lambda als Event-Handler
+
+    b.OnClick += (s, e) => Console.WriteLine("Über Lambda-Ausdruck");
+
+---
+
+## 10. Event auslösen
+
+    b.Click();
+
+---
+
+## 11. Event-Handler-Methode
+
+    public static void ButtonClicked(object? sender, EventArgs e)
+    {
+        Console.WriteLine((sender as Button)?.Text);
+        Console.WriteLine("Der Klick wurde verarbeitet...");
+    }
+
+---
+
+### Erläuterung
+
+- muss zur Delegate-Signatur passen  
+- sender enthält die Quelle des Events  
+
+---
+
+## 12. Multicast-Delegates
+
+    Action<string> a;
+
+    a = Console.WriteLine;
+    a += (s) => Console.WriteLine(s.ToUpper());
+    a += (s) => Console.WriteLine(s.Substring(0, s.Length / 2));
+
+---
+
+### Aufruf
+
+    a.Invoke("Hallo, Welt!");
+
+---
+
+### Erläuterung
+
+- mehrere Methoden werden hintereinander ausgeführt  
+
+---
+
+## 13. Zugriff auf einzelne Methoden
+
+    Delegate[] invocationList = a.GetInvocationList();
+    invocationList[1].DynamicInvoke("Dynamisch aufgerufen");
+
+---
+
+## 14. Zentrale Konzepte im Überblick
+
+### Delegate
+- speichert Methoden  
+- ermöglicht flexible Programmierung  
+
+---
+
+### Lambda-Ausdruck
+- anonyme Funktion  
+- direkt im Code definiert  
+
+---
+
+### Event
+- wendet Delegates an  
+- reagiert auf Ereignisse  
+
+---
+
+### Multicast
+- mehrere Methoden gleichzeitig ausführen  
+
+---
+
+## Zusammenfassung
+
+- Delegates sind Methoden-Referenzen  
+- Lambda-Ausdrücke definieren Verhalten  
+- Delegates machen Code flexibel  
+- Events nutzen Delegates zur Kommunikation  
+- Multicast erlaubt mehrere Methoden gleichzeitig  
+
+---
+
+## Verständnisfragen
+
+- Was ist ein Delegate?  
+- Warum müssen Signaturen übereinstimmen?  
+- Was ist der Unterschied zwischen Action und Func?  
+- Wie funktioniert ein Event?  
+- Warum ist die Null-Prüfung bei Events wichtig?  

Tag 4/Tag_09_Unterrichtsmitschriften/Tag_09_MethodenReferenzen.cs

@@ -0,0 +1,71 @@
+namespace OP6_78_FIAE1;
+
+public class Tag_09_MethodenReferenzen
+{
+    public static void Main()
+    {
+        var auto1 = new Auto();
+        auto1.fahren();
+        
+        // --- Action:
+
+        // Variable, die etwas speichert, was ein Auto braucht und etwas (void) tut.
+        Action<Auto> fahren = (Auto auto) => { Console.WriteLine("Fahren mit " + auto.geschwindigkeit + " kmh!"); };
+        //Kann ausgeführt werden, so wie wir es von Methoden kennen:
+        fahren(auto1);
+
+        // Neu zuweisen der Variable
+        auto1.fahren = () =>
+        {
+            Console.WriteLine("Ruckel, ruckel, Motorprobleme!!!");
+        };
+        auto1.fahren();
+        
+        var auto2 = new Auto();
+        auto2.fahren = auto1.fahren; // Neu zuweisen der Variable von einer anderen Methoden-Referenz
+        
+        auto2.fahren();
+        
+        // --- Func:
+
+        var leuchten = (Auto auto) =>
+        {
+            return auto.leuchtFarbe + "es Licht";
+        };
+        
+        var ergebnis = leuchten(auto2);
+        Console.WriteLine(ergebnis);
+        
+        ergebnis = auto2.leuchten();
+        Console.WriteLine(ergebnis);
+    }
+
+    class Auto
+    {
+        public int geschwindigkeit = 100;
+        public Action fahren; //Action -> keine Parameter und kein Rückgabewert
+        //Action<param1, ...paramX> -> kein Rückgabewert
+        
+        public string leuchtFarbe = "Rot";
+        public Func<string> leuchten; // Func <param1, ...paramX, returnValue>
+
+        public Auto()
+        {
+            geschwindigkeit = 50;
+            fahren = () =>
+            {
+                Console.WriteLine("Fahren mit " + geschwindigkeit + " kmh!");
+            };
+            
+            leuchten = () => {
+                return leuchtFarbe + "es Licht";
+            };
+        }
+
+        // Als normale Methode:
+        // public void fahren()
+        // {
+        //     Console.WriteLine("Fahren mit " + geschwindigkeit + " kmh!");
+        // }
+    }
+}

Tag 4/Tag_09_Unterrichtsmitschriften/Tag_09_Readonly.cs

@@ -0,0 +1,40 @@
+namespace OP6_78_FIAE1;
+
+public class Tag_09_Readonly
+{
+    public static void Main()
+    {
+        var data = new MyData(1);
+        //data.subData = 10; // nicht erlaubt
+        
+        var produkt = new Produkt("p123");
+        //produkt.id = "": // nicht erlaubt
+    }
+
+    class MyData
+    {
+        public const string Greeting = "Hello";
+        public readonly int subData;
+        
+        public MyData(int subData)
+        {
+            this.subData = subData;
+        }
+
+        public void NotAllowed()
+        {
+            //subData = 10;
+        }
+    }
+
+    class Produkt
+    {
+        public readonly string id;
+        public string name;
+
+        public Produkt(string id)
+        {
+            this.id = id;
+        }
+    }
+}

Tag 4/Tag_09_Unterrichtsmitschriften/Tag_09_Sealed.cs

@@ -0,0 +1,33 @@
+namespace OP6_78_FIAE1;
+
+public class Tag_09_Sealed
+{
+    public static void Main()
+    {
+        
+    }
+
+    class Fahrzeug
+    {
+        public virtual void fahren()
+        {
+            Console.WriteLine("Wrooom!");
+        }
+    }
+
+    class Auto : Fahrzeug
+    {
+        public sealed override void fahren()
+        {
+            Console.WriteLine("Brumm!");
+        }
+    }
+
+    class PKW : Auto
+    {
+        // Nicht erlaubt, weil fahren() sealed ist.
+        // public override void fahren()
+        // {
+        // }
+    }
+}

Tag 4/Unterricht/MethodenReferencen.cs

@@ -0,0 +1,36 @@
+namespace Tag_4_Unterricht;
+
+public class MethodenReferenzen
+{
+	public static void Main()
+	{
+		var auto = new Auto();
+
+		auto.fahren();
+
+		var fahren = (Auto auto) => {
+			Console.WriteLine($"Fahren mit {auto.geschwindigkeit} km/h!");
+		};
+
+		fahren(auto);
+
+		auto.fahren = () => {Console.WriteLine("Ruckel, Ruckel, Motorprobleme.");};
+
+		auto.fahren();
+	}
+
+	class Auto
+	{
+		public int geschwindigkeit = 100;
+		public Action fahren;
+
+		public Auto()
+		{
+			geschwindigkeit = 50;
+			fahren = () =>
+			{
+				Console.WriteLine($"Fahren mit {geschwindigkeit} km/h!");
+			};
+		}
+	}
+}

Tag 4/Unterricht/Program.cs

@@ -1,2 +1,3 @@
-// See https://aka.ms/new-console-template for more information
-Console.WriteLine("Hello, World!");
+using Tag_4_Unterricht;
+
+MethodenReferenzen.Main();

Tag 4/Unterricht/ReadOnly.cs

@@ -1,11 +1,11 @@
 namespace Tag_4_Unterricht;
 
-public class Sealed
+public class ReadOnly
 {
 	public static void Main()
 	{
 		var data = new MyData(1);
-		data.subData = 10;
+		// data.subData = 10;
 	}
 
 	class MyData
@@ -20,7 +20,7 @@ public class Sealed
 
 		public void NotAllowed()
 		{
-			subData = 10;
+			// subData = 10;
 		}
 	}
 }

Tag 4/Unterricht/Sealed.cs

@@ -0,0 +1,30 @@
+namespace Tag_4_Unterricht;
+
+public class Sealed
+{
+	public static void Main()
+	{
+
+	}
+
+	class Fahrzeug
+	{
+        public virtual void fahren()
+        {
+            Console.WriteLine("Wroom!");
+        }
+	}
+
+    class Auto : Fahrzeug
+    {
+        public sealed override void fahren()
+        {
+            Console.WriteLine("Brumm!");
+        }
+    }
+
+    class PKW : Auto
+    {
+
+    }
+}

Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.CoreCompileInputs.cache

@@ -1 +1 @@
-45392ea676cd60f1efca1256936625614d4506fcf734fc315438d95aa7b4bc99
+e09687c9b7f00a174eaa10132c687ac93b70f4fcbfb7f5c2cbe95049d1bbcbc9

Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.FileListAbsolute.txt

@@ -2,3 +2,13 @@
 /home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.AssemblyInfoInputs.cache
 /home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.AssemblyInfo.cs
 /home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.CoreCompileInputs.cache
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/bin/Debug/net10.0/Unterricht
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/bin/Debug/net10.0/Unterricht.deps.json
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/bin/Debug/net10.0/Unterricht.runtimeconfig.json
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/bin/Debug/net10.0/Unterricht.dll
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/bin/Debug/net10.0/Unterricht.pdb
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.dll
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/obj/Debug/net10.0/refint/Unterricht.dll
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.pdb
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.genruntimeconfig.cache
+/home/max/Dokumente/Umschulung/CSharp/Tag 4/Unterricht/obj/Debug/net10.0/ref/Unterricht.dll

Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.genruntimeconfig.cache

@@ -0,0 +1 @@
+8b60f12dc663d2aa40ccb0fb87cd4c5c604470f96947448f5072bf2ee0bce24f

wbs-csharp.kdev4

@@ -1,4 +0,0 @@
-[Project]
-CreatedFrom=
-Manager=KDevGenericManager
-Name=wbs-csharp