5 - Objektorientierte Sprachgrundlagen

Die beiden Variablen Computername und Benutzername werden im Konstruktor der Klasse Systeminfo initialisiert. Auf die Variablen kann aber von außen (über Instanzen der Klasse) nur lesend zugegriffen werden.

public class SystemInfo
{
  public readonly string Computername;
  public readonly string Benutzername;
  public void SystemInfo()
  {
    Computername = "MeinPC";
    Benutzername = "Nelly";
  }
}

Es wird eine Variable Dvd1 (auch Referenzvariable genannt, da sie ein Objekt referenziert) vom Typ DVD deklariert. Über new DVD() wird ihr eine Referenz auf ein neues DVD-Objekt zugewiesen. Die Deklaration und die Erzeugung des Objekts können auch über zwei separate Anweisungen erfolgen.

DVD Dvd1 = new DVD();
// oder
DVD Dvd1;
Dvd1 = new DVD();

Vom Compiler wird durch die erste Anweisung ein unbenannter Typ erstellt. Des Weiteren wird ein Objekt von diesem Typ erzeugt, auf das über die Variable person zugegriffen werden kann. Der unbenannte Typ besitzt die beiden Eigenschaften Name und Vorname, auf die nur lesend zugegriffen werden kann.

var person = new { Name = "Meier", Vorname = "Paule" };
string n = person.Name;
Console.WriteLine(person.Vorname);

Die Klasse Person enthält ein Datenelement Name. Vor dem Zugriff wird geprüft, dass die Referenz nicht auf null verweist. Nur in diesem Fall wird auf das Datenelement Name zugegriffen.

Person p;
if(p != null)
  p.Name = "Meier";

int? i = null;
double? d = 1.0;
d = null;

Das Beispiel zeigt die verschiedenen Operationen mit nullbaren Typen für den Datentyp int. Eine Konvertierung von einem nullbaren in den nicht nullbaren Typ ist nur über einen Cast möglich (10). Der umgekehrte Fall geht auch implizit (11). Mittels der Eigenschaft HasValue wird in (13) geprüft, ob die Variable einen Wert enthält, der nicht null ist. Auf den Wert kann über die Eigenschaft Value (14) zugegriffen werden. Über den Operator ?? wird in Zeile (17) eine bedingte Zuweisung realisiert. Ist der Wert von zahl1 nicht null, wird dieser Wert verwendet, sonst der Wert -1. In (19) wird die Methode GetValueOrDefault() genutzt, um einem einfachen Werttyp den Wert eines nullbaren Typs oder im Falle von null den Standardwert des Datentyps zuzuweisen.

01 using System;
02 namespace CSharpBuch.Kap05
03 {
04   public class NullbareTypen
05   {
06     static void Main(string[] args)
07     {
08       int? zahl1 = null;
09       int? zahl2 = 10;
10       int zahl3 = (int)zahl2;
11       zahl2 = zahl3;
12 
13       if(zahl1.HasValue) // oder (zahl1 != null)
14         Console.WriteLine("zahl1 hat den Wert: " + zahl1.Value);
15       else
16         Console.WriteLine("zahl1 hat den Wert null.");
17       zahl3 = zahl1 ?? -1;
18       Console.WriteLine("zahl3 hat den Wert: " + zahl3);
19       zahl3 = zahl1.GetValueOrDefault();
20       Console.WriteLine("zahl3 hat den Wert: " + zahl3);
21       Console.ReadLine();
22     }
23   }
24 }

struct DVD
{
  private string titel;
  private int erscheinungsjahr;
  public void Ausleihen(string name)
  {}
}
...
DVD Dvd1 = new DVD();

Im Beispiel wurde jeweils eine Klasse und eine Struktur mit dem gleichen öffentlichen Datenelement Name deklariert. Dann wird ein Objekt der Klasse KPerson erzeugt und der Variablen kp1 zugewiesen. Einer zweiten Variablen wird die erste Variable zugewiesen. Hier wird aber keine Kopie des Objekts erzeugt, sondern die Variable kp2 verweist nun auch auf das Objekt kp1. Über beide Variablen wird nun der Wert des Datenelements Name geändert. Wie die Ausgabe zeigt, hat die Änderung über kp1 den Wert von kp2 überschrieben. Die gleiche Vorgehensweise wird nun für den Typ SPerson vorgenommen, wobei es sich hier um eine Struktur handelt. Bei der Zuweisung sp2 = sp1; handelt es sich um eine echte Kopie der Datenelemente, so dass die Änderung des Namens über sp1 keine Auswirkungen auf sp2 hat.

using System;
namespace CSharpBuch.Kap05
{
  public class StrukturenUndKlassen
  {
    static void Main(string[] args)
    {
      KPerson kp1 = new KPerson();
      KPerson kp2 = kp1;
      kp2.Name = "Müller";
      kp1.Name = "Meier";
      Console.WriteLine("Klasse => Name: " + kp2.Name);
      SPerson sp1 = new SPerson();
      SPerson sp2 = sp1;
      sp2.Name = "Müller";
      sp1.Name = "Meier";
      Console.WriteLine("Struktur => Name: " + sp2.Name);
      Console.ReadLine();
    }
  }
  public class KPerson
  {
    public string Name;
  }
  public struct SPerson
  {
    public string Name;
  }
}

Klasse => Name: Meier
Struktur => Name: Müller

Die Funktionalität dieser Anwendung wurde auf vier Methoden verteilt. Damit diese innerhalb der Methode Main() verwendet werden können, müssen sie als static deklariert werden (da statische Methoden nur andere statische Methoden aufrufen können). Nach der Aufforderung, die Länge eines Passworts anzugeben, geben Sie eine Zahl auf der Konsole ein, ansonsten wird eine Exception ausgelöst. Dann wird ein Passwort "generiert". Dieses besteht einfach aus einer Folge der Buchstaben ABC... in der eingegebenen Länge (Methode PasswortErzeugen()). Auch wenn die Methoden in diesem Beispiel sehr wenige Anweisungen enthalten, ist die Aufteilung durchaus sinnvoll. Man könnte z.B. die Methode AnzahlZeichenEinlesen() dazu verwenden, beliebige Zahlen über die Konsole einzulesen. Es müsste nur dafür gesorgt werden, dass die Aufforderung zur Eingabe variabel ist. Die Methode PasswortErzeugen() ist natürlich in der Praxis so nicht brauchbar, zumindest was das generierte Passwort angeht. Damit es tatsächlich ein zufälliges Passwort wird, müssen Sie später aber nur diese Methode ändern, der Rest der Anwendung bleibt unberührt. Die Methode PasswortAusgeben() kann z.B. dahingehend geändert werden, dass sie das Passwort in eine Datei schreibt.

using System;
namespace CSharpBuch.Kap05
{
  public class PasswortGeneratorProj
  {
    static void Main(string[] args)
    {
      int anzZeichen;
      string passwort;

      BegruessungAnzeigen();
      AnzZeichen = AnzahlZeichenEinlesen();
      passwort = PasswortErzeugen(anzZeichen);
      PasswortAusgeben(passwort);
    }
    private static void BegruessungAnzeigen()
    {
      Console.WriteLine("Es wird ein Passwort erzeugt, dass " + 
                        "die von Ihnen angegebene Länge besitze.");
    }
    private static int AnzahlZeichenEinlesen()
    {
      Console.WriteLine("Wie lang soll das Passwort sein?");
      return Convert.ToInt32(Console.ReadLine());
    }
    private static string PasswortErzeugen(int laenge)
    {
      string passwort = "";
      for(int i = 0; i < laenge; i++)
        passwort = passwort + (char)(i + 65);
      return passwort;
    }
    private static void PasswortAusgeben(string passwort)
    {
      Console.WriteLine("Das generierte Passwort ist: " + passwort);
      Console.ReadLine();
    }
  }
}

[public | protected | private | internal]  Name()
{
  // Anweisungen
  return [];
}

Die Klasse Mathe deklariert die Methode GetPI(), die den (verkürzten) Wert der mathematischen Konstante Pi zurückliefert. Um die Methode zu nutzen, muss ein Objekt der Klasse Mathe erzeugt werden. Über die Referenzvariable m kann dann die Methode aufgerufen werden.

public class Mathe
{
  public double getPI()
  {
    return 3.14;
  }
}
public class Test
{
  static void Main(string[] args)
  {
    Mathe m = new Mathe(); // Objekt erzeugen
    Console.WriteLine(m.GetPI());
  }
}

Die Klasse ParameterUebergeben enthält zwei Methoden Add1() und Add2(), in denen jeweils der Wert des Parameters um eins erhöht wird. Der Unterschied zwischen beiden Methoden liegt lediglich in der Art der Parameterübergabe. Der Methode Add1() wird der Parameter als Wert und der Methode Add2() als Referenz übergeben. Nach Aufruf der beiden Methoden von Main() aus erfolgt die Ausgabe des Wertes der als Parameter übergebenen Variablen i. An den Ausgaben sehen Sie, dass der Aufruf von Add1() im Gegensatz zu Add2() keinen Einfluss auf den späteren Wert von i hat.

using System;
namespace CSharpBuch.Kap05
{
  public class ParameterUebergeben
  { 
    static void Main(string[] args)
    {
      int i = 1;
      Add1(i);
      Console.WriteLine("i = " + i);
      Add2(ref i);
      Console.WriteLine("i = " + i);
      Console.ReadLine();
    }
    static void Add1(int x)
    {
      x++;
      Console.WriteLine("x = " + x);
    }
    static void Add2(ref int y)
    {
      y++;
      Console.WriteLine("y = " + y);
    }
  }
}

Die Methode Init() nimmt zwei Parameter entgegen, die innerhalb der Methode mit Werten belegt werden. Da die Parameter mit out deklariert sind, müssen die übergebenen Variablen nicht initialisiert werden und die Werte sind nach Beendigung der Methode verfügbar. Dies ist aus der Ausgabe ersichtlich, die dem Methodenaufruf folgt.

static void Init(out int x, out int y)
{
  x = 5;
  y = 8;
}
...
// Aufruf in der Main-Methode:
int j, k;
Init(out j, out k);
Console.WriteLine("j = " + j + ", k = " + k); 
// Ausgabe: j = 5, k = 8

Der Methode Anzahl() kann eine Liste von beliebig vielen Objekten übergeben werden. Sie liefert die Anzahl der tatsächlich übergebenen Objekte zurück. In der Main()-Methode wird die Methode Anzahl() mit vier Parametern aufgerufen. Da in C# Werttypen indirekt Objekte sind (d.h., in diese über Boxing konvertiert werden), kann als Parametertyp der allgemeinste Typ Object genutzt werden. Die zurückgegebene Anzahl der Objekte wird ausgegeben. Die Ausgabe lautet hier: 4 Objekte übergeben

public class VariableParameterliste
{
  static void Main(string[] args)
  {
    Console.WriteLine(Anzahl(1, 2.2, "drei", "vier") + 
                      " Objekte übergeben");
  }
  private static int Anzahl(params object[] liste)
  {
    return liste.Length;
  }
}

Der Aufruf der beispielhaften Methode Ausgabe() erfolgt hier über drei verschiedene Varianten. Zuerst wird der Standardaufruf ohne die Verwendung von benannten Parametern genutzt. Im folgenden Aufruf werden die benannten Parameter genutzt und es wird ersichtlich, das die Reihenfolge keine Rolle spielt. Der dritte Aufruf zeigt schließlich das auch Positionsparameter mit benannten gemischt werden können, solange die Positionsparameter (also die normalen Parameter ohne Angabe des Namen) an ersten Stelle stehen.

public class BenannteParameter
{
  static void Main(string[] args)
  {
    BenannteParameter bPara = new BenannteParameter();
    bPara.Ausgabe(10, "Meier", 100.99);
    bPara.Ausgabe(name: "Schulze", betrag: 200.01, zahl: 100);
    bPara.Ausgabe(1000, betrag: 12.34, name: "Kunze");
  }
  public void Ausgabe(int zahl, string name, double betrag)
  {
    Console.WriteLine("zahl: " + zahl);
    Console.WriteLine("name: " + name);
    Console.WriteLine("betrag: " + betrag);
  }
}

Die Methode Ausgabe() besitzt in diesem Beispiel drei optionale Parameter, die jeweils mit null vorbelegt sind. Es wurden dazu nullbare Typen verwendete um tatsächlich später erkennen zu können, das diese nicht beim Aufruf mit einem Wert belegt wurden. Für die Ausgabe des Wertes wurde der NULL-Sammeloperator ?? verwendet der entweder den Wert des Parameters liefert wenn dieser nicht null ist oder im anderen Fall den nach dem ??-Operator angegebenen Wert. Alternativ könnte auch mit der Methode HasValue() der Parameter geprüft werden, ob dieser einen von null verschiedenen Wert besitzt und entsprechend darauf reagiert werden.

public class OptionaleParameter
{
  static void Main(string[] args)
  {
    OptionaleParameter oPara = new OptionaleParameter();
    oPara.Ausgabe();
    oPara.Ausgabe(name: "Meier");
    oPara.Ausgabe(100, betrag: 12.34);
  }
  public void Ausgabe(int? zahl = null, string name = null, 
                      double? betrag = null)
  {
    Console.WriteLine("zahl: " + (zahl ?? 0).ToString());
    Console.WriteLine("name: " + (name ?? "-"));
    Console.WriteLine("betrag: " + (betrag ?? 0.0).ToString());
  }
}

Die Methode TextAusgeben() wird in diesem Beispiel dreimal deklariert. Sie kann sowohl einen int-, einen double-, als auch einen string-Parameter entgegennehmen. Der übergebene Parameter und sein Datentyp werden ausgegeben. Aufgrund der Überladung müssen nicht für jeden Parametertyp neue Namen erdacht werden, was die Anwendung der Methoden erleichtert.

using System;
namespace CSharpBuch.Kap05
{
  public class MethodeUeberladen
  {
    static void Main(string[] args)
    {
      TextAusgeben("Hallo");
      TextAusgeben(23.456);
      TextAusgeben(25);
      Console.ReadLine();
    }
    static void TextAusgeben(int x)
    {
      Console.WriteLine(x + " ist eine ganze Zahl");
    }
    static void TextAusgeben(double x)
    {
      Console.WriteLine(x + " ist eine Gleitkommazahl");
    }
    static void TextAusgeben(string x)
    {
      Console.WriteLine(x + " ist eine Zeichenkette");
    }
  } 
}

Das Attribut DllImport befindet sich im Namespace System.Runtime.InteropServices, der zu Beginn mit eingebunden werden muss. Zum Aufruf der statischen Methode Sleep() ist der Namespace System.Threading erforderlich, da hieraus die Klasse Thread benötigt wird. Durch den Aufruf von Sleep() wird die Anwendung für die übergebene Anzahl Millisekunden angehalten. In der Klasse ExterneMethoden wird dann die Funktion MessageBeep() importiert (die einen Piepton erzeugt). Dieser wird ein Parameter vom Typ uint übergeben, der festlegt, welcher Sound-Typ erzeugt wird. Die Übergabe von 0xFFFFFFFF erzeugt den Standard-Piepser. Durch den "geschickten" Einsatz der for-Anweisung in Verbindung mit dem Modulo-Operator und der Methode Sleep() erhalten Sie einen Klingelton, der das Herz eines jeden Besitzers eines polyphonen Handys gefrieren lässt.

using System;
using System.Runtime.InteropServices;
using System.Threading;
namespace CSharpBuch.Kap05
{
  public class ExterneMethoden
  {
    [DllImport("user32")]
    static extern bool MessageBeep(uint type);
    static void Main(string[] args)
    {
      for(int i = 0; i < 60; i++)
      {
        if(i % 10 == 0)
          Thread.Sleep(300);
        if(i % 4 == 0)
          Thread.Sleep(50);
        MessageBeep(0xFFFFFFFF);
      }
    }
  }
}

Die Klasse Buch besitzt drei Überladungen des Konstruktors, in denen die Instanzvariablen mit den übergebenen Werten initialisiert werden. In der Main()-Methode werden zwei der Konstruktoren bei der Verwendung des Operators new aufgerufen. Anschließend werden zur Überprüfung die Inhalte der Variablen eines Buch-Objekts über die Methode ObjektAnzeigen() ausgegeben. Über this wird hier Bezug auf die Instanzvariablen der Klasse genommen. Diese Angabe ist notwendig, da die Parameter den gleichen Namen wie diese Variablen besitzen.

using System;
namespace CSharpBuch.Kap05
{
  public class ObjekteErzeugen
  {
    static void Main(string[] args)
    {
      Buch buch = new Buch("Märchen", "Gebrüder Grimm");
      Console.WriteLine(buch.ObjektAnzeigen());
      buch = new Buch("Mord im Orientexpress", "A. Christie", 1978);
      Console.WriteLine(buch.ObjektAnzeigen());
      Console.ReadLine();
    }
  }
  public class Buch
  {
    private string titel;
    private string autor;
    private int erscheinungsJahr;
    public Buch(string titel, int jahr)
    {
      this.titel = titel;
      this.erscheinungsJahr = jahr;
      this.autor = "";
    }
    public Buch(string titel, string autor)
    {
      this.titel = titel;
      this.autor = autor;
      this.erscheinungsJahr = 0;
    }
    public Buch(string titel, string autor, int jahr)
    {
      this.titel = titel;
      this.erscheinungsJahr = jahr;
      this.autor = autor;
    }
    public string ObjektAnzeigen()
    {
      if(erscheinungsJahr == 0)
        return (autor + ": \"" + titel + "\", Erscheinungsjahr unbekannt");
      else if(Autor == "")
        return ("\"" + titel + "\", " + erscheinungsJahr + " Autor unbekannt");
      else
        return (autor + ": \"" + titel + "\", " + erscheinungsJahr);
    }
  }
}

In den weniger umfangreichen Konstruktoren der Klasse Buch werden die Standardwerte einfach an den "allumfassenden" Konstruktor übergeben. Nachdem dieser ausgeführt wurde, werden die Anweisungen im zuerst aufgerufenen Konstruktor ausgeführt.

public Buch(string titel, int jahr): this(titel, "", jahr)
{
  Console.WriteLine("Konstruktor (titel, jahr)"); 
}
public Buch(string titel, string autor, int jahr)
{
  Console.WriteLine("Konstruktor (titel, autor, jahr)");
  this.titel = titel;
  this.erscheinungsJahr = jahr;
  this.autor = autor;
}

Konstruktor (titel, autor, jahr)
Konstruktor (titel, jahr)"

namespace CSharpBuch.Kap05
{
  public class ObjektInitialisierer
  {
    static void Main(string[] args)
    {
      Person p1 = new Person{ Name = "Meierle", Vorname = "Paule" };
      Person p2 = new Person{ Name = "Schulze" };
      Person p3 = new Person("Schmidt"){ Vorname = "Paula" };
    }
  }  
  public class Person
  {
    public string Name;
    public string Vorname { get; set; }
    public Person() {}
    public Person(string Name) { this.Name = Name; }
  }
}

Dem letzten Beispiel wird nun noch ein Destruktor für die Klasse Buch hinzugefügt. Dieser gibt eine Meldung auf der Konsole aus, wenn ein Objekt zerstört wird. Wenn Sie die Anwendung ausführen, werden Sie feststellen, dass der Destruktor erst nach dem Aufruf von ReadLine() aktiviert wird. Dies liegt daran, dass die Buch-Objekte zwar nicht mehr benötigt werden, der Garbage Collector aber noch nicht zum Einsatz gekommen ist.

~Buch()
{
  Console.WriteLine("Buch-Objekt zerstört");
}

Einem partiellen Typ wird das Schlüsselwort partial vorangestellt.

partial class Mathe
{
}

Das Hauptprogramm verwendet die Klasse Mathe, die wiederum durch zwei partielle Klassen in den Dateien Teil1.cs und Teil2.cs implementiert wird. Wichtig ist, dass für die Implementierung der Klasse Mathe immer der gleiche Namespace und die gleichen Zugriffsmodifizierer verwendet werden. Durch das Konzept der partiellen Klassen können nun z.B. komplexe Funktionen in eigene Dateien ausgelagert werden.

using System;
namespace CSharpBuch.Kap05
{
  public class PartielleTypen
  {
    static void Main(string[] args)
    {
      Mathe m = new Mathe();
      Console.WriteLine("3 + 4 = " + m.Add(3, 4));
      Console.WriteLine("3 - 4 = " + m.Minus(3, 4));
      Console.ReadLine();
    }
  }
}

using System;
namespace CSharpBuch.Kap05
{
  public partial class Mathe
  {
    public int Add(int zahl1, int zahl2)
    {
      return zahl1 + zahl2;
    }
  }
}

using System;
namespace CSharpBuch.Kap05
{
  public partial class Mathe
  {
    public int Minus(int zahl1, int zahl2)
    {
      return zahl1 - zahl2;
    }
  }
}

Die Klasse Person wird über zwei partielle Klassen definiert. In der ersten Klasse befindet sich nur der Methodenrumpf, um eine Ausgabe durchzuführen. Außerdem besitzt sie eine öffentliche Methode AusgabeDurchfuehren(), welche die private Methode Ausgabe() aufruft.

namespace CSharpBuch.Kap05
{
  public class PartielleMethoden
  {
    static void Main(string[] args)
    {
      Person p = new Person();
      p.AusgabeDurchfuehren();
    }
  }  
  public partial class Person
  {
    public void AusgabeDurchfuehren()
    {
      Ausgabe();
    }    
    partial void Ausgabe(); // nur Deklaration
  }
  public partial class Person
  {
    /*** entfernen, um die Methode zu nutzen
    partial void Ausgabe()
    { 
      Console.WriteLine("Hallo");
    }
    */
  }
}

Mathematische oder Zeichenkettenoperationen stellen ideale Kandidaten für statische Klassenelemente dar. So wird z.B. eine Methode zum Addieren zweier Zahlen mit den beiden Zahlen als Parameter aufgerufen und liefert die Summe als Ergebnis. Die Methode benötigt keine weiteren Informationen, d.h., sie benötigt insbesondere keinen Zugriff auf die Werte von Instanzvariablen, da kein Zustand über mehrere Methodenaufrufe hinweg gespeichert werden muss. Die Implementierung als statische Methode vermeidet, dass für den Aufruf der Methode erst ein Objekt erstellt werden muss.

public class Mathe
{
  public static int Add(int zahl1, int zahl2)
  {
    return zahl1 + zahl2;
  }
}
... // und der Aufruf
int ergebnis = Mathe.Add(10, 11);

Im Beispiel wird eine statische Klasse Mathe deklariert, welche nur statische Elemente enthält. Über die statische Variable aufrufe soll die Anzahl der Methodenaufrufe gezählt werden. Die Variable wird in einem statischen Konstruktor initialisiert. Über zwei statische Methoden wird die Addition durchgeführt und der Wert der Variablen aufrufe zurückgeliefert. Die Methoden der Klasse werden in der Methode Main() direkt über den Klassennamen aufgerufen. Die Verwendung einer solchen statischen Variablen ist z.B. für manuelle Statistik- und Durchsatzmessungen geeignet.

using System;
namespace CSharpBuch.Kap05
{
  public class StatischeElemente
  {
    static void Main(string[] args)
    {
      Console.WriteLine(String.Format("3 + 4 = {0}", Mathe.Add(3, 4)));
      Console.WriteLine(String.Format("6 + 5 = {0}", Mathe.Add(6, 5)));
      Console.WriteLine(String.Format("Mathe wurde {0} mal verwendet.", Mathe.GetAufrufe()));
    }
  }
  public static class Mathe
  {
    public const double PI = 3.14;
    private static int aufrufe;
    public static Mathe()
    {
      aufrufe = 0;
    }
    public static int Add(int zahl1, int zahl2)
    {
      aufrufe++;
      return zahl1 + zahl2;
    }
    public static int GetAufrufe()
    {
      return aufrufe;
    }
  }
}

Die Klasse Person besitzt zwei öffentliche Instanzvariablen. Diese sollen mit einer Methode ausgegeben werden, die als Erweiterungsmethode implementiert wird. Dazu wird eine weitere statische Klasse PersonErweiterung bereitgestellt, welche die Methode Ausgabe() besitzt. Als erster Parameter muss ein Objekt vom Typ der zu erweiternden Klasse übergeben werden. Der zweite Parameter soll als Trennzeichen für die Ausgabe dienen. Zum Test wird ein Person-Objekt über einen Objektinitialisierer erzeugt und danach wird für das Objekt die Methode Ausgabe() aufgerufen.

using System;
namespace CSharpBuch.Kap05
{
  public class ErweiterungsMethoden
  {
    static void Main(string[] args)
    {
      Person p = new Person { Name="Meierle", Vorname="Paule" };
      p.Ausgabe(", ");
    }
  }  
  public class Person
  {
    public string Name;
    public string Vorname;
  }  
  public static class PersonErweiterung
  {
    public static void Ausgabe(this Person pers, string trenner)
    {
      Console.WriteLine(pers.Name + trenner + pers.Vorname);
    }
  }
}

Zur Bruchrechnung existiert im .NET Framework noch keine geeignete Klasse. Die folgende Klasse Bruch besitzt zwei private Instanzvariablen, welche den Wert des Zählers und des Nenners verwalten, einen Konstruktor, mit dem beide Werte initialisiert werden, zwei Get-Methoden, um den Zähler und Nenner des Bruchs abzufragen, einen überladenen Operator zur Addition zweier Brüche und eine Methode ToString(), welche eine geeignete Textdarstellung eines Bruches zurückliefert. In der Methode Main() werden zum Test zwei Brüche addiert und das Ergebnis wird ausgegeben.

using System;
namespace CSharpBuch.Kap05
{
  public class OperatorenUeberladen
  {
    static void Main(string[] args)
    {
      Bruch b1 = new Bruch(3, 4);
      Bruch b2 = new Bruch(7, 5);
      Bruch b3 = b1 + b2;
      Console.WriteLine(b1.ToString() + "+" + 
                        b2.ToString() + "=" + 
                        b3.ToString());
    }
  }
  public class Bruch
  {
    private int zaehler;
    private int nenner;
    public Bruch(int zaehler, int nenner)
    {
      this.zaehler = zaehler;
      this.nenner = nenner;
    }
    public int GetZaehler()
    {
      return zaehler;
    }
    public int GetNenner()
    {
      return nenner;
    }
    public static Bruch operator +(Bruch op1, Bruch op2)
    {
      int nenner = op1.nenner * op2.nenner;
      int zaehler = nenner / op1.nenner * op1.zaehler +
                    nenner / op2.nenner * op2.zaehler;
      Bruch b = new Bruch(zaehler, nenner);
      return b;
    }
    public override string ToString()
    {
      return zaehler.ToString() + "/" + nenner.ToString();
    }
  }
}