C#.NET * C++ * JAVASCRIPT * PYTHON * DIVERSES
XML * XML-SCHEMA * XPATH * XSL * XSL-FO * SVG * XQUERY * XPROC * ANT



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

Bruch-Klasse mit EventHandler

Bruch-Klasse mit EventHandler

➪ Die nachstehende Logik beschreibt eine Klasse zur mathematischen Bruchrechnung mit Zaehler und Nenner, samt EventHandler, Operatorüberladung, System.Reflection und Invoke. Ergänzend wird eine Attribut-Klasse definiert.

Auf dieser Seite:

Die Bruchklasse:


namespace CSharpSchulung
{
[AttributeUsage(AttributeTargets.All)]
  public class Developer : Attribute
  {
    private string nachname, vorname, datum;
    public Developer(string nn, string vn, string d)
    {
      nachname = nn;
      vorname = vn;
      datum = d;
    }
    public override string ToString()
    {
      return $"Developer: {vorname} {nachname}, 
               Datum: {datum}";
    }
  }
 [Developer("Grupe", "Wilfried", "20190101")]
 public class Bruch
 {
  #region Private fields
  private int _Zaehler;
  private int _Nenner;
  #endregion
  #region Properties
  public int Zaehler
  {
   get => _Zaehler;
   set => _Zaehler = value;
  }
  public int Nenner
  {
   get =>this._Nenner;   
   set
   {
    this._Nenner = value;
    if (this._Nenner == 0)
     OnNennerIstNull(new EventArgs());
   }
  }  
  #endregion
  #region Constructors
  /// <summary>Standardkonstruktor der Klasse Bruch</summary>
  public Bruch()
  {
  }
  /// <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;
  }
  /// <summary>Parametrisierter Konstruktor der Klasse Bruch</summary>
  /// <param name="eh">Hier wird der EventHandler zugewiesen</param>
  /// <param name="z">Wird _Zaehler zugewiesen</param>
  /// <param name="n">Wird _Nenner zugewiesen</param>
  [Developer("Grupe", "Wilfried", "20190125")]
  public Bruch(int z, int n, EventHandler eh)
  {
   this.NennerIstNull += eh;
   this.Zaehler = z;
   this.Nenner = n;   
  }
  /// <summary>Destruktor der Klasse Bruch</summary>
  ~Bruch()
  {
   //Console.WriteLine($"Destruktor Bruch {this.Zaehler}/{this.Nenner}");
  }
  #endregion
  #region Events  
  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. 
  */
  private void OnNennerIstNull(EventArgs c)
  {
   if (this.NennerIstNull != null)
   {
    NennerIstNull(this, c);
   }
  }
  #endregion
  #region Methods
  public override string ToString()
  {
   if (this.Zaehler == 0 || this.Nenner == 1)
    return this.Zaehler.ToString();
   //else return String.Format("{0} / {1}", this.Zaehler, this.Nenner);
   else return $"{this.Zaehler} / {this.Nenner}";
  }
  /// <summary>
  /// Kuerzt _Zaehler und _Nenner des aufrufenden Objekts
  /// durch Ermittlung des größten gemeinsamen Teilers
  /// </summary>
  [Developer("Grupe", "Wilfried", "20190125")]
  public void Kuerzen()
  {
   int z = Math.Abs(this.Zaehler);
   int n = Math.Abs(this.Nenner);
   if (z > 0 && n > 0)
   {
    while (z != n)
    {
     if (z > n) z = z - n;
     else n = n - z;
    }
    this.Zaehler = this.Zaehler / z;
    this.Nenner = this.Nenner / z;
   }
  }
  public void Addiere(Bruch a, Bruch b)
  {
   a.Kuerzen();
   b.Kuerzen();
   this.Zaehler = a.Zaehler * b.Nenner + a.Nenner * b.Zaehler;
   this.Nenner = a.Nenner * b.Nenner;
   this.Kuerzen();
  }
  public void Dividiere(Bruch a, Bruch b)
  {
   a.Kuerzen();
   b.Kuerzen();
   this.Zaehler = a.Zaehler * b.Nenner;
   this.Nenner = a.Nenner * b.Zaehler;
   this.Kuerzen();
  }
  public void Subtrahiere(Bruch a, Bruch b)
  {
   a.Kuerzen();
   b.Kuerzen();
   this.Zaehler = a.Zaehler * b.Nenner - a.Nenner * b.Zaehler;
   this.Nenner = a.Nenner * b.Nenner;
   this.Kuerzen();
  }
  public void Multipliziere(Bruch a, Bruch b)
  {
   a.Kuerzen();
   b.Kuerzen();
   this.Zaehler = a.Zaehler * b.Zaehler;
   this.Nenner = a.Nenner * b.Nenner;
   this.Kuerzen();
  }
  #endregion
  #region overloadedOperators
  public static Bruch operator +(Bruch a, Bruch b)
  {
   Bruch x = new Bruch();
   x.Addiere(a, b);
   return x;
  }
  public static Bruch operator -(Bruch a, Bruch b)
  {
   Bruch x = new Bruch();
   x.Subtrahiere(a, b);
   return x;
  }
  public static Bruch operator *(Bruch a, Bruch b)
  {
   Bruch x = new Bruch();
   x.Multipliziere(a, b);
   return x;
  }
  public static Bruch operator /(Bruch a, Bruch b)
  {
   Bruch x = new Bruch();
   x.Dividiere(a, b);
   return x;
  }
  public static bool operator >(Bruch a, Bruch b)
  {
   Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
   Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
   bool x = false;
   if (a1.Zaehler > b1.Zaehler) x = true;
   return x;
  }
  public static bool operator <(Bruch a, Bruch b)
  {
   Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
   Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
   bool x = false;
   if (a1.Zaehler < b1.Zaehler) x = true;
   return x;
  }
  public static bool operator >=(Bruch a, Bruch b)
  {
   Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
   Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
   bool x = false;
   if (a1.Zaehler >= b1.Zaehler) x = true;
   return x;
  }
  public static bool operator <=(Bruch a, Bruch b)
  {
   Bruch a1 = new Bruch(a.Zaehler * b.Nenner, a.Nenner * b.Nenner);
   Bruch b1 = new Bruch(b.Zaehler * a.Nenner, a.Nenner * b.Nenner);
   bool x = false;
   if (a1.Zaehler <= b1.Zaehler) x = true;
   return x;
  }
  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;
  }
  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;
  }
  // =
  public override bool Equals(object obj)
  {
   Bruch b = obj as Bruch;
   return true;
  }
  public override int GetHashCode()
  {
   return base.GetHashCode();
  }
  #endregion
 }
}

Instanziierung und Aufruf


  static void DelegateDemo_Bruch()
  {
   Bruch a = new Bruch(57, 95);
   a.NennerIstNull += new EventHandler(Bruch_NennerIstNull);
   Bruch b = new Bruch(171, 361);
   b.NennerIstNull += new EventHandler(Bruch_NennerIstNull);
   Bruch c = a + b;
   Console.WriteLine($"{a} + {b} = {c}");
   // c: Konstruktoraufruf bei jeder Zuweisung
   c = a - b;
   Console.WriteLine($"{a} - {b} = {c}");
   c = a * b;
   Console.WriteLine($"{a} * {b} = {c}");
   c = a / b;
   Console.WriteLine($"{a} / {b} = {c}");
   Console.WriteLine("SETZE NENNER VON B AUF 0");
   b.Nenner = 0;
   Console.WriteLine("SETZE NENNER VON C AUF 0");
   c = new Bruch(0,0, new EventHandler(Bruch_NennerIstNull));
   Console.WriteLine($"{c}");
  }

Für den EventHandler benötigen Sie noch die passende Methode:


  private static void Bruch_NennerIstNull(object sender, EventArgs e)
  {
   Console.WriteLine($"EVENTHANDLER: DER NENNER IST NULL: 
             {sender}; eventargs: {e.ToString()}");
  }

Das Ergebnis:


3 / 5 + 9 / 19 = 102 / 95
3 / 5 - 9 / 19 = 12 / 95
3 / 5 * 9 / 19 = 27 / 95
3 / 5 / 9 / 19 = 19 / 15
SETZE NENNER VON B AUF 0
EVENTHANDLER: DER NENNER IST NULL: 9 / 0; eventargs: System.EventArgs
SETZE NENNER VON C AUF 0
EVENTHANDLER: DER NENNER IST NULL: 0; eventargs: System.EventArgs
0

Reflection, Invoking, Attribute


  static void Bruch_Attribute_Demo()
  {
   Bruch b = new Bruch(33, 44);
   Type t = b.GetType();
   Console.WriteLine(t.FullName);
   foreach (System.Reflection.MethodInfo mi in t.GetMethods())
   {
    Console.WriteLine("Methode: {0} {1}", mi.ReturnType.Name, mi.Name);
    foreach (System.Reflection.ParameterInfo pi in mi.GetParameters())
    {
     Console.WriteLine($"\tParameter: {pi.ParameterType.Name} {pi.Name}");
    }
    if (mi.Name == "Kuerzen")
    {
     Console.WriteLine("\n============INVOKING START==================");
     mi.Invoke(b, null);
     Console.WriteLine(b);
     Console.WriteLine("============INVOKING ENDE==================\n");
    }
   }
   Developer[] MyAttribute = (Developer[])Attribute.GetCustomAttributes(t, 
                             typeof(Developer));
   if (MyAttribute.Length == 0)
   {
    Console.WriteLine("The attribute was not found.");
   }
   else
   {
    for (int i = 0; i < MyAttribute.Length; i++)
    { // Aufruf der ToString-Methode
     Console.WriteLine($"DerDeveloper ist: {MyAttribute[i]}.");
    }
   }
  }

Das Ergebnis:


CSharpSchulung.Bruch
Methode: Int32 get_Zaehler
Methode: Void set_Zaehler
  Parameter: Int32 value
Methode: Int32 get_Nenner
Methode: Void set_Nenner
  Parameter: Int32 value
Methode: Void add_NennerIstNull
  Parameter: EventHandler value
Methode: Void remove_NennerIstNull
  Parameter: EventHandler value
Methode: String ToString
Methode: Void Kuerzen
============INVOKING START==================
3 / 4
============INVOKING ENDE==================
Methode: Void Addiere
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Void Dividiere
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Void Subtrahiere
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Void Multipliziere
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Bruch op_Addition
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Bruch op_Subtraction
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Bruch op_Multiply
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Bruch op_Division
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Boolean op_GreaterThan
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Boolean op_LessThan
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Boolean op_GreaterThanOrEqual
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Boolean op_LessThanOrEqual
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Boolean op_Equality
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Boolean op_Inequality
  Parameter: Bruch a
  Parameter: Bruch b
Methode: Boolean Equals
  Parameter: Object obj
Methode: Int32 GetHashCode
Methode: Type GetType
Der Developer ist: Developer: Wilfried Grupe, Datum: 20190101.

Die Member der Klasse Bruch können Sie auch mit der Assembly-Klasse analysieren; soweit Attribute verfügbar sind, werden auch diese angezeigt. Die Klassen MemberInfo und Assembly gehören beide zum Namespace System.Reflection.


using System.Reflection;
Assembly a = Assembly.GetExecutingAssembly();
Type t2 = a.GetType("CSharpSchulung.Bruch");
foreach (MemberInfo m in t2.GetMembers())
{
  Console.WriteLine($"Member: {m}");
  foreach (Attribute at in m.GetCustomAttributes(true))
  {
    Console.WriteLine($"\tAttribute: {at}");
  }
}

Das Resultat lautet hier:


DerDeveloper ist: Developer: Wilfried Grupe, Datum: 20190101.
Member: Int32 get_Zaehler()
Member: Void set_Zaehler(Int32)
Member: Int32 get_Nenner()
Member: Void set_Nenner(Int32)
Member: Void add_NennerIstNull(System.EventHandler)
    Attribute: System.Runtime.CompilerServices.CompilerGeneratedAttribute
Member: Void remove_NennerIstNull(System.EventHandler)
    Attribute: System.Runtime.CompilerServices.CompilerGeneratedAttribute
Member: System.String ToString()
Member: Void Kuerzen()
    Attribute: Developer: Wilfried Grupe, Datum: 20190125
Member: Void Addiere(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Void Dividiere(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Void Subtrahiere(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Void Multipliziere(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: CSharpSchulung.Bruch op_Addition(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: CSharpSchulung.Bruch op_Subtraction(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: CSharpSchulung.Bruch op_Multiply(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: CSharpSchulung.Bruch op_Division(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Boolean op_GreaterThan(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Boolean op_LessThan(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Boolean op_GreaterThanOrEqual(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Boolean op_LessThanOrEqual(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Boolean op_Equality(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Boolean op_Inequality(CSharpSchulung.Bruch, CSharpSchulung.Bruch)
Member: Boolean Equals(System.Object)
Member: Int32 GetHashCode()
Member: System.Type GetType()
    Attribute: System.Security.SecuritySafeCriticalAttribute
    Attribute: __DynamicallyInvokableAttribute
Member: Void .ctor()
Member: Void .ctor(Int32, Int32)
Member: Void .ctor(Int32, Int32, System.EventHandler)
    Attribute: Developer: Wilfried Grupe, Datum: 20190125
Member: Int32 Zaehler
Member: Int32 Nenner
Member: System.EventHandler NennerIstNull

wg / 4. 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_Bruchklasse_mit_Event.html