Es ist zwangsläufig notwendig, sich vorher mit seinen Klassen auseinander zu setzen, um nicht später alles über den Haufen werfen zu müssen, wenn man merkt, dass man etwas wichtiges vergessen hat. In diesem Prozess sind sogenannte Design Patterns von absoluter Notwendigkeit! Diese Entwicklungs Muster dienen dazu, grundsätzliche Strukturen und Verfahren in Euer Programm zu bringen. Ich möchte mich im ersten Teil dieser Serie mit dem Singleton, also der Einmal-Instanzierung einer Klasse, beschäftigen.

Fängt man ein neues Projekt an, so hat man meistens einen Basis-Layer, der die Verbindungungen mit Datenbanken reglementiert (Database Access Layer [DAL]) oder Konfigurationen aus einer XML oder anderen Formaten ausliest. Gerade beim DAL ist es von bedeutender Relevanz, dass pro Anwendung nur eine einzige DAL-Initiierung erfolgen darf! Man möchte schließlich nicht 3 oder 4 Mal die gleiche Datenbank mit unterschiedlichen Objekten, mit vielleicht sogar unterschiedlichen Parametern ansprechen.

Der Design Pattern “Singleton” reglementiert die Instanzierung von Klassen. Dabei ist die theoretische Vorgehensweise sehr einfach. Wichtig ist zuersteinmal, dass wir den Konstruktor von außen nicht mehr zugänglich machen. Dieser ist nun private und kann nur vom Singleton aufgerufen werden. Soweit, so gut. Nun müssen wir uns überlegen, wie wir prüfen können, ob es bereits eine Instanz unserer Klasse gibt. Das machen wir indem wir in der Klasse eine Variable vom Typ der zu überwachenden Klasse anlegen und auf NULL setzen.

Der Singleton

private static volatile Klassenname _instance = null;
private static object m_lock = new object();
 
public static Klassenname GetInstance()
{
  if (_instance == null)
  {
    lock(m_lock)
    {
      if (_instance == null)
      {
        _instance = new Klassenname();
      }
    }
  }
 
  return _instance;
}

Diese Methodik bezeichnet auch schon den Singleton. Wir prüfen, ob eine Instanz der Klasse angelegt wurde. Ist dies nicht der Fall, sperren wir den folgenden Code für weitere Threads, die eventuell auf diese Klasse zugreifen könnten und prüfen erneut, ob eine Instanz vorliegt (DoubleLock). Ist dies nun immernoch nicht der Fall, so erzeugen wir eine neue Instanz, rufen also den Konstruktor auf.

Nun wurde die Variable _instance auf die gerade erzeugte Instanz festgelegt und kann bei jedem weiteren Aufruf von GetInstance() an das Objekt vom Typen Klassenname zurückgegeben werden. Doch wofür das alles? Ganz einfach: Wir brauchen keine Objekte mehr zwischen mehreren Klassen hin und her zu übergeben. Diese Klassen können nun mit GetInstance() einfach der vollständig initialisierte Klasse holen und mit all ihren Werten und Parametern arbeiten.

GetInstance() im Einsatz

// Aufruf der Klassen-Instanz
Klassenname myClass = Klassenname.GetInstance();
 
// Aufruf mit Hilfe eines Interfaces
IKlassenname myClass = Klassenname.GetInstance();

Diese Vorgehensweise lässt sich auch ideal erweitern, falls Ihr nur eine gewisse Anzahl an Instanzen zulassen wollte. Sowas kann gebraucht werden, wenn man Zugriff auf mehr als eine Datenbank haben möchte. In diesem Fall kann man dem Singleton noch Parameter übergeben, welche er dazu nutzen kann, ebenfalls den Konstruktor parameterisiert aufzurufen. Probiert es aus, Euch sind so gut wie keine Grenzen gesetzt!

Doch was tun, wenn genau diese Funktionen nicht mehr helfen können oder ein Workaround zu unschönem und unübersichtlichem Quelltext führen? Genau dafür bringt C# eine pfiffige Lösung: Die Erweiterungsmethoden.

Fangen wir erstmal vorne an. Erweiterungsmethoden dienen, wie der Name schon sagt, zum Erweitern von Objekten. Es können also im Prinzip jedem Objekt Funktionen nachträglich beigebracht werden. Das ist immer dann von Vorteil, wenn man komplexere Prüfungen oder Verfahren jedem Objekt verfügbar machen möchte, ohne dabei neue Klassen o.ä. zu erstellen.

Nehmen wir als Beispiel eine Variable vom Typ string. Neben vielen schönen Funktionen gäbe es aber in manchen Anwendungsgebieten auch die Notwendigkeit weiterer Funktionen. Gerade bei Textverarbeitung o.ä. wäre es gut, wenn wir eine Funktion hätten, die uns die Anzahl der Worte oder der Umlaute zurückgibt.

Dazu erstellen wir eine statische Klasse mit einer statischen Methode. Als Übergabe Parameter bekommen Erweiterungsmethoden immer ein “this” und dahinter folgt der Typ, der erweitert werden soll, samt Variablennamen für die Funktion.

Wörter zählen:

public static int WordCount(this string str)
{
  return str.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
}
 
string meinText = "Das ist nur ein kleiner Test!"
int anz = 0;
anz = meinText.WordCount()
 
// anz = 5

Schon haben wir die Möglichkeit uns die Anzahl an Wörtern zurückgeben zu lassen. Das Gleiche funktioniert auch wunderbar mit Sonderzeichen, was man gebrauchen könnte, sobald Sonderzeichen einen Fehler auslösen oder Ähnliches.

Sonderzeichen zählen:

public static int SpecialCount(this string str)
{
  return str.Split(new char[] { 'ö', 'ü', 'ä', '?' }, StringSplitOptions.RemoveEmptyEntries).Length;
}
 
string meinText = "Däs ist nür ein kleiner Teßt!"
int anz = 0;
anz = meinText.SpecialCount()
 
// anz = 3

Es gibt noch eine Vielzahl von Möglichkeiten für eine solche Funktion. Anzahl an Kommentaren, Zeilenumbrüchen und viele mehr. In manchen Einsatzgebieten ist es allerdings notwendig den eigenen Wert der Variable zu ändern und diese nicht via “return” an eine weitere Variable weiterzugeben. Leider erlaubt uns C# hier nur die Weitergabe über einen out Parameter, den wir dann nutzen können.

Werte setzen:

public static bool IsZero(this int oldValue, out int newValue, int max)
{
  if (oldValue > max)
    newValue = max;
  return true;
}
 
int zahl = 1020;
zahl.IsGreater(zahl, 1000);
 
// zahl = 1000;

Wir können bei den Erweiterungsmethoden aber nicht auf einen Return-Type verzichten. Das heißt, dass jede Funktion einen Rückgabe-Wert haben muss. Ich hoffe, ich konnte Euch diese Art der Variablen-Nutzung ein wenig näher bringen und wünsche viel Spaß beim Testen – Cherryo!

Wie immer gilt: Dies ist freier Code, Ihr könnt Ihn einsetzen, wie und wo Ihr wollt!

Doch hin und wieder ertappt man sich selber, wie man wieder in gewohnte Muster zurückfällt und auf eine ansehliche Oberfläche verzichtet. Genau hier möchte ich mit dem ersten Blog-Eintrag einhaken. Wie sollte ein solches Projekt beginnen? Was ist zu beachten?

Das Erste, womit man sich beschäftigen sollte, sofern benötigt, ist die Übergabe von Parametern und Schaltern.

Bei mir ein gern genutztes Sprichwort. In den meisten Anwendungen ist es sinnvoll, dem Nutzer die Möglichkeit zu bieten, die Nutzung der Anwendung zu optimieren, indem er Parameter oder Schalter hinzufügen kann. Ich denke, jeder hat solche Konsolenanwendungen bereits gesehen.

Programm.exe -a para1 -b para2 /schalter1 /schalter2

Diese Werte sollten optimal vom Programm abgefangen werden, ohne aber zu viel Zeit darauf zu verschwenden. Ich nutze hierfür immer gerne eine kleine Parameter-Klasse. Diese besteht aus allen Variablen, die über Parameter (int, string, char, double, etc.) oder Schalter (bool) übergeben werden können. Zusätzlich enthält sie noch zwei Funktionen mit denen es möglich ist, zu überprüfen, welche Werte ein entsprechender Parameter hat oder ob ein Schalter aktiviert ist.

Die Grundfunktionen (C#):

// Parameter auswerten
private string GetArgument(string ArgName)
{
  // Alle Parameter durchlaufen
  for (int i = 0; i < Arguments.Length; i++)
  {
    // Wurde das Keyword gefunden, Wert zurückliefern
    // Hierbei wird auf den Bindestrich geprüft und ob ein Wert folgt
    if (Arguments[i] == "-" + ArgName && Arguments.Length >= i)
    {
      return Arguments[i + 1];
    }
  }
  // Wenn nichts gefunden wurde, Leerstring zurückgeben
  return "";
}
 
// Schalter auswerten
private bool GetSwitch(string SwitchName)
{
    // Alle Parameter durchlaufen
    foreach (string item in Arguments)
    {
        // Wurde ein Schalter gefunden, TRUE zurückgeben
        // Beim Schalter prüfen wir auf den Schrägstrich
        if (item.Contains("/" + SwitchName)) return true;
    }
    return false;
}

Hiermit habe ich nun zwei Funktionen die mir, mit Übergabe der Namen der Parameter oder Schalter, die passenden Werte zurückliefern. Optimal lässt sich dies in der Parameter-Klasse im Konstruktor einbauen, so dass man direkt ein entsprechendes Objekt nutzen kann, ohne weiter auf die Funktionen zurückzugreifen.

Die gesamte Klasse (C#):

namespace MyProgramm
{
    class ArgumentHandler
    {
        // Übergabevariablen
        protected static string[] Arguments;
 
        // Variablendeklaration
        protected string para1;
        protected long para2;
        protected int para3;
 
        protected bool switch1;
        protected bool switch2;
 
        // Getter & Setter
        public string Para1 { get { return _para1; } }
        public long Para2 { get { return _para2; } }
        public int Para3 { get { return _para3; } }
 
        public bool Switch1 { get { return _switch1; } }
        public bool Switch2 { get { return _switch2; } }
 
        // Konstruktor
        public ArgumentHandler(string[] args)
        {
            Arguments = args; // Diese liefert mir meine Main-Klasse
 
            // Variableninitialisierung
            _para1 = "";
            _para2 = 0;
            _para3 = 0;
 
            _switch1 = false;
            _switch2 = false;
        }
 
        // Prüfen, ob Kernelemente gesetzt sind
        public bool CheckArguments()
        {
            try
            {
                _para1 = GetParameter("para1");
                long.TryParse(GetParameter("para2"), out _para2);
                int.TryParse(GetParameter("para3"), out _para3);
 
                _switch1 = GetSwitch("switch1");
                _switch2 = GetSwitch("switch2");
 
                // Prüfen ob vorhanden
                if (string.IsNullOrEmpty(_para1.ToString())) { return false; }
                if (_para2 <= 0) { return false; }
                if (_para3 <= 0) { return false; }
            }
 
            catch
            {
                return false;
            }
 
            return true;
        }
 
        private string GetArgument(string ArgName)
        {
            for (int i = 0; i < Arguments.Length; i++)
            {
                if (Arguments[i] == "-" + ArgName && Arguments.Length >= i)
                {
                    return Arguments[i + 1];
                }
            }
            return "";
        }
 
        private bool GetSwitch(string SwitchName)
        {
            foreach (string item in Arguments)
            {
                if (item.Contains("/" + SwitchName)) return true;
            }
            return false;
        }
    }
}

Wie immer gilt: Dies ist freier Code, Ihr könnt Ihn einsetzen, wie und wo Ihr wollt!