C# 6.0 – Dictionary Initialisierung

Mit C# 6.0 lassen sich auch Dictionaries direkt initsialisieren. Dabei spielt es auch keine Rolle welche Typen verwendet werden. Da hier nicht viel Erklärungbedarf bestehen dürfte, hier ein selbsterklärendes Beispiel (es werden Zeilennummern C++ Quellcodezeilen zugewiesen und im Dictionary gespeichert):

Dictionary<int, string> CppHelloWorldProgramCode = new Dictionary<int, string>
    {
        [1] = "#include <iostream>", 
        [2] = "", 
        [3] = "int main () {", 
        [4] = "  std::cout << \"Hello World!\" << std::endl;", 
        [5] = "  return 0;", 
        [6] = "}"
    };

C# 6.0 – Wie heißt du denn?

Um in C# 6.0 zu erfahren, wie eine Variable im Quellcode heißt, gibt es das neue Schlüsselwort „nameof„. Mit dessen Hilfe kann z.B. ein Umbennen von Variablen, welche anschließend im Logging oder Exception-Text (-Parameter) verwendet werden, so gestaltet werden, dass der Kompiler einen Fehler ausgibt, wenn die Bezeichnung nicht stimmt. Hier ein Beispiel:

public void DoSomething(string someValue)
{
    if (string.IsNullOrEmpty(someValue))
        throw new ArgumentException(nameof(someValue), $"A value for parameter \"{nameof(someValue)}\" is required!");

    // Do some stuff here
}

Und so reiht sich die neue Funktionalität wunderbar in der Sammlung positiver Aspekte von  C# ein.

C# 6.0 – Auf NULL prüfen vereinfachen

Eine weitere Neuerung in C# 6.0 ist das vereinfachte prüfen, ob eine Variable „NULL“ ist oder ob diese bereits initialisiert worden ist. Der hierfür benötigte Operator ist das „?“, welches auch bereits bei Nullable-Typen verwendet wird. Hier ein kleines Beispiel der Verwendung:

string sTest = "Hello World";

char? thirdChar = sTest?[2]; // 'l'

sTest = null;
thirdChar = sTest?[2]; // null

sTest = "Hi";
thirdChar = sTest?[2]; // throws IndexOutOfRangeException

Auch dies erspart dem Programmierer wieder ein paar Zeilen, jedoch finde ich es zum jetzigen Zeitpunkt noch merkwürdig zu lesen. Wobei das wohl vergehen wird, wenn erst einmal die Übung mit besagter Funktionalität etabliert ist.

C# 6.0 – Lambda Expressions für Read-Only Properties

Als Ergänzung zu der Möglichkeit, in C# 6.0 ganze Methoden durch Lambda Expressions zu ersetzen, ist dies auch mit Read-Only Properties sehr simpel  möglich. Hierzu muss lediglich ein ähnlicher Aufbau wie bei den Methoden verwendet werden.

public string Name { get; private set; } 
public string BackwardsName => new string(Name.Reverse().ToArray());

C# 6.0 – Lambda Expressions für Methoden verwenden

Mit der Version 6.0 von C# wird es möglich sein anstelle von Methoden-Implementation simple Lamdba Expressions zu verwenden, um so den Quellcode noch kleiner zu halten. Der hierbei benötigte Aufwand ist sehr überschaubar und ermöglicht es saubere Methoden zu definieren. Hier ein Beispiel:

public class Dog
{ 
    public string Name { get; private set; }
    public int Age { get; private set; }
	
    public Dog(string name, int age)
    {
        Name = name;
        Age = age;
    }
 
    public void AgeIncrement() => Age++;
    public int AgeInDogYears() => Age * 7;
}

Die beiden Methoden „AgeIncrement“ und „AgeInDogYears“ machen hierbei von der neuen Funktionalität Gebrauch. In der Theorie kann man den Quellcode oben noch weiter vereinfachen, aber ich wollte an dieser Stelle nur dieses eine Thema behandeln.

C# 6.0 – Read-Only Auto-Properties vom Konstruktor initialisieren

In C# 6.0 hat Microsoft die Möglichkeit geschaffen, Read-Only Auto-Properties vom Konstruktor zu initialisieren. Auch dann, wenn diese keinen direkten Setter haben. Hierbei gibt es zwei Möglichkeiten. Die eine ist die direkte Initialisierung bei der Definition der Eigenschaft. Die andere ist vom Konstruktor aus. Und dies würde so aussehen:

public DateTime CreationTime { get; } = DateTime.Now;

Und hier noch die direkte Initialisierung vom Konstruktor aus:

public class MyObject
{
    public string Name { get; }
 
    public MyObject(string name)
    {
        Name = name;
    }
}

So wird ungewolltes überschreiben noch besser verhindert.

C# 6.0 – Ausnahmen filtern

Mit C# 6.0 hat Microsoft wieder einige neue Funktionalitäten hinzugefügt, die das Schreiben von Quellcode nicht nur erleichtern sondern auch übersichtlicher gestalten. Eine dieser Neuerungen in C# 6.0 ist das sogenannte „Exception filtering“ mit dem es möglich ist, auftretene Ausnahmen nur unter bestimmten Bedingungen abzufangen und andernfalls einfach durchzulassen. Das Abfangen einer Exception unter bestimmten Bedingungen könnte zum Beispiel wie folgt aussehen:

try
{
	int x = 5 / 0;
}
catch (DivideByZeroException ex) if (DateTime.Now.DayOfWeek != DayOfWeek.Saturday)
{
	Console.WriteLine(ex.Message);
}

Hier wird die Ausnahme an jedem Wochentag abgefangen außer Samstags. Wenn wir also einen Samstag haben, wird die Exception in diesem Fall normal weiter gegeben bis jemand diese abfängt oder die Applikation abstützt.

Async und Await in .NET 4.0

Vielen dürften inzwischen die geliebten Schlüsselwörter „async“ und „await“ ein Begriff sein. Diese haben die asynchrone Programmierung unter .NET sehr stark vereinfacht sind jedoch leider erst im neusten Framework standardmäßig verfügbar – dem .NET 4.5. Seit Mitte April gibt es aber hierfür nun eine Abhilfe, welche es immerhin ermöglicht diese Funktionalität unter .NET 4.0 bereits zu verwenden. Denn das größte Problem des .NET 4.5 ist, die nicht vorhandene Kompatibilität zu dem immer noch stark verbreitetem Windows XP.

Wie das Ganze zu nutzen ist, kann eigentlich der NuGET Galerie entnommen werden. Denn nach der Installation funktioniert dies wie bereits unter .NET 4.5. Der Link zum entsprechenden NuGET Galerie Eintrag ist am Ende des Posts zu finden. Es ist jedoch eigentlich nichts weiter nötig als das Package „Microsoft.Bcl.Async“ zu installieren, welches über die NuGET Paketverwaltung oder über die Paket-Manager-Konsole mit folgendem Befehl erfolgt:

Install-Package Microsoft.Bcl.Async

Weiterlesen