Neues in .NET Codename "Swinomish"

Geschrieben von: Bernhard Spuida
Kategorie: Aprilscherz

Lange hat es gedauert und die Gerüchteküche brodelt dementsprechend. Die nächste Version des .NET Framework steht vor der Tür, noch umfangreicher, das steht fest. Aber was bringt uns Microsoft danach? Von Generics in .NET "Whidbey" hat schon fast jeder gehört, aber was wird sich danach in diesen und anderen Bereichen tun? In diesem Artikel betrachten wir einige der innovativsten Features des kommenden .NET "Swinomish", das wie seine Vorgänger seinen Codenamen von einem Landmark aus der Pudget Sound Area rund um Seattle erhalten hat.

Exception Handling

Die strukturierte Behandlung von Exceptions war schon immer eine der Stärken des .NET Frameworks. Mit dem try / catch Block lassen sich Exceptions hervorragend behandeln. Bisher werden die catch Blöcke ausgeführt wenn eine Exception auftritt. Mit einem finally kann ich Code spezifizieren der in jedem Fall ausgeführt werden soll, egal ob Exception oder nicht. Dieses Konstrukt wird nun um einen miss Block erweitert, der nur dann zur Ausführung kommt wenn keine Exception aufgetreten ist. Wir sind also noch flexibler als bisher:

try
{
   Seismic.OpenSEGYFile(file, traces, offset); // Seismic datasets can get *huge*
}
// catch  a possible OutOfMemoryException
catch (OutOfMemoryException e)
{
   Seismic.WriteLog("Ran out of memory opening data set: {0}", e);
}
// handle other eventual exceptions gracefully
catch (Exception e)
{
   Seismic.WriteLine("An exception occurred: {0}", e);
}
miss (Exception e) // no exception whatsoever, so we can proceed
{
   // now that we have obtained the data, let us prepare the workbench windows
   Seismic.InitWorkbench(file, configstatefile);
}
finally
{
   // close the file, it will be open whether or not we loaded successfully
   Seismic.CloseSEGYFile(file);
}

Durch das neue miss() haben wir noch mehr Kontrolle über die strukturierte Behandlung von Exceptions als in bisherigen .NET-Versionen (Whidbey und Orcas eingeschlossen). Wichtig ist daß hier nur ein allgemeines miss() vorgezeigt wird, aber analog zu den catch Statements auch das Nichtauftreten einzelner Exceptiontypen behandelt werden kann. Eine einfache aber geniale Erweiterung des Frameworks. Wer jetzt noch instabile Fehlerbehandlung implementiert, dem ist nicht mehr zu helfen.

Generics

Eine wichtige Neuerung in .NET "Whidbey" ist (im Rahmen dieses Artikels wäre es eigentlich angebracht davon bereits in Vergangenheitsform zu sprechen) die Einführung von Generics bzw. Generika - ein Thema das einerseits Sprachtheoretikern und echten Informatikern sehr am Herzen liegt, andererseits aber tatsächlich von großem Nutzen für den praktizierenden Programmierer ist. Generika sind in Java schon seit einiger Zeit bekannt, werden aber jetzt endlich auch in .NET eingeführt. Einfach gesagt, erlaubt mir der Einsatz von Generika das Schreiben von allgemeinen Funktionen die erst zur Laufzeit Typen zugewiesen bekommen. Ich erspare mir also die mehrfache Implementation von nahezu identischem Code - ein gewaltiger Produktivitässprung und ein weiterer Schritt zur Verminderung von Fehlerquellen.

Das Konzept ist ein wenig gewöhnungsbedürftig, aber letzlich klar. Ein primitives Beispiel eines Generikums wäre:

public class Thingie<T> {
  T t;
  public T Val{
    get{
         return t;
       }
    set{
         t=value;
       }
  }
}

Wichtig ist dabei das Paar spitze Klammern um den Typ T von Thingie. Dadurch wird Thingie als generisch deklariert. Wir können nun im Aufruf zur Laufzeit Thingie wie folgt mit unterschiedlichen Typen instanzieren:

public class ThingiesMain {
  public static void Main() {
    // String-version unseres Generikums
    Thingie<string> mystring = new Thingie<string>();
    // Wert setzen
    mystring.Val = "Hallo";   
    // Ausgeben
    System.Console.WriteLine(mystring.Val);
    // Typ ausgeben
    System.Console.WriteLine(mystring.Val.GetType());
    
    // Noch eine Instanz unseres Generikums, diesmal ein anderer Typ
    Thingie<int> myint  = new Thingie<int>();
    // Wert setzen
    myint.Val = 42;
    // Ausgeben
    System.Console.WriteLine(myint.Val);
    // Typ ausgeben
    System.Console.WriteLine(myint.Val.GetType());   
  }
}

Simpel, nicht wahr? Die Ausgabe ist wie folgt:

Hallo
System.String
42
System.Int32

Dies ist zwar ein gewaltiger Schritt nach vorne, von dem wir in "Whidbey" profitieren werden, allerdings geht Microsoft bei der Erweiterung des Frameworks "Swinomish" noch einen wichtigen Schritt weiter.

Specifics

Was, wenn eine bestimmte Variable auf keinen Fall, egal unter welchen Umständen in einen anderen Typ gecastet werden darf? Unter Aspekten der Systemstabilität und Codesicherheit wäre dies häufig wünschenswert. Daher wird sozusagen das genaue Gegenstück zu den Generika eingeführt: Specifics bzw. Spezifika. Die Typdefinition ist in etwa analog zu den Generika:

public class SpecificThingie>T< {
  T t;
  public T Val{
    get{
         return t;
       }
    set{
         t=value;
       }
  }
}

Der einzige Unterschied ist die Vertauschung der spitzen Klammern um T. Ansonsten gibt es keine Auffälligkeiten. Probieren wir nun aus was passiert wenn wir versuchen LockedThingie zu instanzieren und anschliessend auf einen anderen Typen zu casten:

public class LockedThingiesMain {
  public static void Main() {
    // String-version unseres Generikums
    LockedThingie>int< myint = new LockedThingie>int<();
    // Wert setzen
    myint.Val = "Hallo";   
    // Ausgeben
    System.Console.WriteLine(myint.Val);
    // Typ ausgeben
    System.Console.WriteLine(myint.Val.GetType());
    
    // Noch eine Instanz unseres Generikums, diesmal ein anderer Typ - geht nicht mehr.
    // Compilerfehler
    LockedThingie>float< myfloat  = new LockedThingie>float<();
    // Wert setzen
    myfloat.Val = 47.11;
    // Ausgeben
    System.Console.WriteLine(myfloat.Val);
    // Typ ausgeben
    System.Console.WriteLine(myfloat.Val.GetType());
		
    // Ein Castversuch, geht ebenfalls schief mit Compilerfehler
    float myfloat2 = (float) LockedThingie.myint;
    // Ausgeben
    System.Console.WriteLine(myfloat2.Val);
    // Typ ausgeben
    System.Console.Writeline(myfloat2.Val.GetType());
  }
}

Besonders schön ist der Ansatz nach der ersten Zuweisung eines Spezifikums den Typ zu sperren, so daß weder neue Spezifika mit anderem Typ instanziert werden können (das wären ja Generika), noch ein instanziertes Spezifikum in einen anderen Typ gecastet werden kann. Weitere Spezifika des erst zugewiesenen Typs können allerdings angelegt werden. Fehler durch Typzuweisungen gehören somit der Vergangenheit an. Ein großer Schritt in Richtung solider Code ohne Anstrengung.

Schleifen

Auch am Sprachumfang von C# werden behutsame Erweiterungen vorgenommen, speziell werden Kurzformen für existierende Schleifen mit negativen Laufbedingungen eingeführt. Aus do {} while() wird so do {} unless(). Diese Neuerung dient dazu die Formulierung der Laufbedingungen klarer und besser wartbar zu gestalten:

class LoopDemo
{
   public static void Main()
   {
     int i = 10;

    // We count down and print until we reach i = 5
    do
    {
      Console.WriteLine("Counter: {0}",i);
      i--;
    } while (i != 5);

    // Same thing with unless
    int j = 10;
    do
    {
      Console.WriteLine("Counter: {0}",j];
      j--;
    } unless (i = 5);
   }
}		 	

Der Code wird so nicht nur klarer, sondern der Verzicht auf die Verneinung erzeugt auch einen leichten Performancegewinn der sich zumindest bei grösseren Schleifenläufen positiv bemerkbar macht. Analog zu do {} unless() gibt es weiters forexcept() {} als Ergänzng zu foreach() {}.

Schlußbemerkung

Das waren nur einige der augenfälligsten Neuerungen in .NET "Swinomish" (4.0?). Es ist mit Sicherheit anzunehmen daß sich noch einiges bis zur endgültigen Freigabe ändern wird. Vor allem ist anzunehmen daß Microsoft im Rahmen der Bemühungen um sicheres Programmieren noch weiter auf absichernde Konzepte wie Spezifika setzen wird. Die Zukunft wird spannend.

Verwandte Artikel

Debugging in der Tiefe
Hochleistungskompression mit .NET-Bordmitteln

Wenn Sie jetzt Fragen haben...

Wenn Sie Fragen rund um die in diesem Artikel vorgestellte Technologie haben, dann schauen Sie einfach bei uns in den Community Foren der deutschen .NET Community vorbei. Die Teilnehmer helfen Ihnen gerne, wenn Sie sich zur im Artikel vorgestellten Technologie weiterbilden möchten.

Haben Sie Fragen die sich direkt auf den Inhalt des Artikels beziehen, dann schreiben Sie dem Autor! Unsere Autoren freuen sich über Feedback zu ihren Artikeln. Ein einfacher Klick auf die Autor kontaktieren Schaltfläche (weiter unten) und schon haben Sie ein für diesen Artikel personalisiertes Anfrageformular.

Und zu guter Letzt möchten wir Sie bitten, den Artikel zu bewerten. Damit helfen Sie uns, die Qualität der Artikel zu verbessern - und anderen Lesern bei der Auswahl der Artikel, die sie lesen sollten.