diff --git a/.kdev4/wbs-csharp.kdev4 b/.kdev4/wbs-csharp.kdev4 deleted file mode 100644 index 03a5044..0000000 --- a/.kdev4/wbs-csharp.kdev4 +++ /dev/null @@ -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 diff --git a/Tag 4/Aufgaben/Aufgabe_1.cs b/Tag 4/Aufgaben/Aufgabe_1.cs new file mode 100644 index 0000000..1836183 --- /dev/null +++ b/Tag 4/Aufgaben/Aufgabe_1.cs @@ -0,0 +1,9 @@ +namespace Tag_4_Aufgaben; + +public class Aufgabe_1 +{ + public static void Main() + { + + } +} \ No newline at end of file diff --git a/Tag 4/Aufgaben/Program.cs b/Tag 4/Aufgaben/Program.cs index 3751555..6fa4b1a 100644 --- a/Tag 4/Aufgaben/Program.cs +++ b/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(); \ No newline at end of file diff --git a/Tag 4/Delegates/Button.cs b/Tag 4/Delegates/Button.cs new file mode 100644 index 0000000..8ff0a84 --- /dev/null +++ b/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. + } + } +} \ No newline at end of file diff --git a/Tag 4/Delegates/Delegates.cs b/Tag 4/Delegates/Delegates.cs new file mode 100644 index 0000000..d10f024 --- /dev/null +++ b/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 action; // Void-Methode mit bis zu 16 Parametern. (Vergleich zum Consumer in Java) + Func func; // Methode mit beliebigem Return-Typ und bis zu 16 Parametern. (Vergleich zum Function-Interface in Java) + Predicate predicate; // Boolean-Methode mit einem Parameter. (Wie Predicate in Java) + Comparison 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 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..."); + } +} \ No newline at end of file diff --git a/Tag 4/Handout/Delegates.md b/Tag 4/Handout/Delegates.md new file mode 100644 index 0000000..7c2d8f6 --- /dev/null +++ b/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 action; + Func func; + Predicate predicate; + Comparison 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 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? \ No newline at end of file diff --git a/Tag 4/Tag_09_Unterrichtsmitschriften/Tag_09_MethodenReferenzen.cs b/Tag 4/Tag_09_Unterrichtsmitschriften/Tag_09_MethodenReferenzen.cs new file mode 100644 index 0000000..efeb7d6 --- /dev/null +++ b/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 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 -> kein Rückgabewert + + public string leuchtFarbe = "Rot"; + public Func leuchten; // Func + + 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!"); + // } + } +} \ No newline at end of file diff --git a/Tag 4/Tag_09_Unterrichtsmitschriften/Tag_09_Readonly.cs b/Tag 4/Tag_09_Unterrichtsmitschriften/Tag_09_Readonly.cs new file mode 100644 index 0000000..9a965e0 --- /dev/null +++ b/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; + } + } +} \ No newline at end of file diff --git a/Tag 4/Tag_09_Unterrichtsmitschriften/Tag_09_Sealed.cs b/Tag 4/Tag_09_Unterrichtsmitschriften/Tag_09_Sealed.cs new file mode 100644 index 0000000..41189a5 --- /dev/null +++ b/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() + // { + // } + } +} \ No newline at end of file diff --git a/Tag 4/Unterricht/MethodenReferencen.cs b/Tag 4/Unterricht/MethodenReferencen.cs new file mode 100644 index 0000000..b378a9b --- /dev/null +++ b/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!"); + }; + } + } +} \ No newline at end of file diff --git a/Tag 4/Unterricht/Program.cs b/Tag 4/Unterricht/Program.cs index 3751555..499dd2a 100644 --- a/Tag 4/Unterricht/Program.cs +++ b/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(); \ No newline at end of file diff --git a/Tag 4/Unterricht/sealed.cs b/Tag 4/Unterricht/ReadOnly.cs similarity index 81% rename from Tag 4/Unterricht/sealed.cs rename to Tag 4/Unterricht/ReadOnly.cs index e71e2c6..1f28952 100644 --- a/Tag 4/Unterricht/sealed.cs +++ b/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; } } } \ No newline at end of file diff --git a/Tag 4/Unterricht/Sealed.cs b/Tag 4/Unterricht/Sealed.cs new file mode 100644 index 0000000..c03c91c --- /dev/null +++ b/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 + { + + } +} \ No newline at end of file diff --git a/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.CoreCompileInputs.cache b/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.CoreCompileInputs.cache index 23108ad..8a62c50 100644 --- a/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.CoreCompileInputs.cache +++ b/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.CoreCompileInputs.cache @@ -1 +1 @@ -45392ea676cd60f1efca1256936625614d4506fcf734fc315438d95aa7b4bc99 +e09687c9b7f00a174eaa10132c687ac93b70f4fcbfb7f5c2cbe95049d1bbcbc9 diff --git a/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.FileListAbsolute.txt b/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.FileListAbsolute.txt index abff711..1df5e30 100644 --- a/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.csproj.FileListAbsolute.txt +++ b/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 diff --git a/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.dll b/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.dll new file mode 100644 index 0000000..56ba683 Binary files /dev/null and b/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.dll differ diff --git a/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.genruntimeconfig.cache b/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.genruntimeconfig.cache new file mode 100644 index 0000000..3c7196a --- /dev/null +++ b/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.genruntimeconfig.cache @@ -0,0 +1 @@ +8b60f12dc663d2aa40ccb0fb87cd4c5c604470f96947448f5072bf2ee0bce24f diff --git a/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.pdb b/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.pdb new file mode 100644 index 0000000..e6233c6 Binary files /dev/null and b/Tag 4/Unterricht/obj/Debug/net10.0/Unterricht.pdb differ diff --git a/Tag 4/Unterricht/obj/Debug/net10.0/apphost b/Tag 4/Unterricht/obj/Debug/net10.0/apphost new file mode 100755 index 0000000..c5415af Binary files /dev/null and b/Tag 4/Unterricht/obj/Debug/net10.0/apphost differ diff --git a/Tag 4/Unterricht/obj/Debug/net10.0/ref/Unterricht.dll b/Tag 4/Unterricht/obj/Debug/net10.0/ref/Unterricht.dll new file mode 100644 index 0000000..bb428d0 Binary files /dev/null and b/Tag 4/Unterricht/obj/Debug/net10.0/ref/Unterricht.dll differ diff --git a/Tag 4/Unterricht/obj/Debug/net10.0/refint/Unterricht.dll b/Tag 4/Unterricht/obj/Debug/net10.0/refint/Unterricht.dll new file mode 100644 index 0000000..bb428d0 Binary files /dev/null and b/Tag 4/Unterricht/obj/Debug/net10.0/refint/Unterricht.dll differ diff --git a/wbs-csharp.kdev4 b/wbs-csharp.kdev4 deleted file mode 100644 index 96b8716..0000000 --- a/wbs-csharp.kdev4 +++ /dev/null @@ -1,4 +0,0 @@ -[Project] -CreatedFrom= -Manager=KDevGenericManager -Name=wbs-csharp