Visual Studio 2010 und .NET 4 nach zwei Monaten

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

• Die neue Oberfläche ist wie der Editor in WPF gebaut, und fühlt sich im Alltag meist gut an.
• IntelliSense, „Navigate To“ und Markierung von Verwendungen sparen echte Klickarbeit.
• Parallel.For und Task machen einfache Parallelisierung ziemlich bequem.
• C# 4 bringt optionale Parameter und dynamic, Entity Framework 4 sieht vielversprechend aus.

Am 12. April ist Visual Studio 2010 erschienen, und ich arbeite jetzt seit rund zwei Monaten damit. Im Herbst hatte ich schon die Beta 2 ausprobiert. Damals war es teilweise zäh und hat öfter gehangen. Zeit für einen Zwischenstand.

Oberfläche und Editor

Der Editor ist jetzt in WPF geschrieben. Man sieht es an der weicheren Darstellung, und die Fenster lassen sich frei auf mehrere Monitore ziehen. Das habe ich sofort genutzt: Code links, Designer oder Debug-Fenster auf dem zweiten Bildschirm. Im Vergleich zur Beta ist die Geschwindigkeit deutlich besser geworden, bei großen Solutions merkt man aber immer noch hin und wieder eine Gedenksekunde.

Kleine Dinge, die mir gefallen:

• Navigate To (Strg + Komma): Klasse oder Methode tippen und direkt springen.
• Ein Klick auf einen Bezeichner markiert alle Verwendungen im Dokument.
• Call Hierarchy: wer ruft diese Methode auf?
• Generate from Usage: erst die noch nicht vorhandene Klasse aufrufen, dann per Tastenkürzel anlegen lassen.

Auch IntelliSense ist besser geworden. Die Vorschläge werden nach Teilen des Namens gefiltert, man kann also auch nur Coll für ObservableCollection tippen.

Parallel Extensions

Spannend finde ich die neue Unterstützung für Parallelität. Eine Schleife auf mehrere Kerne verteilen geht mit Parallel.For:

using System.Threading.Tasks;

Parallel.For(0, bilder.Length, i =>
{
    bilder[i] = Verkleinern(bilder[i]);
});

Wichtig: Der Schleifenkörper muss unabhängig voneinander laufen können. Wenn mehrere Durchläufe auf dieselbe Variable schreiben, braucht man weiterhin ein lock oder Interlocked. Für einzelne Aufgaben im Hintergrund gibt es Task:

Task<int> aufgabe = Task.Factory.StartNew(() => BerechneSumme(daten));

// ... in der Zwischenzeit etwas anderes tun ...

int summe = aufgabe.Result; // wartet, falls noch nicht fertig

Das ist viel angenehmer als der manuelle Umgang mit Thread und ThreadPool. Ob es bei komplexeren Anwendungen genauso glatt läuft, muss ich noch testen.

C# 4: optionale Parameter und dynamic

Methoden dürfen jetzt Standardwerte haben, und man kann Parameter beim Aufruf benennen:

static void Log(string text, string kategorie = "Info", bool zeitstempel = true)
{
    // ...
}

Log("Start");
Log("Fehler!", kategorie: "Error");

Das spart einige Überladungen. Dazu kommt dynamic, bei dem die Prüfung erst zur Laufzeit stattfindet:

dynamic wert = "Hallo";
Console.WriteLine(wert.Length); // erst zur Laufzeit aufgelöst

Praktisch für COM (Office-Automatisierung) oder wenn man mit dynamischen Sprachen spricht, aber ich würde es sparsam einsetzen. Man verliert IntelliSense und die Fehler tauchen erst beim Ausführen auf.

Entity Framework 4

Nur ein kurzer Blick: Das Entity Framework wurde mit .NET 4 deutlich überarbeitet. Man kann jetzt zum Beispiel erst das Modell aus der Datenbank erzeugen oder auch umgekehrt vorgehen, und die Abfragen lassen sich besser mit LINQ formulieren. Ich habe es bisher nur mit einem kleinen Testprojekt probiert und schreibe vielleicht später mehr dazu.

Wie geht es weiter?

Der Umstieg lohnt sich, auch wenn nichts davon revolutionär ist. Es sind viele Verbesserungen im Alltag, und die Beta-Probleme sind größtenteils weg. Habt ihr schon umgestellt? Wie läuft es bei euch?

Beitragsbild: eigene Collage mit Logos von Wikimedia Commons (.NET Framework logo from 2002: Microsoft, gemeinfrei); die Marken gehören ihren Inhabern.