101 C# Tipp – Interface – Regel – lose Kopplung

Als ich frisch angefangen habe mit OOP zu arbeiten, hatte ich sehr oft die Vererbung mehr bevorzugt als zum Beispiel Interfaces oder abstrakte Kassen. Ich konnte den Nutzen als Anfänger nicht wirklich sehen.

In diesem einfachen Beispiel möchte ich versuchen denn Nutzen von einem Interface einfach darzustellen. Interface oder Abstrakte Klassen helfen uns Regeln und eine Struktur in unsere Softwarelösung zu integrieren. Wenn wir ein Interface oder eine Abstrakte Klasse in unsere Klasse verwenden, müssen wir die Methoden Implementieren die vordefiniert sind. Wir sind also an eine Regel gebunden.

Das schöne daran ist, wir können diese Regeln aber auch erweitern und somit je nach Fall anpassen. Es ist eigentlich ein Spezialisierung von unserem Interface.

Zuerst erstellen wir ein Interface, in unserem Fall heisst die jetzt IAccount. Die sieht dann so aus:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ch.starwolf.tipp.Interface
{
    interface IAccount
    {
        double Deposit      { set;} // Einzahlung
        double Payout       { set;} // Auszahlung
        double Balance      { get;} // Saldo
        int AccountID       { set; get;} //Konto
        int AccountOwner { set; get; } //Account Besitzer
        void CalBalance(); // Berechnung des Saldos
    }
}//end of namespace

In diesem Interface sind jetzt vier Eigenschaften und eine Methode definiert. Das ganze soll ein Regel für ein Konto darstellen. Es ist sehr vereinfacht Dargestellt. Wenn wir dieses Interface IAccount jetzt verwenden möchten in unserer Klasse,  müssen wir alle Definitionen implementieren.  In unserem Fall heisst die Klasse AccountBasic. Das sieht dann so aus:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using ch.starwolf.tipp.Interface;

namespace ch.starwolf.tipp
{
    class AccountBasic : IAccount
    {
        private double _deposit;
        private double _payout;
        private double _balance;
        private int _accountID;
        private int _accountOwner;

        public AccountBasic() {
            this._balance = 0;
        }

        public double Deposit {
            set  { _deposit = value;}
        }// Einzahlung

        public double Payout {
            set { _payout = value; }
        }// Auszahlung

        public double Balance {
            get { return _balance; }
        }// Saldo

        public int AccountID {
            set { _accountID = value;}
            get { return _accountID; }
        }//Konto

        public int AccountOwner {
            set { _accountOwner = value; }
            get { return _accountOwner; }
        }//Account Besitzer

        public void CalBalance() {
            Console.WriteLine("Balance Methode von Accountbasic");
            Console.WriteLine("Object : "+this.ToString());
            Console.WriteLine(" ");
            // Berechnung des Saldos
        }
    }//end of class
}//end of namespace

So haben wir es gelernt – nichts neues. Jetzt machen wir eine Spezialisierung von einem Interface, das ganze ist sehr einfach.

In unserem Beispiel möchten wir auch andere Konto Arten verwenden, die Ihre eigenen Berechnungen haben, aber trotzdem von der Art ein Konto sind. Zudem möchten wir eine Sicherheit haben, dass das neue Konto eine minimale Grund Regel aufweist. Wir verwenden sozusagen die Vererbung direkt auf dem neuem Interface. Wir könnten das ganze auch direkt auf einer Klasse machen.

Ich finde aber diese Variante sehr elegant und ist bei einer Anpassung Zentraler geregelt. Es hilft auch die Abhängigkeiten untereinander einfacher zu lesen. Das neue Interface heisst jetzt IAccountStock und ist eine Spezialisierung von IAccount. Das ganze sieht so aus:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ch.starwolf.tipp.Interface
{
    interface IAccountStock : IAccount
    {

        int ShareNumber         {set; get;} // Anzahl
        string ShareSymbol      {set; get;} // Symbol Aktie
        void CalBuy();    //Berechnung Kauf

    }
}

Das ganze ist wider sehr einfach gehalten – hoffe ich ^^ .
Wenn wir jetzt das neue Interface IAccountStock verwenden möchten für eine neue Klasse, müssen wir alle Methoden von IAccount Implementieren (die Basis Regel) . Zusätzlich müssen wir auch jetzt die zwei Eigenschaften und die Methode aus der Spezialisierung Implementieren.

In unserem Beispiel sieht das ganze so aus für die Klasse AccountStock:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using ch.starwolf.tipp.Interface;

namespace ch.starwolf.tipp
{
    class AccountStock : IAccountStock
    {
        private double _deposit;
        private double _payout;
        private double _balance;
        private int _accountID;
        private int _accountOwner;
        private int _shareNunber;
        private string _shareSymbol;

        public AccountStock() {
            this._balance = 0;
        }

        #region IAccount implementation
        public double Deposit {
            set  { _deposit = value;}
        }// Einzahlung

        public double Payout {
            set { _payout = value; }
        }// Auszahlung

        public double Balance {
            get { return _balance; }
        }// Saldo

        public int AccountID {
            set { _accountID = value;}
            get { return _accountID; }
        }//Konto

        public int AccountOwner {
            set { _accountOwner = value; }
            get { return _accountOwner; }
        }//Account Besitzer

        public void CalBalance() {
            Console.WriteLine("Balance Methode von AccountStock");
            Console.WriteLine("Object : " + this.ToString());
            Console.WriteLine(" ");
            //Berechnung des Saldos
        }
        #endregion
        #region IAccountStock implementation

        public int ShareNumber {
            set {_shareNunber = value;}
            get{return _shareNunber;}
        } // Anzahl

        public string ShareSymbol {
            set{_shareSymbol = value;}
            get{ return _shareSymbol;}
        } // Symbol Aktie

        public void CalBuy()
        {
            Console.WriteLine("Buy Methode von AccountStock");
            Console.WriteLine("Object : " + this.ToString());
            Console.WriteLine(" ");
            //Berechnung Kauf
        }
        #endregion
    }//end of class
}//end of namespace

Ich hab dazu noch ein kleines Programm gemacht um zu zeigen wie die Regeln greifen. Das Programm ist sehr einfach aufgebaut.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using ch.starwolf.tipp.Interface;

namespace ch.starwolf.tipp
{
    class Program
    {
        static void Main(string[] args) {
            Program oProgram = new Program();

           AccountStock oStock = new AccountStock();
           AccountBasic oBasic = new AccountBasic();

           oProgram.ShowAccount(oStock);
           oProgram.ShowAccount(oBasic);

           oProgram.ShowStockmarket(oStock);

           Console.ReadLine();
        }

        private void ShowStockmarket(IAccountStock param) {
            param.CalBuy();
        }

        private void ShowAccount(IAccount param) {
           param.CalBalance();
        }

    }//end of class
}//end of namespace

Hier sehen wir auch das wir die Programm Methoden ShowStockmarket und ShowAccount ein Interface Type erwarten. Das ganze hat den Vorteil einer losen Kopplung. Was in der OOP Welt immer gut ist, um Stare Strukturen in unserer Software zu vermeiden.
Wir müssen also nicht eine spezifisches Objekt übergeben sondern ein Objekt wo eine Implementation vom gewünschten Interface besitzt.

Das schöne an der ganzen Sache ist, das die individuelle Berechnung wo wir in der Klasse definiert haben verwendet wird. In der Methode ShowAccount wird die Methode CalBalance ausgeführt. Die CalBalance verwendet immer die Implementierte Methode von der eigenen Klasse. Man sieht das schön im Output:

Output Interface Example

So können wir also auf einfache Art sehr elegante Strukturen bauen. Die Regeln helfen uns eine Konsistenz in der Software zu erhalten. Zudem haben wir gesehen es förder auch die lose Kopplung in unserer Software. Das ganze ist sehr einfach gehalten und als Tipp gedacht. Alle Arten von Lösungen haben Ihre Vor- oder Nachteile, bis jetzt war dieser Ansatz bei mir immer Hilfreich und sollte einfach zeigen wie man mit Interfaces arbeiten kann.

Das Beispiel habe ich mit Visual Studio 2010 Express erstellt – das kleine Projekt könnt hier herunterladen: Interface001

Gruss @all