.NET Programmierung Tipps & Tricks

Entschuldigt bitte meine lange Abwesenheit. Ich hatte viel mit der Uni zu tuen und konnte deshalb keine neuen Beiträge verfassen.
Ich hoffe der Blog hat nicht all zu sehr darunter gelitten.

In diesem Post soll es um die Operatorenüberladung gehen. Ursprünglich kommt dieser Mechanismus aus C++ und wurde (glücklicherweise) mit in die Sprachfeatures von C# übernommen.
Zuerst möchte ich klären was es damit überhaupt auf sich hat.

Das Überladen von Methoden kennt ja sicherlich jeder. Es beschreibt den Mechanismus das man eine Methode, mit gleichen Funktionsnamen, verschiedene Parameterlisten verpassen kann.
Genau das selbe kann man auch mit Operatoren machen. Eine Liste der Überladbaren Operatoren findet ihr hier.

Das Überladen von Operatoren ist eine heikle Angelegenheit, es birgt zwar eine Menge Potential und ist ein mächtiges Sprachfeature, genauso gut kann man es auch vollkommen falsch verwenden.
Wenn ihr C# programmiert macht ihr von überladenen Operatoren sehr oft Gebrauch.
Wenn ihr zum Beispiel die DateTime Struktur benutzt, dann könnt ihr ein DateTime Objekt mit einem DateTime Objekt vergleichen, Zeitspannen auf ein DateTime Objekt dazuaddieren und Zeitspannen abziehen. Das alles könnt Ihr nur machen, weil die passenden Operatoren(+, -, ==, != usw) dazu überladen wurden.

Warum hab ich aber gesagt dass, das Überladen von Operatoren heikel sein kann? Möchte man einen Operator überladen, sollte man sich vorher genaustens Gedanken darüber machen ob es für die darunter liegende Klasse wirklich sinnvoll ist diejenigen Operatoren zu überladen. Man sollte immer folgende Regel beachten: Überlade ich Operatoren, dann muss die Benutzung, im Zusammenhang mit der Klasse, so intuitiv gestaltet sein wie möglich. Die DateTime Struktur zeigt das was ich mit Intuitiv meine.

DateTime now = DateTime.Now;
now = now + TimeSpan.FromDays(5);

Was bei der Addition entsteht ist natürlich ein DateTime Objekt welches 5 Tage von heute dazu addiert bekäme.
Unintuitiv wäre an dieser Stelle wenn ein komplett Wirres Datum entstehen würde.

Als nächstes möchte ich mit euch eine minimalistische Version einer Klasse entwickeln welche zum Rechnen mit Rationalen Zahlen dient.
In dieser Klasse werde ich diverse Operatoren überladen, weil sich das bei einer solchen Klasse mehr als anbietet. Folgende Features wollen wir mit der Klasse unterstützen

Fraction f = 0.2;
Fraction f = 0.5;
Fraction f2 = 0.1;
Fraction f3 = f + f2;
Fraction f +=0.59;

Das sind eine Menge Anforderungen die wir da unterstützen wollen. Nachfolgend will ich euch zeigen wir Ihr den ersten Fall unterstützen könnt. Dieser Operator nennt sich der implicit-operator. Dieser Operator wird bei jeglichen Konvertierungen und Casts aufgerufen die Implizit durchgeführt werden können. Wichtig bei diesem Operator: Es darf keine Exception geworfen werden während des Konvertierungsvorgangs. Sollte man das nicht sicherstellen können, sollte man den explicit-operator Überladen.

Operatoren werden IMMER als statische Methoden einer Klasse definiert. Der implicit-operator für unsere Klasse sehe zum Beispiel wie folgt aus:

public static implicit operator Fraction(double number)
{
   return new Fraction(number);
}

Ich werde euch das Projekt mit an den Post hängen sodass ich hier nur die Operator-Definitionen präsentiere da ich nicht all den anderen Code hier mit Posten möchte um nicht vom Hauptthema abzulenken.

Wie Ihr sehen könnt definiere ich die Methode zuerst als Statische Methode der Klasse, danach kommt das Schlüsselwort implicit gefolgt vom operator Schlüsselwort und dem Rückgabewert der bei dieser impliziten Konvertierung zurückgegeben werden soll. In den Klammern steht dann ausgehend von welchem Typ wir die Konvertierung durchführungen wollen.
Möchten wir noch long-Zahlen als Konvertierungskandidaten unterstützen, so müssen wir eine weitere Überladung anbieten.

public static implicit operator Fraction(long number)
{
  return new Fraction(number);
}

Als nächstes möchte ich euch noch die Binären Operatoren, speziell die +-operatoren präsentieren.
Wollen wir zwei Bruch-Objekte miteinander addieren so muss das wie folgt aussehen:

public static Fraction operator +(Fraction frac, Fraction otherFrac)
{
  if (frac == null)
    throw new ArgumentNullException("frac", "Bruchobjekt darf nicht 'null' sein.");
   return frac.Add(otherFrac);
}

Innerhalb der Klammer stehen nun der linke Operand (erstes Argument) und rechte Operand (zweites Argument). Als Rückgabe erhalten wir hier wieder ein Bruch-Objekt. Natürlich könnte man hier auch ein double zurückgeben, doch das würde dann schon wieder unintuitiv werden.
Was aber wenn ich ein Bruchobjekt mit einer double-Zahl addieren will. Dann brauchen wir nur das zweite Argument in der Parameterliste ändern:

public static Fraction operator +(Fraction frac, double number)
{
   if (frac == null)
     throw new ArgumentNullException("frac", "Bruchobjekt darf nicht 'null' sein.");

   return frac.Add(number);
}

Es bietet sich meistens an, für die jeweiligen Operatoren die passenden Funktionen zur Verfügung zu stellen, dann brauch man den Aufruf des Operators nur an die Funktion weiterleiten.

Ich hoffe ich konnte euch das Thema Operatoren anhand dieses Beispiels etwas näher bringen. Ich halte es für unnötig euch noch die ganzeren anderen Operatoren zu präsentieren, weil das alles der gleiche Aufbau ist.
Bruch Klasse