C# 6 und Visual Studio 2015 ausprobiert

Keine Zeit? Hier die Kurzversion in 30 Sekunden.
- Visual Studio 2015 ist seit dem 20. Juli draußen und bringt C# 6 mit dem neuen Roslyn-Compiler.
- C# 6 ist kein einzelnes großes Feature, sondern eine Sammlung kleiner Änderungen: nameof, String-Interpolation, ?., Expression-bodied Members, Auto-Property-Initialisierer, using static, Exception-Filter.
- Der Gewinn liegt weniger im Neuen als im Wegfall von Zeremonie: weniger Null-Prüfungen, weniger String.Format, weniger Boilerplate.
- Roslyn macht Analyzer und Code-Fixes möglich, die direkt im Projekt leben können. ASP.NET 5 und .NET Core sind noch Vorschau.
Ich habe mir Visual Studio 2015 in den letzten Wochen ein paar Abende lang angesehen, nicht im Rahmen eines großen Umstiegs, sondern eher zum Spielen. Die Installation ist schwerer als früher, sie ist aber nicht der Punkt. Interessanter ist, was darunter passiert ist: C# und Visual Basic werden jetzt vom Roslyn-Compiler übersetzt, einer in C# und VB selbst geschriebenen Plattform, die ihre Syntaxbäume und Analysen als Bibliothek zur Verfügung stellt. Und obenauf sitzt C# 6.
Gleich vorweg meine Einordnung: Wer ein großes neues Sprachmerkmal erwartet, so wie bei C# 3 mit LINQ oder bei C# 5 mit async/await, wird enttäuscht. C# 6 besteht aus vielen Kleinigkeiten. Und ich bin nach einigen Tagen der Meinung, dass genau das die Stärke ist.
Weniger Zeremonie im Alltag
Das Feature, das ich am schnellsten im eigenen Code vermisst habe, ist der Null-Conditional-Operator. Jeder kennt den Code, in dem eine Kette von Prüfungen davorsteht, bevor man an die eigentliche Information kommt:
string stadt = null;
if (kunde != null && kunde.Adresse != null)
{
stadt = kunde.Adresse.Stadt;
}Mit C# 6 wird daraus eine Zeile, und das Ergebnis ist bei fehlendem Zwischenglied einfach null:
string stadt = kunde?.Adresse?.Stadt;Kombiniert mit dem bekannten ?? ergibt sich auch ein Vorgabewert: kunde?.Adresse?.Stadt ?? "unbekannt". Besonders angenehm ist die Variante bei Ereignissen. Das alte Muster mit der lokalen Kopie des Delegaten, um Rennen mit anderen Threads zu vermeiden, schrumpft auf Geaendert?.Invoke(this, EventArgs.Empty);. Das ist nicht nur kürzer, es ist auch weniger fehleranfällig, weil man die Kopie nicht mehr vergessen kann.
Dazu kommt die String-Interpolation. Statt String.Format("{0} hat {1} Positionen", name, anzahl) schreibt man $"{name} hat {anzahl} Positionen". Das klingt nach Kosmetik, aber wer einmal in einer Formatzeichenfolge die Argumente vertauscht hat, weiß, dass dort Fehler entstehen. Formatangaben funktionieren weiter, etwa {preis:N2}. Dahinter steckt übrigens weiterhin ein Aufruf von String.Format, es ist also reiner Compilerzucker. Das ist legitim, man sollte es nur wissen.
Kleine Dinge, die zusammen Wirkung haben
Auto-Property-Initialisierer erlauben Vorgabewerte direkt an der Eigenschaft, ohne den Umweg über den Konstruktor, und schreibgeschützte Auto-Properties lassen sich nun als echte Getter-only-Eigenschaften deklarieren:
public class Bestellung
{
public Guid Id { get; } = Guid.NewGuid();
public List<string> Positionen { get; } = new List<string>();
}Für unveränderliche Objekte ist das eine echte Erleichterung. Vorher musste man dafür ein Feld mit readonly anlegen und eine Eigenschaft darum bauen, jetzt gibt es eine Zeile. Die Werte können nur im Initialisierer oder im Konstruktor gesetzt werden.
Expression-bodied Members sind der Lambda-Pfeil für Methoden und Eigenschaften: public string Anzeige => $"{Name} ({Id})";. Bei kurzen Methoden spart das Klammern und Rückgabeanweisungen. Ich benutze es für Eigenschaften, die nur etwas zusammensetzen, und bei längeren Methoden lasse ich es bewusst weg, denn dort verliert man schnell die Lesbarkeit.
using static erlaubt, statische Member einer Klasse ohne Präfix zu verwenden, etwa using static System.Math; und dann Sqrt(x). Bei Math gefällt mir das, in anderen Fällen bin ich skeptisch. Wenn ein Name wie Parse oder Create plötzlich ohne Klassennamen im Code steht, weiß man beim Lesen nicht mehr, woher er kommt.
Und nameof ersetzt die Magic Strings, die man früher für Parameter- und Eigenschaftsnamen in Argumentprüfungen oder in INotifyPropertyChanged verwendet hat: throw new ArgumentNullException(nameof(kunde));. Beim Umbenennen zieht der Compiler den Namen mit, und das ist mehr wert, als es klingt.
Exception-Filter und was sie ändern
Ein Merkmal fällt aus der Reihe, weil es nicht nur Syntax ist: Exception-Filter mit when.
try
{
Lade(datei);
}
catch (IOException ex) when (ex.HResult == unchecked((int)0x80070020))
{
// Datei wird von einem anderen Prozess benutzt
}Der Filter wird ausgewertet, bevor der Stack abgewickelt wird. Trifft die Bedingung nicht zu, fängt der Block die Ausnahme gar nicht erst, und der Stack bleibt für einen späteren Fehlerbericht oder ein Debugging unverändert. Das ist ein Unterschied zum bisherigen Muster, die Ausnahme zu fangen, zu prüfen und mit throw; weiterzureichen. Man kann Filter auch zum Protokollieren missbrauchen, indem man eine Methode aufruft, die false liefert. Das ist ein Trick, den ich mit Vorsicht betrachte, weil er Nebenwirkungen in eine Stelle legt, wo niemand sie sucht.
Roslyn und die Werkzeuge
Der eigentliche strategische Teil liegt für mich unter der Haube. Mit Roslyn kann man eigene Analyzer schreiben, die im Editor Warnungen erzeugen, und zugehörige Code-Fixes, die ein Problem per Tastendruck beheben. Diese Analyzer lassen sich als Paket in ein Projekt einbinden, sodass Regeln eines Teams oder eines einzelnen Projekts mit dem Code wandern. Das ist ein anderer Ansatz als externe Prüfwerkzeuge, die außerhalb der IDE laufen und deren Meldungen man erst im Nachhinein ansieht. Ob es sich im Alltag durchsetzt, muss sich zeigen, aber die Möglichkeit ist da.
Auch die Diagnosewerkzeuge sind besser geworden. Das Debuggen mit dem neuen Diagnosefenster, in dem man Speicher- und CPU-Verbrauch während der Sitzung sieht, hat mir bei einem kleinen Experiment schneller gezeigt, wo Zeit verloren geht, als es früher ein separater Profiler getan hätte. Ich will daraus keine große Aussage ableiten, ein Profiler ersetzt es nicht. Aber der Weg vom Verdacht zur Messung ist kürzer.
Wie ich das einordne
Mein Gesamteindruck ist erstaunlich ruhig. Es gibt keinen Moment, in dem man denkt, jetzt müsse man alles anders machen. Man bemerkt nach einer Woche eher, dass man gewisse Zeilen nicht mehr schreibt. Das ist schwer zu verkaufen, weil sich Zeilen, die nicht mehr dastehen, schlecht demonstrieren lassen, aber im Alltag ist es genau das, was Code lesbarer macht.
Zwei Einschränkungen gehören dazu. Erstens zwingt einen C# 6 zu einer aktuellen Toolkette: Wer in einem Team mit gemischten Versionen arbeitet oder auf einem Buildserver mit älterem Compiler, muss beides anpassen, sonst wird aus einem hübschen Feature ein kaputter Build. Zweitens ist von der größeren Neuerung rund um ASP.NET 5 und das, was Microsoft als .NET Core bezeichnet, bisher nur eine Vorschau zu sehen. Ich habe sie mir angesehen und finde die Richtung interessant, würde aber nichts darauf bauen, was nächstes Jahr stabil laufen muss. Ob und wie das ausgeliefert wird, kann ich noch nicht beurteilen.
Meine Empfehlung ist deshalb unspektakulär: Auf einem Rechner installieren, ein bestehendes kleines Projekt öffnen und beim Weiterarbeiten nach und nach die neuen Schreibweisen nutzen. Nicht alles auf einmal umstellen, nicht in einem Rutsch refaktorieren. Die Sprache ist abwärtskompatibel, nichts zwingt einen dazu, und die Änderungen zeigen ihren Wert erst im Gebrauch.
Christian Ackermann
Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.