Objektorientiertes Programmieren in C#

Slides: siehe Slides OOP in C#

Links:

• https://www.w3schools.com/cs/cs_oop.php
• https://www.youtube.com/watch?v=GAvhe6oe-_4 (und anschliessende Folgen)
• https://www.youtube.com/watch?v=PRLrcXcwVdw (und anschliessende Folgen)
• und weitere 42 Millionen Videos zum Thema

Vektoren sind eine praktische Sache (Tatsache!). Ziel dieses Auftrags ist, eine Vector-Klasse in C# zu implementieren, damit du in deinem C# gut mit vektoriellen Grössen umgehen kannst. Man könnte meinen, dass ein Array bereits so etwas ist wie ein Vektor, allerdings kann man mit diesen nicht rechnen.

1. Erstelle auf GitHub ein Repo CsharpVectorMath (private, gitignore: Visual Studio) und klone es auf deinen Computer.
2. Erstelle darin ein C#-Projekt VectorMath.
3. Erstelle darin eine Klasse Vector:
   1. wichtig in C#: jede Klasse in eigenem File!
   2. Name der Klasse soll genau zu den davon erzeugten Objekten passen, deshalb Vector und nicht z.B. Vectors (ein Objekt dieser Klasse ist ein einzelner Vektor.
   3. neue Klasse: Projektmappe → Rechte Maustaste auf Projekt → Hinzufügen → Neue Klasse
4. Informiere dich darüber, was der Konstruktor ist und wozu dieser gut ist.
5. Erstelle den Konstruktor für die Klasse. Diesem soll ein double-Array übergeben werden, welches dann in einer Eigenschaft Components gespeichert wird.
6. In der Main-Methode (in Program.cs) sollte man jetzt Objekte der Vector-Klasse erstellen können:

Vector v = new Vector(new double[] { 3.0, -7.0, 42.0 });

1. Informiere dich darüber, was die Eigenschaften einer Klasse sind und wozu, wann und wie man getter und setter verwendet.
2. Implementiere (über getter) die Eigenschaften unten. Achte darauf, dass es nicht möglich ist, diese Werte von Hand zu setzen. Stattdessen sollen sie jedesmal aus den Komponenten bestimmt werden.
   1. Dimension gibt Dimension des Vektors an, also z.B. 3 für einen Vektor mit drei Komponenten
   2. Magnitude gibt Länge des Vektors an
   3. UnitVector gibt den zugehörigen Einheitsvektor (wieder ein Vektor!!!) an. Erinnerung: Einheitsvektor zeigt in gleiche Richtung, hat aber Länge $1$.
   4. IsZeroVector gibt true (false) zurück, wenn Vektor (nicht) ein Nullvektor ist. Achtung: Doubles sind auf etwa $16$ Stellen genau, d.h. sehr kleine Zahlen $<10^{-15}$ sollte man auch als $0$ interpretieren. Definiere dazu ein private Feld (z.B. _accuracy, Underline weil private) die die Genauigkeit festlegt.
   5. IsUnitVector gibt true (false) zurück, wenn Vektor (nicht) ein Einheitsvektor ist. Beachte wieder, dass doubles ungenau sind.

1. Informiere dich darüber, was die Methoden einer Klasse sind und wie man sie implementiert. Finde weiter heraus, wie man eine Ausnahme ausgelöst (Exception handling) kann (throw new Exception(...)).
2. Implementiere die Vektoraddition, Vektorsubtraktion und das Skalarprodukt (dot product) in den Methoden Add, Sub und DotProduct. Diesen Methoden wird jeweils ein Vektor übergeben und mit diesem wird dann die entsprechende Operation ausgeführt. Mit Vector vSum = v1.Add(v2) soll man dann die Vektorsumme der beiden Vektoren v1 und v2 bestimmen und in einem neuen Vektor vSum speichern können. Die Methoden sollen natürlich die passenden Rückgabetypen haben. Achte darauf, dass diese Operationen nur durchgeführt werden können, wenn beide Vektoren die gleiche Dimension haben. Ansonsten soll eine Ausnahme/Exception ausgelöst werden.
3. Implementiere weiter die skalare Multiplikation (ScalarMultiplication()), mit der ein Vektor mit einer Zahl (double) multipliziert wird. Damit kann man einen Vektor skalieren also seine Länge ändern, ohne dass seine Richtung geändert wird. Ausnahme: entgegengesetzte Richtung bei Multiplikation mit negativen Zahlen.

Im Code unten werden drei Methoden mit dem gleichen Namen SayHi definiert. Die drei Funktionen nehmen aber unterschiedliche Argumente entgegen. Rufe ich SayHi("Fritz") auf, so erkennt C# anhand des Arguments, dass die mittlere Funktion gemeint ist und führt diese entsprechend aus. Dies nennt man eine Überladung von Methoden.

public static void SayHi()
{
    Console.WriteLine("Hi, person with no name!");
}
 
public static void SayHi(string name)
{
    Console.WriteLine("Hi, person with name " + name);
}
 
public static void SayHi(int nr)
{
    Console.WriteLine("Hi, person with number " + nr);
}

1. Überlade nun den Konstruktor: Einmal soll diesem nur das Double-Array übergeben werden. Einmal soll zusätzlich ein Wert für die Genauigkeit übergeben werden.
2. Die Genauigkeit soll auch im Nachhinein angepasst werden können, dazu muss diese aber public gemacht werden. Wir wollen aber eine Obergrenze setzen, z.B. soll für die Genauigkeit kein Wert $> 10^{-5}$ (oder was auch immer) gesetzt werden können. Dazu gehen wir wie folgt vor: Wir haben ein privates Feld _accuracy und eine public Eigenschaft Accuracy. Über dessen getter/setter wird der Wert von _accuracy gesetzt, wobei sichergestellt wird, dass ein erlaubter Wert gesetzt wird (Stichword: setter!). Siehe z.B. hier für mehr Infos dazu: https://codeasy.net/lesson/properties
3. In Realität benötigt man meist 2D- und 3D-Vektoren. Daher macht es Sinn, für diese Fälle weitere Überladungen des Konstruktors zu machen: Vecor(3,-42) und Vector(3,-42,7) soll dann einen entsprechenden 2D- resp. 3D-Vektor erzeugen. Die Genauigkeit wird dabei jeweils auf den Standardwert gesetzt.
4. Auch vordefinierte C#-Methoden können überladen werden. Schön wäre doch, wenn man einfach mit Console.Writeline(v) die Komponenten des Vektors schön ausgeben könnte. Console.Writeline ruft jeweils die Klassenmethode ToString() auf. Für gewissen Datentypen wie ints wurde diese Methode implementiert. Deshalb können solche Datentypen mit Console.Writeline angezeigt werden, obwohl sie keine Strings sind - sie werden vor der Anzeige in Strings umgewandelt.

Gegeben seien zwei Vektoren v1 und v2. Möchten wir nun die Vektorsumme der beiden bestimmen, so haben wir zwei Möglichkeiten: v1.Add(v2) oder v2.Add(v1). Im ersten Fall verwenden wir also die Klassenmethode Add des ersten Vektors und übergeben den zweiten Vektor als Argument. Schön wäre aber, wenn wir dies ohne die Klassenmethode machen könnten und einfach Add(v1,v2) schreiben könnten. Eine solche Methode heisst statische Methode. Sie ist objektunabhängig, gehört also nicht direkt zum Objekt. Wir könnten diese neue Add-Methode (Add(v1,v2)) deshalb in der Main-Methode deklarieren, was aber nicht sehr viel Sinn ergibt. Die Methode passt thematisch zur Vector-Klasse, da sie zwei Vektoren entgegennimmt, diese Addiert und dann wieder einen Vector zurückgibt. Deshalb liegt es auf der Hand, diese Methode als statische Methode in der Vector-Klasse zu definieren.

Beachte, dass du dann zwei Vektoren auf drei verschiedene Arten miteinander addieren kannst: v1.Add(v2), v2.Add(v1) und Add(v1,v2). Die drei Methoden heissen zwar immer gleich, es sind aber unterschiedliche Methoden: Im ersten und zweiten Fall handelt es sich um eine Klassenmethode von v1 resp. v2, im dritten Fall um eine statische Methode. Wie oben (Überladung von Methoden) besprochen, erkennt C# aufgrund der Art und Weise, wie die Funktion aufgerufen wird, um welche der drei Möglichkeiten es sich handelt. Man kann also also den gleichen Namen für verschiedene Methoden verwenden.

Tipp: Definiere die statischen Methoden wenn immer möglich durch Klassenmethoden.

1. Implementiere statische Methoden Add(...,...), Sub(...,...), DotProduct(...,...).
2. Implementiere die statische Methode ScalarMultiplication. Diese soll unabhängig der Reihenfolge der Argumente funktionieren ScalarMultiplication(s,v) und ScalarMultiplication(v,s).
3. Implementiere die statische Methode CrossProduct - das Kreuzprodukt oder Vektorprodukt: https://de.wikipedia.org/wiki/Kreuzprodukt#Komponentenweise_Berechnung Beachte, dass dieses (in der Standardform) nur für 3D-Vektoren funktioniert.

Noch praktischer wäre, wenn man einfach v1 + v2 anstelle von Add(v1,v2) schreiben könnte. Dies ist möglich und heisst Überladung von Operatoren: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading Implementiere diese Überladungen so dass man einfach kann:

1. addieren & subtrahieren: v1 + v2 und v1 - v2
2. Vektoren mit Vorzeichen: +v und -v
3. Multiplizieren: v1*v2 ist Skalarprodukt (dot product) und s*v und v*s sind skalare Multiplikation (ScalarMultiplication)

Implementiere die folgenden, nützlichen Methoden für Vektoren.

Tipps:

• Verwende wann immer möglich bereits implementierte Methoden und Eigenschaften.
• Definiere die Methode zuerst als Klassenmethode und dann (mithilfe dieser) als statische Methode - so kann sie auf zwei Arten genutzt werden.

1. AngleInRad(v1,v2) und AngleInDeg(v1,v2): Bestimmt den Winkel (im Bogenmass und in Grad) zwischen den beiden Vektoren, siehe https://de.wikipedia.org/wiki/Skalarprodukt.
2. AreParallel(v1,v2), AreAntiparallel (v1,v2), AreParallelOrAntiparallel(v1,v2), ArePerpendicular(v1,v2) geben true/false zurück. Parallel heisst: zeigen in gleiche Richtung, Antiparallel heisst: zeigen in entgegengesetzte Richtung.
3. SameLength(v1,v2): true/false

Öffne dein Dossier oder deine Aufgabenblätter aus dem Matheunterricht zum Thema Vektoren. Löse einige Aufgaben mithilfe deiner Vector-Klasse.