© best_vector/Shutterstock.com
.NET sinnvoll mit den C# Extensions erweitern

.NET sinnvoll mit den C# Extensions erweitern


Seit .NET 3.0 gibt es in C# die Möglichkeit, Klassen mit Extensions zu erweitern. Bekanntestes Beispiel sind wohl die LINQ-Abfrageoperatoren. Sie erweitern die IEnumerables durch verschiedene Abfragemethoden. Doch welche Extensions sind im täglichen Einsatz für uns wirklich sinnvoll und wie sollten wir sie am besten einsetzen? Wie können Extensions unseren Programmiereralltag vereinfachen?

Microsofts C# Extensions gibt es nun schon eine ganze Weile, und auf verschiedene Weise haben wir sie alle schon einmal eingesetzt oder zumindest genutzt, denn Microsoft selbst setzt in vielen Bereichen darauf. Die Idee dahinter ist einfach: Extensions sollen uns die Möglichkeit geben, selbst Hand anzulegen, wenn eine bestimmte Funktionalität gefragt ist, aber noch nicht existiert. Sie sollen die Aufrufe von Quelltext vereinfachen und unsere Anwendungen zu einer höheren Wartbarkeit führen. Das soll dann noch unter der Prämisse entstehen, die ursprüngliche Komponente nicht verändern zu können, keine davon abgeleitete Komponente erstellen und die ursprüngliche Komponente dennoch wie gehabt nutzen zu wollen. Steigen wir mit dem Beispiel aus Listing 1 in das Thema ein.

Listing 1

// String-Variable mit mehreren Leerzeichen
string text = "        ";
 
// Ohne Extension
if(!string.IsNullOrEmpty(text) && text.Trim() != "")
{
  // Tue etwas
}
 
// Mit Extension vor .NET 4.0
if(!text.IsNullOrWhiteSpace())
{
  // Tue etwas
}
 
// Ohne Extension seit .NET 4.0
if(!string.IsNullOrWhiteSpace(text))
{
  // Tue etwas
}

Noch immer kommt es häufig vor, dass wir Objekte vom Typ String haben, die ausschließlich aus Leerzeichen bestehende Werte enthalten. Das kann zum Beispiel daran liegen, dass dieser Wert aus einer Datenbank mit dem Werttyp char und einer festen Länge von acht Zeichen kommt, oder auch von einem Formular auf einer Webseite, das mit falschen Eingabewerten übermittelt wurde.

Eine sichere Behandlung des Inhalts der Variable muss hier zuerst NULL ausschließen, um Fehler bei der weiteren Überprüfung zu verhindern. Erst im zweiten Schritt kann die eigentliche Abfrage durchgeführt werden, da der Aufruf von Trim() vom String-Objekt nur dann gelingt, wenn das Objekt nicht NULL ist. Durch die Dopplung der Abfragen auf eine Variable wird der Quelltext gleich unübersichtlicher, was gerade bei mehreren Überprüfungen in einem If-Block zu schlecht lesbarem Code führt. Eine Extension des String-Objekts bietet hier eine gute Abhilfe, da es uns die Abfrage aller wichtigen Werte von einem einzelnen Methodenaufruf der Variable selbst ermöglicht. Seit .NET 4.0 gibt es von diesem Beispiel eine eigene Methode, die Teil des statischen Bereichs der String-Klasse ist. Und selbst dieser Aufruf wird durch eine Extension les- und vor allem auch schreibbarer.

Extensions ermöglichen uns also nicht nur, Quelltext lesbarer und wartbarer zu gestalten, sondern auch, ihn schreibbarer zu machen. Wir alle kennen Momente, in denen wir mehrfach „um die Ecke“ denken müssen und uns beim Programmieren die Finger verknoten, obwohl es viel einfacher gewesen wäre, wenn die gewünschte Funktionalität als einfache Methode der gerade verwendeten Klasse existieren würde. Extensions bieten uns auch oder gerade in diesen Fällen eine deutliche Verbesserung des .NET Frameworks.

In diesem Artikel stelle ich viele sinnvolle Möglichkeiten vor, die in beinahe jedem Projekt zum Einsatz kommen können und die Arbeit in vielen Bereichen ungemein erleichtern.

Die wichtigsten Extensions

Beginnen wir mit den grundlegendsten Extensions, den Erweiterungen der Werttypen wie string, int oder auch byte. Im erweiterten Kreis dazu zählt auch das DateTime-Objekt. Dazu die wichtigste Frage vorweg: Was wollen wir überhaupt erreichen? Die Codequalität und Übersichtlichkeit heben? Oder uns unsere Arbeit erleichtern? Als Antwort darauf gibt es nur eine Option: all das zusammen.

Beginnen wir mit dem String-Objekt. Hier gibt es so viele Einsatzgebiete und Variationen, dass wir zuallererst herausfinden müssen, welche Bereiche wir überhaupt erweitern wollen. Ich habe mich dabei auf die folgenden drei grundlegenden Bereiche festgelegt: Validierung, Konvertierung und Verarbeitung.

String-Werte sind nicht nur der häufigste Datentyp, sondern auch der variabelste. Er kann beinahe jede Form von Daten enthalten. Seien es Zahlen, boolesche Werte, verschlüsselte und unverschlüsselte Texte oder auch nur einfache E-Mail-Adressen. Dadurch entstehen aber auch Fehlerquellen und diese wollen wir verhindern. Daher gilt es, Inhalte zu überprüfen, sie zu validieren.

Am häufigsten wird der Test auf numerische Zahlen und leere, nicht initialisierte Strings benötigt. Die Methode IsNumeric prüft, ob der Inhalt des gegebenen Strings eine Zahl ist. Die Methode IsNullOrWhiteSpace habe ich in der Einleitung schon angesprochen, sie prüft auf NULL und auf leere oder leer erscheinende Inhalte.

Sehr häufig kommen auch boolesche Werte vor, gerade da heute Inhalte aus verschiedenen Quellen zusammengetragen werden und jeder etwas anderes unter True und False versteht. Sei es 1/0, Ja/Nein, Valid/Invalid oder auch nur ein kleingeschriebenes true. Die Methode IsExpressionTrue versucht hier die gängigsten Variationen anzuwenden und den Inhalt darauf zu überprüfen. Als weitere häufig benötigte Validierung steht die IsEmail-Methode zur Verfügung (Listing 2).

Listing 2

public static bool IsNumeric(this string instance)
{
  Regex pattern = new Regex(@"^[0-9,.]+$");
  return pattern.IsMatch(instance.Trim());
}
 
public static bool IsNullOrWhiteSpace(this string instance)
{
  // Eigene Implementierung verwenden, um Kompatibilität zu früheren Versionen 	  // zu behalten
  if(instance != null)
  {
    for(int i = 0; i < instance.Length; i++)
    {
      if(instance[i] != ' ')
      {
        return false;
      }
    }
  }
  
  return true;
}
 
public static bool IsExpressionTrue(this string instance)
{
  // NULL gilt selbstverständlich als False
  if(instance == null)
  {
    Return false;
  }
  
  // Der String muss getrimmt werden, da "true" ebenfalls als True erkannt werden 	  // soll
  string expression = instance.Trim().ToLower(CultureInfo.CurrentCulture);
  
  // first check if the string is empty
  if(expression.IsNullOrWhiteSpace())
  {
    return false;
  }
  
  // Erst auf Zahlen überprüfen, da positive Zahlen immer als True gelten
  if(expression.IsNumeric())
  {
    if(...

headline from sands settings