Kursvorbereitung / Bruch-Klasse mit EventHandler

Bruch-Klasse mit EventHandler

Bruch-Klasse mit EventHandler

Auf dieser Seite:

Aufruf:


        #region Delegates
        static void Ausgeben(string s, int i)
        {
            Console.WriteLine("{0} {1}", s, i);
        }
        static void Ausgeben(string s)
        {
            Console.WriteLine("{0}", s);
        }
        /// <summary>Funktionszeiger auf beliebige Methode 
        /// mit parameterliste string / int
        /// und Rückgabetyp void.</summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public delegate void abg(string x, int y);
        static void DelegateDemo1()
        {
            // Funktionszeiger aus Ausgeben
            abg y = new abg(Ausgeben);
            y("Moin Moin", 99);
        }
        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("{0} + {1} = {2}", a, b, c);
            // c: Konstruktoraufruf bei jeder Zuweisung
            c = a - b;
            Console.WriteLine("{0} - {1} = {2}", a, b, c);
            c = a * b;
            Console.WriteLine("{0} * {1} = {2}", a, b, c);
            c = a / b;
            Console.WriteLine("{0} / {1} = {2}", a, b, c);
            Console.WriteLine("SETZE NENNER VON B AUF 0");
            c = new Bruch();
            b.Nenner = 0;
            c.NennerIstNull += new EventHandler(Bruch_NennerIstNull);
            // funktioniert:
            // c.Multipliziere(a, b);
            // Achtung, neue Instanz, funktioniert nicht!!!
            c = a * b;
            Console.WriteLine("{0} * {1} = {2}", a, b, c);
        }
        /// <summary>EVENTHANDLER</summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        static void Bruch_NennerIstNull(object sender, EventArgs e)
        {
            Console.WriteLine("DER NENNER IST NULL: {0}; eventargs: {1}", sender, e.ToString());
        } 
        #endregion

Die Bruchklasse:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace csharpkomplett
{
    public class Developer : Attribute
    {
        private string nachname, vorname;
        public Developer(string nn, string vn)
        {
            nachname = nn;
            vorname = vn;
        }
        public override string ToString()
        {
            return String.Format("{0} {1}", vorname, nachname);
        }
    }
    [Developer("Grupe", "Wilfried")]
    public class Bruch
    {
        #region Private fields
        private int _Zaehler;
        private int _Nenner; 
        #endregion
        #region Properties
        public int Zaehler
        {
            get
            {
                return this._Zaehler;
            }
            set
            {
                this._Zaehler = value;
            }
        }
        public int Nenner
        {
            get
            {
                return this._Nenner;
            }
            set
            {
                this._Nenner = value;
                if (this._Nenner == 0) OnNennerIstNull(new EventArgs());
            }
        } 
        #endregion
        #region Constructors
        public Bruch()
        {
        }
        public Bruch(int z, int n)
        {
            this.Zaehler = z;
            this.Nenner = n;
        }
        ~Bruch()
        {
            //Console.WriteLine("Destruktor Bruch {0} / {1}", this.Zaehler, this.Nenner);
        }
        #endregion
        #region Events
        // wird in Property Nenner aufgerufen
        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);
            }
        }
        #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);
        }
        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
    }
}

Und das auch noch mit Reflection+Invoking


    class Program
    {
        static void Main(string[] args)
        {
            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("\t Parameter: {0} {1}", 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: {0}." , MyAttribute[i]);
                }
            }
            Console.ReadLine();
        }
    }

wg / 1. Mai 2018



Fragen? Anmerkungen? Tips?

Bitte nehmen Sie Kontakt zu mir auf.




Generics



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