CSharp 6.0 (C# 6.0)

Eintrag zuletzt aktualisiert am: 19.10.2015

 Fachbücher zum Thema CSharp 6.0 (C# 6.0)

C# 6.0 (alias C# 2015) ist der Nachfolger von C# 5.0 und ab .NET Framework 4.6 und Visual Studio 2015 verfügbar.

C# 6 ist (zusammen mit Visual Basic 14 alias Visual Basic 2015) am 20.7.2015 im Rahmen von .NET Framework 4.6 und Visual Studio 2015 erschienen.

Hinweis: einige der neuen Sprachfeatures funktionieren auch, wenn man mit Visual Studio 2015 für ältere .NET Framework-Versionen kompiliert, da diese Features reine Compiler-Features sind, die keine der neuen Klassen in .NET 4.6 erfordern und der entstehende IL-Code kompatibel zu früheren .NET-Versionen ist.

Geschichte

Erste Ankündigungen gab es auf der NDC 2013-Konferenz.
Eine breitere Vorstellung gab es auf der BUILD 2014-Konferenz Anfang April 2014.
C# 6.0 ist am 20.7.2015 erschienen.

Neue Sprachfeatures in C# 6.0

Auto-property initializers
public int X { get; set; } = x;

Getter-only auto-properties
public int Y { get; } = y;

Using static members
using System.Console; … WriteLine(4);

Dictionary initializer
new JObject { ["x"] = 3, ["y"] = 7 }

Await in catch/finally
try … catch { await … } finally { await … }

Exception filters
catch(E e) if (e.Count > 5) { … }

Expression-bodied members
public double Dist => Sqrt(X * X + Y * Y);

Null propagation Operator
customer?.Orders?[5]?.$price

Details zu den neuen Sprachfeatures

Zu den sehr praktischen Neuerungen in beiden Sprachen gehört der Fragezeichen-Punkt-Operator (?.), der im Gegensatz zu dem einfachen Punkt-Operator keinen Laufzeitfehler auslöst, wenn der Ausdruck vor dem Punkt keinen Wert besitzt, also "null" (in C#) beziehungsweise "nothing" (in Visual Basic .NET) liefert.

string name = repository?.GetKontakt()?.Name;

Mit einer String Interpolation können Entwickler die Zusammensetzung von Zeichenketten aus festen und variablen Bestandteilen übersichtlicher als bisher realisieren.

var ausgabeAlt = String.Format("Kontakt #{0:0000}: {1} ist in der Liste seit {2:d}.", k.ID, k.GanzerName, k.ErzeugtAm);

var ausgabeNeu = $"Kontakt #{k.ID:0000}: {k.GanzerName} ist in der Liste seit {k.ErzeugtAm:d}.";

Zudem kann man nun automatische Properties, für die es keine explizite Felddeklaration gibt, direkt im Rahmen der Deklaration mit einem Wert initialisieren und auch automatische Properties schaffen, die nach ihrer Initialisierung unveränderbar sind. Lediglich im Konstruktor der Klasse kann der Entwickler solche Eigenschaften dann noch ändern (siehe Listing 1).

public class Kontakt
{
  // Automatic Properties mit Initialisierung
  public string Land { get; set; } = "Deutschland";
  // Automatic Properties mit Initialisierung und ohne Setter
  public DateTime ErzeugtAm { get; } = DateTime.Now;

  public Kontakt(DateTime erzeugtAm)
  {
   // Getter Only Auto Property im Konstruktor setzen
   ErzeugtAm = DateTime.Now;
  }
}
Listing 1: Automatische Properties mit Initialisierung und optional auch ohne Setter

Der neue Operator nameof() liefert den Namen eines Bezeichners als Zeichenkette (bei mehrgliederigen Namen nur den letzten Teil). Dieser Operator erhöht die Robustheit und erleichtert das Refactoring in Situationen, in denen der Name einer Klasse oder eines Klassenmitglieds als Zeichenkette zu übergeben ist, z.B. ArgumentNullException (siehe Listing 2) Dependency Properties und PropertyChangedEventArgs (siehe Listing 3).

  public void SaveKontakt(Kontakt neuerKontakt)
  {
   if (neuerKontakt == null) throw new ArgumentNullException(nameof(neuerKontakt));
   ...
  }
Listing 2: Einsatz des Operators nameof() für ArgumentNullException

  public int KontaktAnzahl
  {
   get { return kontaktAnzahl; }
   set
   {
   PropertyChanged(this, new PropertyChangedEventArgs(nameof(KontaktAnzahl)));
   kontaktAnzahl = value;
   }
  }
Listing 3: Einsatz des Operators nameof() für PropertyChangedEventArgs

Alle vorgenannten Sprachfeatures hat Microsoft sowohl in C# 6 als auch Visual Basic 14 ergänzt – auch wenn sie hier aus Platzgründen nur in C# abgedruckt sind. Andere Sprachfeatures wurden in lediglich einer Sprache ergänzt, weil es sie in der anderen bereits gab.

Dazu gehören Exception Filter, mit denen der C#-Entwickler nun zusätzlich zu den Exception-Klassen in den catch-Blöcken mit dem Schlüsselwort when zwischen verschiedenen Fällen differenzieren kann (siehe Listing 4). Diese Spracheigenschaft gibt es in Visual Basic .NET schon seit dem Jahr 2002. Ebenso hat C# nun bei der Möglichkeit gleichgezogen, statische Klassen mit using so einzubinden, dass man auf die einzelnen Klassenmitglieder nun ohne Verwendung des Klassennamens zugreifen darf:

// bisherige Schreibweise
Console.WriteLine(Environment.UserDomainName + @"\" + Environment.UserName);

// neu in C# 6.0
using static System.Console;
using static System.Environment;

WriteLine(UserDomainName + @"\" + UserName);

Dieses Sprachfeature ist jedoch umstritten, weil hier die Lesbarkeit des Programmcodes zugunsten einer ersparten Tipparbeit geopfert wird.

   try
   {
   var datei = System.IO.File.ReadLines(filename);
   }
   catch (ArgumentException) when (filename == "")
   {
   Console.WriteLine("Ohne Dateiname macht diese Aktion keinen Sinn!");
   }
   catch (ArgumentException ex) when (ex.Message.Contains("Illegales"))
   {
   Console.WriteLine("Ungültige Zeichen im Dateinamen: " + filename);
   }
   catch (ArgumentException ex)
   {
   Console.WriteLine("Ungültige Angabe: " + filename + ":" + ex.Message);
   }
   catch (NotSupportedException ex) when (ex.Message.Contains("format"))
   {
   Console.WriteLine("Ungültiges Format!");
   }
   catch (NotSupportedException ex)
   {
   Console.WriteLine("Nicht unterstützt: " + ex.Message);
   }
   catch (FileNotFoundException ex)
   {
   Console.WriteLine("Datei " + filename + " nicht gefunden");
   }
   catch (Exception ex)
   {
   Console.WriteLine("Anderer Fehler: " + ex.Message);
   }
Listing 4: Exception Filter in C# 6

Auch Visual Basic hat ein paar Angleichungen an C# erfahren: Erlaubt sind nun mehrzeilige Zeichenkettenliterale und Kommentare in LINQ-Ausdrücken sowie partielle Module und partielle Schnittstellendefinitionen.

C# hat aber in der Version 6 auch Möglichkeiten bekommen, die es in Visual Basic .NET nicht gab und auch vorerst weiterhin nicht geben wird. Dazu gehören sogenannte Expression-bodied Members: Methoden und nicht beschreibbare Properties, die nur einen einzigen Ausdruck zurückliefern, kann der C#-Entwickler nun verkürzt unter Einsatz des Lambda-Operators => schreiben:

public string GanzerName => this.Vorname + " " + this.Nachname;
public decimal NeuerEinkauf(decimal wert) => this.Umsatz += wert;
public override string ToString() => this.GanzerName + ": " + this.KontaktStatus;

Weiterhin darf ein C#-Entwickler nun die Schlüsselwörter async und await auch in catch- und finally-Blöcken verwenden. Auch dies ist bisher für Visual Basic .NET nicht vorgesehen, sodass die komplette Sprachparität zwischen den beiden vorherrschenden .NET-Sprachen nicht gegeben ist.

Leider wieder gestrichene (also doch nicht in C# 6.0 enthaltene) Sprachfeatures

Declaration expressions
int.TryParse(s, out var x);

Params IEnumerabl
e int Avg(params IEnumerable<int> numbers) { … }

Primary constructors
class Point(int x, int y) { … }

Binary literals
0b00000100

Digit separators
0xEF_FF_00_A0

Event initializers
new Customer { Notify += MyHandler };

Field targets on autoprops
<Field: Serializable> Property p As Integer

Als E-Mail versenden
Bookmarken bei del.icio.us
Bookmarken bei Digg
Reddit
Bookmarken bei Live