XML * XML-SCHEMA * XPATH * XSL * XSL-FO * SVG * XQUERY * XPROC * ANT * DIVERSES



Diverses / Objekt-Orientierte Programmierung mit C#.NET / C#.NET Die Klasse Bruch

C#.NET Die Klasse Bruch

C#.NET Die Klasse Bruch

Auf dieser Seite:

using System;
namespace CSharpSchulung
{
  /// <summary>
  /// Die Klasse implementiert die Bruchrechnung in C#.NET
  /// mit Addition, Subtraktion, Multiplikation, Division,
  /// Kuerzroutine und Operatorüberladung
  /// </summary>
  public class Bruch
  {
#region Private geschützte Felder
    /// <summary>
    /// private geschütztes Feld _Zaehler
    /// </summary>
    private int _Zaehler;
    /// <summary>
    /// private geschütztes Feld _Nenner
    /// </summary>
    private int _Nenner;
#endregion
#region Properties
    /// <summary>
    /// PROPERTY: kombinierte Lese- und Schreibmethode für _Zaehler
    /// </summary>
    public int Zaehler
    {
      get
      {
        return this._Zaehler;
      }
      set
      {
        this._Zaehler = value;
      }
    }
    /// <summary>
    /// PROPERTY: kombinierte Lese- und Schreibmethode für _Nenner. Ruft Methode OnNennerIstNull für Eventhandler auf.
    /// </summary>
    public int Nenner
    {
      get
      {
        return this._Nenner;
      }
      set
      {
        this._Nenner = value;
        //if (this._Nenner == 0) OnNennerIstNull(new EventArgs());
        if (this.Nenner == 0)
        {
          // fuer die delegate-Lösung
          Ondvnenneristnull();
          // für den EventHandler/EventArgs-Lösung
          OnNennerIstNull(new EventArgs());
        }
      }
    }
    /// <summary>Dividiert Zaehler durch Nenner.
    /// Nullable: kann null sein, wenn Nenner==0</summary>
    public double? Quotient
    {
      get
      {
        if (this.Nenner == 0) return null;
        else
        {
          /*Die direkte Division von zwei Integerwerten gibt ggf. 0, 
          wenn der Nenner größer ist als der Zaehler.
          Daher wird einer oder beide Integerwerte nach double konvertiert;
          anschließend funktioniert auch die Typkonvertierung.*/
          double dz = (double)this.Zaehler;
          double dn = (double)this.Nenner;
          double d = dz / dn;
          return d;
        }
      }
    }
    /// <summary>Größter gemeinsamer Teiler, 
    /// Berechnung durch Euklidischen Algorithmus</summary>
    /// <remarks>Achtung bei wiederholter Verwendung etwa beim Kuerzen(), siehe dort</remarks>
    public int GGT
    {
      get
      {
        int z = Math.Abs(this.Zaehler);
        int n = Math.Abs(this.Nenner);
        int erg = 1;
        if (z > 0 && n > 0)
        {
          while (z != n)
          {
            if (z > n) z = z - n;
            else n = n - z;
          }
          erg = z;
        }
        return erg;
      }
    }
#endregion
#region Konstruktoren
    /// <summary>Standardkonstruktor der Klasse Bruch</summary>
    public Bruch()
    {
    }
    /// <summary>Parametrisierter Konstruktor der Klasse Bruch</summary>
    /// <param name="value">Rationale Zahl, die in Zaehler und Nenner konvertiert wird</param>
    /// <remarks>Die Zahl wird intern mit einem Faktor erweitert, der von der Anzahl der Nachkommastellen abhängt. Der erweiterte Gesamtwert muss sich im Rahmen des Int32-Wertebereichs finden. Daher sind Größenbeschänkungen zu erwarten.</remarks>
    /// <exception cref="Exception">wird geworfen bei zu großen oder zu kleinen Gesamtwerten</exception>
    public Bruch(double value)
    {
      string str = value.ToString();      
      // Aufpassen mit dem Komma!
      int pos = str.IndexOf(",");      
      int anzNKStellen = str.Substring(pos + 1).Length;      
      double wert = value * Math.Pow(10, anzNKStellen);
      if (wert <= Int32.MaxValue && wert >= Int32.MinValue)
      {
        this.Zaehler = (int)wert;
        this.Nenner = (int)Math.Pow (10 , anzNKStellen);
      }
      else throw new Exception("Der Wert ist zu groß oder zu klein");
    }
    /// <summary>Parametrisierter Konstruktor der Klasse Bruch</summary>
    /// <param name="sbruch">zum Beispiel "57/95"</param>
    /// <exception cref="NotFiniteNumberException">wird geworfen bei fehlerhafter Dateneingabe</exception>
    public Bruch(string sbruch)
    {
      // besser: über regexpr
      if (sbruch.Contains("/"))
      {
        int pos = sbruch.IndexOf('/');
        string links = sbruch.Substring(0, pos ).Trim();
        string rechts = sbruch.Substring( pos + 1).Trim();
        try
        {
          this.Zaehler = Int32.Parse(links);
          this.Nenner = Int32.Parse(rechts);          
        }
        catch (NotFiniteNumberException exc)
        {
          throw exc;
        }
      }
    }
    /// <summary>Parametrisierter Konstruktor der Klasse Bruch</summary>
    /// <param name="z">wird _Zaehler zugewiesen</param>
    /// <param name="n">wird _Nenner zugewiesen</param>
    public Bruch(int z, int n)
    {
      this.Zaehler = z;
      this.Nenner = n;
      this.Kuerzen();
    }
    /// <summary>Kopier-Konstruktor der Klasse Bruch</summary>
    /// <param name="x">ein anderes existierendes Objekt der Klasse, dessen Zaehler und Nenner kopiert werden</param>
    public Bruch(Bruch x)
    {
      this.Zaehler = x.Zaehler;
      this.Nenner = x.Nenner;
    }
#endregion
#region Events    
    /// <summary>
    /// Methode für EventHandler: wird in Property Nenner aufgerufen
    /// </summary>
    /// <param name="c">Parameter wird in get-Property Nenner generiert</param>
    public delegate void dvNennerIstNull(Bruch sender, string s);
    /// <summary>
    /// Der Methodenzeiger dvnenneristnull erhält seinen Verweis 
    /// auf private-Methode Ondvnenneristnull()
    /// im Nenner-Property.
    /// </summary>
    public event dvNennerIstNull dvnenneristnull;
    private void Ondvnenneristnull()
    {
      if(dvnenneristnull != null)
      {
        string s = "Der Nenner ist 0";
        dvnenneristnull(this, s);
      }
    }
    /// <summary>
    /// Dieser Konstruktor erhält einen Delegate-Parameter, 
    /// der automatisch den Zeiger auf die Handler-Methode setzt.
    /// </summary>
    /// <param name="d"></param>
    public Bruch(int z, int n, dvNennerIstNull d)
    {
      this.dvnenneristnull = d;
      this.Zaehler = z;
      //this.Nenner = n;
      this._Nenner = n;
      if (this.Nenner == 0)
      {
        // fuer die delegate-Lösung
        Ondvnenneristnull();
      }
      // Da der Delegate-Aufruf im Nenner-Property steht, wird
      // bei Aufruf von Kuerzen() das Ereignis mehrfach aufgerufen
      //this.Kuerzen();
    }
    /**ALTERNATIVE MIT EventHandler und EventArgs
    Eine etwas elegantere Lösung als das Delegate-Prinzip 
    ist der EventHandler in Verbindung mit EventArgs.
    Offenbar kapselt der EventHandler ein Delegate
    mit zwei Parametern: object sender und EventArgs e.
       */
    /// <summary>
    /// Event, wird in OnNennerIstNull bzw. Property 
    /// Nenner aufgerufen, wenn Nenner 0 ist
    /// </summary>
    public event EventHandler NennerIstNull;
    // EventArgs ist die Basisklasse für Klassen, die Ereignisdaten enthalten. 
    /*
    Diese Klasse enthält keine Ereignisdaten. 
    Sie wird von Ereignissen verwendet, die beim Auslösen 
    eines Ereignisses keine Zustandsinformationen an einen Ereignishandler 
    übergeben. Wenn für einen Ereignishandler Zustandsinformationen 
    erforderlich sind, muss die Anwendung von dieser Klasse eine 
    Klasse ableiten, die die Daten enthält.
    */
    private void OnNennerIstNull(EventArgs c)
    {
      if (this.NennerIstNull != null)
      {
        this.NennerIstNull(this, c);        
      }
    }
    public Bruch(int z, int n, EventHandler eh)
    {
      this.NennerIstNull += eh;
      this.Zaehler = z;
      //this.Nenner = n;
      this._Nenner = n;
      if (this.Nenner == 0)
      {
        OnNennerIstNull(new EventArgs());
      }
    }
#endregion
#region Methoden
    /// <summary>
    /// Überschreibt die ToString-Methode der Basisklasse Object
    /// </summary>
    /// <returns>Zaehler / Nenner</returns>
    public override string ToString()
    {
      if (this.Nenner == 0) return "NICHT DEFINIERT";
      else if (this.Nenner == 1 || this.Zaehler == 0) return this.Zaehler.ToString();
      else return String.Format("{0} / {1}", Zaehler, Nenner);
    }
    // Alternativen:
    //public override string ToString() => ($"{this.Zaehler} / {this.Nenner}");
    //
    //public override string ToString() => (this.Nenner==0 ? $"NICHT DEFINIERT" 
    //                                      : ($"{this.Zaehler} / {this.Nenner}"));
    //
    //public override string ToString() => (this.Nenner == 0 ? $"NICHT DEFINIERT"
    //    : (this.Nenner == 1 || this.Zaehler == 0) ? $"{this.Zaehler}"
    //    : ($"{this.Zaehler} / {this.Nenner}"));
    //
    //public override string ToString()
    //{
    //    switch (this.Nenner)
    //    {
    //        case 0: return $"NICHT DEFINIERT";
    //        case 1: return $"{this.Zaehler}";
    //        default:
    //            if (this.Zaehler == 0) return $"0";
    //            else return $"{this.Zaehler} / {this.Nenner}";
    //    }            
    //}
    /// <summary>
    /// Addiert zwei Objekte der Klasse Bruch und schreibt das
    /// Ergebnis auf das aufrufende Objekt
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    public void Addiere(Bruch a, Bruch b)
    {
      this.Zaehler = a.Zaehler * b.Nenner + a.Nenner * b.Zaehler;
      this.Nenner = a.Nenner * b.Nenner;
      this.Kuerzen();
    }
    /// <summary>
    /// Subtrahiert zwei Objekte der Klasse Bruch und schreibt das
    /// Ergebnis auf das aufrufende Objekt
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    public void Subtrahiere(Bruch a, Bruch b)
    {
      this.Zaehler = a.Zaehler * b.Nenner - a.Nenner * b.Zaehler;
      this.Nenner = a.Nenner * b.Nenner;
      this.Kuerzen();
    }
    /// <summary>
    /// Multipliziert zwei Objekte der Klasse Bruch und schreibt das
    /// Ergebnis auf das aufrufende Objekt
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    public void Multipliziere(Bruch a, Bruch b)
    {
      this.Zaehler = a.Zaehler * b.Zaehler;
      this.Nenner = a.Nenner * b.Nenner;
      this.Kuerzen();
    }
    /// <summary>
    /// Dividiert zwei Objekte der Klasse Bruch und schreibt das
    /// Ergebnis auf das aufrufende Objekt
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    public void Dividiere(Bruch a, Bruch b)
    {
      this.Zaehler = a.Zaehler * b.Nenner;
      this.Nenner = a.Nenner * b.Zaehler;
      this.Kuerzen();
    }
    /// <summary>Kürzt Zaehler und Nenner des aufrufenden Objekts mit <seealso cref="GGT">GGT</seealso></summary>
    /// <remarks>Das Folgende wäre ein Fehler: 
    /// Da sich this.Zaehler durch die Division ändert, 
    /// ändert sich beim Folgeaufruf der Wert des GGT.
    /// this.Zaehler = this.Zaehler / this.GGT;
    /// this.Nenner = this.Nenner / this.GGT;
    ///</remarks>
    public void Kuerzen()
    {
      int iggt = this.GGT;
      this.Zaehler = this.Zaehler / iggt;
      this.Nenner = this.Nenner / iggt;
    }
#endregion
#region Operatoren
    /// <summary>
    /// Überladener Operator +: Addiert zwei Objekte der Klasse Bruch. 
    /// Rückgabe ist eine neue Instanz der Klasse, die den Wert aufnimmt
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>Bruch</returns>
    public static Bruch operator +(Bruch a, Bruch b)
    {
      Bruch erg = new Bruch();
      erg.Addiere(a, b);
      return erg;
    }
    /// <summary>
    /// Überladener Operator +: Subtrahiert zwei Objekte der Klasse Bruch. 
    /// Rückgabe ist eine neue Instanz der Klasse, die den Wert aufnimmt
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>Bruch</returns>
    public static Bruch operator -(Bruch a, Bruch b)
    {
      Bruch erg = new Bruch();
      erg.Subtrahiere(a, b);
      return erg;
    }
    /// <summary>
    /// Überladener Operator +: Multipliziert zwei Objekte der Klasse Bruch. 
    /// Rückgabe ist eine neue Instanz der Klasse, die den Wert aufnimmt
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>Bruch</returns>
    public static Bruch operator *(Bruch a, Bruch b)
    {
      Bruch erg = new Bruch();
      erg.Multipliziere(a, b);
      return erg;
    }
    /// <summary>
    /// Überladener Operator +: Dividiert zwei Objekte der Klasse Bruch. 
    /// Rückgabe ist eine neue Instanz der Klasse, die den Wert aufnimmt
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>Bruch</returns>
    public static Bruch operator /(Bruch a, Bruch b)
    {
      Bruch erg = new Bruch();
      erg.Dividiere(a, b);
      return erg;
    }
    // Die Vergleichsoperatoren müssen immer paarweise überladen werden
    /// <summary>
    /// Überladener Operator <: Prüft, ob der erste Bruch kleiner ist als der zweite.     
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>bool</returns>
    public static bool operator <(Bruch a, Bruch b)
    {
      bool erg = false;
      Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
      Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
      if (a1.Zaehler < b1.Zaehler) erg = true;
      return erg;
    }
    /// <summary>
    /// Überladener Operator <: Prüft, ob der erste Bruch größer ist als der zweite.     
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>bool</returns>
    public static bool operator >(Bruch a, Bruch b)
    {
      bool erg = false;
      Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
      Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
      if (a1.Zaehler > b1.Zaehler) erg = true;
      return erg;
      // IST DAS KORREKT?? Wie wenn beide gleich sind?
      //return !(a < b);
    }
    /// <summary>
    /// Überladener Operator <=: Prüft, ob der erste Bruch kleiner oder gleich ist als der zweite.     
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>bool</returns>
    public static bool operator <=(Bruch a, Bruch b)
    {
      bool erg = false;
      Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
      Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
      if (a1.Zaehler <= b1.Zaehler) erg = true;
      return erg;
    }
    /// <summary>
    /// Überladener Operator <=: Prüft, ob der erste Bruch größer oder gleich ist als der zweite.     
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>bool</returns>
    public static bool operator >=(Bruch a, Bruch b)
    {
      bool erg = false;
      Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
      Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
      if (a1.Zaehler >= b1.Zaehler) erg = true;
      return erg;
    }
    /// <summary>
    /// Überladener Operator ==: Prüft, ob der erste und der zweite Bruch gleich sind.
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>bool</returns>
    public static bool operator ==(Bruch a, Bruch b)
    {
      bool erg = false;
      Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
      Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
      if (a1.Zaehler == b1.Zaehler) erg = true;
      return erg;
    }
    /// <summary>
    /// Überladener Operator !=: Prüft, ob der erste und der zweite Bruch ungleich sind.
    /// </summary>
    /// <param name="a">Erster Parameter, Typ: Bruch</param>
    /// <param name="b">Zweiter Parameter, Typ: Bruch</param>
    /// <returns>bool</returns>
    public static bool operator !=(Bruch a, Bruch b)
    {
      bool erg = false;
      Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
      Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
      if (a1.Zaehler != b1.Zaehler) erg = true;
      return erg;
    }
    /// <summary>
    /// Überschreibt die Equals-Methode der Basisklasse Object
    /// </summary>
    /// <param name="obj"></param>
    /// <returns>bool</returns>
    public override bool Equals(object obj)
    {
      /*Hier ist es schwierig, mit == zu arbeiten. 
       * Zwei Objekte können dieselben Werte, aber unterschiedliche Referenzen haben.
       * Wenn zwei Objekte identisch sind, haben sie auch denselben Hashcode.
       */
      return System.Object.ReferenceEquals(this, obj);
    }
    /**
     Der Sinn von GetHashCode: ein Objekt in eine Hashtable einzufügen
       */
    /// <summary>
    /// Überschreibt die GetHashCode-Methode der Basisklasse Object
    /// </summary>
    /// <returns>int</returns>
    public override int GetHashCode()
    {      
      return base.GetHashCode();
    }
#endregion
  }
}

Die Klasse Bruch definiert einen Event und eine Routine, die bei Auftreten des Ereignisses dafür sorgt, dass alles korrekt abläuft. Einem Objekt dieser Klasse können Sie eine andere Methode als EventHandler zuweisen, quasi als Delegate.

Den Eventhandler können Sie aber erst zuweisen, nachdem das Objekt instanziiert ist. Wenn Sie dem Objekt per parametrisiertem Konstruktor Werte übergeben, die eigentlich ein Fall für den Handler wären, dann kümmert sich der Handler nicht drum. Die Lösung: implementieren Sie un der Klasse einen Konstruktor mit Eventhandler als Parameter, dann können Sie dem Objekt den Funktionszeiger gleich mitgeben.


delegate void dBruch(Bruch b);
static void Bruchdemo()
{
    EventHandler eh = new EventHandler(Bruch_NennerIstNull);
    Bruch beh = new Bruch(36, 0, eh);
    Console.ReadLine();
    Bruch.dvNennerIstNull d;
    d= Bruch_NennerIstNull;
    Bruch hx = new Bruch(99, 0, d);
    Console.WriteLine(hx);
    Console.ReadLine();
    Bruch a = new Bruch(4, 5);
    Bruch b = new Bruch(1, 1);
    // hier werden zwei unterschiedliche Methoden angesprochen
    // spricht static void Bruch_NennerIstNull(Bruch sender, string e) an
    b.dvnenneristnull += Bruch_NennerIstNull;
    // spricht Bruch_NennerIstNull(object sender, EventArgs e) an
    b.NennerIstNull += new EventHandler(Bruch_NennerIstNull);
    /*Der EventHandler ist referenzgebunden. 
      Wird via Konstruktor eine neue Instanz deklariert, muss 
      im Bedarfsfall auch der Eventhandler neu gesetzt werden*/
    b.Nenner = 0;
    try
    {
        b = new Bruch("4   /     0");                
        //b.NennerIstNull += new EventHandler(Bruch_NennerIstNull);
        /*wirkungslos, wenn der Nenner schon im Konstruktor auf 0 gesetzt wird.*/
    }
    catch(Exception exc)
    {
        Console.WriteLine(exc.Message);
    }
    b = new Bruch(100.100);
    Console.WriteLine("{0}", b);
    b.Kuerzen();
    Console.WriteLine("a.GetHashCode(): {0}", a.GetHashCode());
    Console.WriteLine("b.GetHashCode(): {0}", b.GetHashCode());
    Bruch c = a;
    Console.WriteLine("c.GetHashCode(): {0}", c.GetHashCode());
    if (a.Equals(b)) Console.WriteLine("Equals: Beide Brüche sind gleich");
    else Console.WriteLine("Equals: Beide Brüche sind nicht gleich");
    if (a == b) Console.WriteLine("==    : Beide Brüche sind gleich");
    if (a != b) Console.WriteLine("Beide Brüche sind nicht gleich");
    if (a < b) Console.WriteLine("Bruch a ist kleiner als Bruch b");
    if (a > b) Console.WriteLine("Bruch a ist größer als Bruch b");
    if (a <= b) Console.WriteLine("Bruch a ist kleiner als Bruch b oder beide sind gleich");
    if (a >= b) Console.WriteLine("Bruch a ist größer als Bruch b oder beide sind gleich");
    Console.WriteLine("{0}", b);
    Console.WriteLine("{0}", b.Quotient);
    /*hier wird der oben definierte Delegate dBruch verwendet, 
     der ein Bruch-Objekt als Parameter verlangt; der Rückgabetyp ist void.
        mit ddd wird der Zaehler des Bruch-Parameters auf Console ausgegeben*/
    dBruch ddd = (bb) => Console.WriteLine(bb.Zaehler);
    Bruch bbb = new Bruch("45/55");            
    ddd(bbb);
}
/// <summary>EVENTHANDLER</summary>
/// <param name="sender"></param>
/// <param name="e"></param>
static void Bruch_NennerIstNull(object sender, EventArgs e)
{
    Bruch x = sender as Bruch;
    Console.WriteLine("EVENTARGS: DER NENNER IST NULL: {0}; eventargs: {1}", x.Zaehler, e.ToString());
}
static void Bruch_NennerIstNull(Bruch sender, string e)
{            
    Console.WriteLine("Delegate: Bei Zaehler: {0}; Meldung: {1}", sender.Zaehler, e);
}

Arbeiten mit Func

Analog zu ist es auch hier möglich, eine lokale Func mit einem Lambda-Ausdruck zu implementieren.

Func<Bruch, Bruch, Bruch> deklariert hier ein Delegate mit zwei Bruch-Parametern und einem Bruch-Rückgabewert. Letzterer wird über die in der Klasse Bruch codierten Operatorüberladung realisiert.


static void Main(string[] args)
{            
    Func<Bruch, Bruch, Bruch> 
        fAddiere = (a, b) => { return a + b; };
    Bruch b1 = new Bruch(1,2);
    Bruch b2 = new Bruch(3,2);
    Bruch b3 = fAddiere(b1, b2);
    Console.WriteLine(b3);
}

wg / 5. April 2021



Fragen? Anmerkungen? Tipps?

Bitte nehmen Sie Kontakt zu mir auf.






Vielen Dank für Ihr Interesse an meiner Arbeit.



V.i.S.d.P.: Wilfried Grupe * Klus 6 * 37643 Negenborn

☎ 0151. 750 360 61 * eMail: info10@wilfried-grupe.de

www.wilfried-grupe.de/cs_OOP_Bruch.html