Programmieren

[Palladin007]

Ein Interface ist in C# was ganz anderes. Da ist das eine, ich sag mal extrem abgespeckte Klasse.
Sie enthält keinen Programm-Code, nur die Methoden, Konstruktoren, Eigenschaften und Attribut und stellt damit sicher, dass eine Klasse, die von diesem Interface erbt, auch ganz sicher diese Elemente enthält.

das hängt jetzt wieder mit der Polimorphie zusammen, deshalb erkläre ich das jetzt nicht ausführlich.



Also Delegaten-Beispiel:

Code:

namespace Namensraum
{
    public delegate double CalculateHandler(double FirstNumber, double SecondNumber);

    static class Rechnen
    {
        static void Main()
        {
            CalculateHandler calculate = new CalculateHandler(Plus);

            double Ergebnis = calculate(5, 7);

            Console.WriteLine(Ergebnis);
            Console.Read();
        }


        static double Plus(double Summand1, double Summand2)
        {
            return Summand1 + Summand2;
        }
    }
}

Es muss zu erst ein MethodenHandler als Typ definiert werden. Da sind auch alle nötigen Infos drin, nämlich Rückgabewert und die Parameter.
Dann kannst du ganz normal eine Variable vom Typ des Delegaten machen und diese Variable dann wie eine Methode aufrufen.

Damit werden meistens Events gelöst, das heißt, es wird in einer Klasse ein Event (Ereignis) ausgelöst. Die Variable des entsprechenden Delegaten wird also auf gerufen. Wenn der Nutzer eine Methode darin gekapselt hat, wird die ausgeführt. Wenn nicht, passiert gar nichts. Das gibt dem Nutzer die Möglichkeit, auf bestimmte Dinge direkt reagieren zu können und die Forms-Programmierung (Windows-Fenster) wäre ohne Events gar nicht möglich, da jeder Mucks mit einem Event bearbeitet werden kann, oder einfach nur ein Button-Click.



Hab aber noch was interessanteres:
Man kann ja Methoden überladen. Einfach zwei Methoden mit dem selben Namen, aber unterschiedlichen Parametern. Sie wird dann nur einmal aufgeführt, akzeptiert aber verschiedene Kombinationen von Parametern.
Das geht auch mit Operatoren.
Der Operator == gibt ja zurück, ob zwei Werte/Referenzen gleich sind, oder nicht.
Man kann diesen Operator auch überschreiben und dann z.B. genau sagen, wie die beiden Werte/Referenzen gleich sind.
Bei Werten wäre das sinnlos, aber da zwei verschiedene Referenzen niemals gleich sind, aber gleiche Eigenschaften haben können, könnte man spezielle Eigenschaften von dem ==-Operator vergleichen lassen und bekommt das richtige Ergebnis.

---

Zur Erklärung des Beispiels oben:

Das Programm beginnt immer bei Main.
Und "Console" ist die Klasse, die die einfache Windows-Konsole darstellt. WriteLine schreibt ne Zeile und Read liest ein Zeichen, allerdings nutze ich es hier nur zum Warten.


Hier mal ein Beispiel, wie ich den Operator + überlade:

Code:

public class Werte
    {
        public double Wert { get; set; }

        public Werte(double Wert)
        {
            this.Wert = Wert;
        }

        public static double operator +(Werte Wert1, Werte Wert2)
        {
            return Wert1.Wert + Wert2.Wert;
        }
    }

    public class Rechnen
    {
        static void Main()
        {
            Werte w1 = new Werte(5);
            Werte w2 = new Werte(7);

            Console.WriteLine(w1 + w2);

            Console.Read();
        }
    }

Wenn ich in der Klasse Werte die Operator-Überladung weg gelassen hätte, würde ich einen Fehler in der Main-Methode bekommen, da man zwei Referenzen nicht addieren kann.

Das Thema ist recht besucht, kein Grund also, nach 4 Stunden einen Doppelpost zu machen // Acuros