C# OOP [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== C# OOP ======

===== Quellen =====

   * [[http://openbook.rheinwerk-verlag.de/visual_csharp_2012/|Gratis E-Book, etwas alt (2012) aber trotzdem gut]]
   * [[https://www.tutorialspoint.com/csharp/index.htm]]

===== Auftrag in Kürze =====

Erstelle eine *Vector* Klasse, mit der du Vektorrechnungen durchführen kannst.

Lerne anhand dieses Beispiels die Grundlagen von OOP in C#.

===== Auftrag im Detail =====


[[https://www.youtube.com/watch?v=A05n32Bl0aY|Despicable Me: Vector]]


   1. Erstelle ein neues **C#-Konsolen-Programm**. Nenne es z.B. *MathVector*\\ \\
   1. Erstelle darin eine **neue Klasse** *Vector* in einem neuen File (pro Klasse ein .cs File). Klicke dazu im Projektmappen-Explorer mit rechts auf den Namen der Solution -> Hinzufügen -> Klasse\\ \\
   1. Erstelle einen **Konstruktor** in der Vector-Klasse. Shortcut: ctor + TAB.\\ \\
   1. Ein Vector soll dann in *Program.cs* mithilfe eines Double-Arrays definiert werden können: `Vector v = new Vector(new double[] { 1, 2, 3 });`\\ \\
   1. Ein Vektor hat **Eigenschaften** wie seine Dimension (Anzahl Zahlen, aus dem er besteht) oder seine Länge/Magnitude. Ist `v` ein Vektor, so soll z.B. über `v.Magnitude` auf diese Eigenschaft zugegriffen werden. Informiere dich darüber, was **Eigenschaften und Felder**, sowie **getter und setter** in C# sind. Schaue dir dazu z.B. folgende Quellen an:
      1. [[https://docs.microsoft.com/de-de/dotnet/csharp/programming-guide/classes-and-structs/fields#:~:text=Ein%20Feld%20ist%20eine%20Variable,members%20of%20their%20containing%20type|Beispiel Felder (fields) und Eigenschaften (Properties)]]
      1. [[https://www.youtube.com/watch?v=puf8z--uDp8|Eigenschaften (Achtung: Variablen = Felder)]]
      1. [[https://www.youtube.com/watch?v=qXj4B4l92_A|Getter und Setter]]\\ \\
   1. Programmiere nun den Konstruktor aus: Speichere die dem Konstruktor übergebenen Werte in einem *privaten* Feld `components`, ein Double-Array, welches die Komponenten des Vektors beinhaltet. Regle über eine Eigenschaft (get/set) `Components` den Zugriff auf `components`. Sinn könnte machen:
      1. Die Komponenten sind unveränderbar.
      1. Die Komponenten sind nur veränderbar, wenn sie die gleiche Dimension haben (benötigt `Dim` von unten).\\ \\
   1. Füge nun deiner Vector-Klasse die **Eigenschaften** `Dim` (für Dimension) und `Magnitude`. Diese sollen über eine Eigenschaft (get) abgerufen werden. Natürlich sollen sie //nicht von aussen über einen setter verändert// werden können!\\ \\
   1. Informiere dich nun über **statische und nicht-statische Methoden**, z.B. hier; [[https://www.youtube.com/watch?v=PhvjwmkVEfg|Methoden in Klassen]]\\ \\ 
   1. Füge deiner Klasse folgende (nicht-statische) public **Methoden** hinzu: `IsZeroVector()` und `IsUnitVector()`. Diese geben den Bool true oder false zurück, je nachdem ob es sich beim Vektor um einen Nullvektor oder einen Einheitsvektor (unit vector) handelt.\\ Achtung: Da wir mit doubles Arbeiten, können schnell Rundungsfehler entstehen. Es kann deshalb sein, dass die Länge des Vektors eigentlich $0$ wäre, der Code aber eine ganz kleine Zahl berechnet. Deshalb sollte man der Klasse eine Eigenschaft `accuracy` geben: Ist der Betrag des Werts kleiner dieser Genauigkeit, so wird der Wert als $0$betrachtet.\\ \\
   1. Nun wollen wir mit den Vektoren **Rechnen** können. Dazu fügen wir drei **statische Methoden** mit den Namen *Add, Sub* und *ScalarProd* für die Vektoraddition, Vektorsubtraktion und das Skalarprodukt hinzu. Über `Vector.Add(v1,v2);` soll man dann die Vektorsumme zweier Vektoren berechnen können.\\ \\
   1. Die beiden Rechenmethoden vom letzten Punkt sollen können nur Funktionieren, wenn beide Vektoren, die als Argument übergeben werden, die gleiche Dimension haben. Überprüfe dies und gib gegebenenfalls einen **Fehler** aus: `throw new System.Exception("...");`\\ \\
   1. Nun wollen wir aber nicht immer `Vector.Sub(v1,v2);` schreiben müssen, um zwei Vektoren zu Subtrahieren. Stattdessen soll das mit dem Operator `-`, also `v1-v2`, gehen. Dies geht ganz einfach mit einem **Operator Overloading**, siehe z.B. hier: [[https://www.tutorialspoint.com/csharp/csharp_operator_overloading.htm|C# - Operator Overloading]]. Füge nun jeweils ein Operator Overloading für die Operatoren + (Vektoraddition), - (Vektorsubtraktion) und * (Skalarprodukt) hinzu.\\ \\
   1. Aktuell gibt der Befehl `System.Console.WriteLine(v);` für einen Vektor `v` nur "Vector" aus. Schön wäre aber, wenn man direkt die Komponenten erhalten würde: Jede Klasse in C# erbt automatisch von der Basisklasse `object`, und `object` definiert die Methode `ToString()`. Wenn man also `Console.WriteLine(anyObject)` aufrufst, wird intern `anyObject.ToString()` verwendet, ganz egal was `anyObject` für ein Objekt ist. Mit `public override string ToString()` können wir nun diese standardmässige Methode **überschreiben**.\\ \\
   1. Über eine Eigenschaft soll von einem Vektor der zugehörige **Einheitsvektor** ausgegeben werden: `v.UnitVector`. Dieser Einheitsvektor soll *selbst wieder vom Typ Vector* sein! Um von einem Vektor den zugehörigen Einheitsvektor zu erhalten, dividiert man jede Komponente des Vektors durch die Länge des gesamten Vektors. *Tipp:* Überlege dir gut, *wo* genau der Einheitsvektor berechnet werden soll!\\ \\
   1. Es ist etwas umständlich, für neue Vektoren immer zuerst ein double-Array erstellen zu müssen. Stattdessen wollen wir die gängigsten Vektoren (sagen wir 1-4D) auch durch `Vector v = new Vector(3.2,0,4)` erzeugen. Dafür müssen wir den Konstruktor **überladen**, in dem wir 'weitere Konstruktoren' wie `public Vector(double x, double y, double z)` hinzufügen.\\ \\
   1. Erweitere nun deine Klasse beliebig. Hier einige Vorschläge:
      1. Weiter Operationen:
        1. `DotProduct`
        1. `ScalarMultiplication` (überladen, damit `ScalarMultiplication(3,v)` und `ScalarMultiplication(v,3)` funktionieren.
        1. `VectorProduct` (nur für 3D Vektoren)
      1. Winkel zwischen zwei Vektoren: `AngleInRad` , `AngleInRad`
      1. Zwei Vektoren vergleichen: `ArePerpendicular`,`AreParallel`,`AreAntiParallel`,`HaveSameMagnitude`\\ \\
   1. **Operatoren überladen**: Mit `v1 + v2` soll man zwei Vektoren addieren können. Der Operator `+` muss dazu überladen werden: Wird `+` auf zwei Vektoren angewendet, soll die `Add`-Methode aufgerufen werden. Gleiches für `v1 * v2` (dot product) und `s * v` resp. `v * s` (scalar multiplication).\\ \\
   1. **Optional:** Falls du sehr motiviert bist, könntest du eine Klasse *Matrix* definieren, mit der man Matrizen-Rechnungen durchführen kann. Matrizen können als Verallgemeinerungen von Vektoren betrachtet werden.