Training - Beratung - Projektarbeiten

www.David-Tielke.de

Webcast C# 6.0 - Folge 4: Using Static

Die wohl merkwürdigste Erweiterung von C# 6.0 ist ohne Zweifel “Using Static”, also das direkte Einbinden von Membern eines statischen Typs in einen Namensraum. Dadurch entfällt der vermeidlich komplizierte Aufruf über den Klassennamen. Auch wenn ich ein großer Fan von C# 6.0 und dessen Erweiterungen bin, kann ich diesem Sprachfeature einfach nichts abgewinnen. Der Code dadurch mag kompakter werden, jedoch leidet die Lesbarkeit des Codes sehr stark und statische Member aus anderen Klassen sehen plötzlich so aus, wie Memberaufrufe auf dem aktuellen Typ – ein no-go!

Dazu aus der Project Roslyn Webseite

The feature allows all the accessible static members of a type to be imported, making them available without qualification in subsequent code:
using static System.Console;
using static System.Math;
using static System.DayOfWeek;
class Program
{
    static void Main()
    {
        WriteLine(Sqrt(3*3 + 4*4)); 
        WriteLine(Friday - Monday); 
    }
}
This is great for when you have a set of functions related to a certain domain that you use all the time. System.Math would be a common example of that. It also lets you directly specify the individual named values of an enum type, like the System.DayOfWeek members above. Extension methods Extension methods are static methods, but are intended to be used as instance methods. Instead of bringing extension methods into the global scope, the using static feature makes the extension methods of the type available as extension methods:
using static System.Linq.Enumerable; // The type, not the namespace
{
    static void Main()
    {
        var range = Range(5, 17);                // Ok: not extension
        var odd = Where(range, i => i % 2 == 1); // Error, not in scope
        var even = range.Where(i => i % 2 == 0); // Ok
    }
}
This does mean that it can now be a breaking change to turn an ordinary static method into an extension method, which was not the case before. But extension methods are generally only called as static methods in the rare cases where there is an ambiguity. In those cases, it seems right to require full qualification of the method anyway.
Links

Webcast C# 6.0 - Folge 3: Expression Bodied Function Member

Immer dann, wenn in C# eine Methode oder ein Computed-Property mit nur einem einzigen Statement geschrieben wird, erzeugt dies, bedingt durch den notwendigen Anweisungsblock nach Methoden oder Properties, unnötig viel Code. Ein ähnliches Problem existieren bei den in C# 2.0 eingeführten anonymen Funktionen. In C# 3.0 wurde deshalb mit den Lambdaausdrücken eine Kurzform hinzugefügt, bei der mit Hilfe eines Projektionsoperators, sehr kurze und knappe “Inlinemethoden” geschrieben werden können:

names.Where(n => n.Age >= 18);

Mit C# 6.0 und den “Expression Bodied Function Member”, existiert nun eine solche Variante auch für die direkte Deklarationen von Methoden und berechneten Eigenschaften.

Dazu aus der Projekt Roslyn Webseite:

Lambda expressions can be declared with an expression body as well as a conventional function body consisting of a block. This feature brings the same convenience to function members of types. Expression bodies on method-like members Methods as well as user-defined operators and conversions can be given an expression body by use of the “lambda arrow”:
public Point Move(int dx, int dy) => new Point(x + dx, y + dy); 
public static Complex operator +(Complex a, Complex b) => a.Add(b);
public static implicit operator string(Person p) => p.First + " " + p.Last;
The effect is exactly the same as if the methods had had a block body with a single return statement. For void-returning methods – and Task -returning async methods – the arrow syntax still applies, but the expression following the arrow must be a statement expression (just as is the rule for lambdas):
public void Print() => Console.WriteLine(First + " " + Last);
Expression bodies on property-like function members Properties and indexers can have getters and setters. Expression bodies can be used to write getter-only properties and indexers where the body of the getter is given by the expression body:
public string Name => First + " " + Last;
public Customer this[long id] => store.LookupCustomer(id); 
Note that there is no get keyword: It is implied by the use of the expression body syntax.
Links

Webinar “Visual Studio 2012” Teil 1 & 2

Am 8.8. und 22.8. gab es einiges “Neues” zu Visual Studio 2012: Die Developer Media startete u.a. mit diesem Thema ihre neue Reihe an Webinaren zu Entwicklerthemen und ich hatte das große Vergnügen, als Referent mit von der Partie zu sein.

Webinar zu Visual Studio 2012–Teil 1

“Entwickler verstehen oft ihr eigenes Handwerkszeug nicht” – Ein Satz den man leider immer wieder im Beratungsalltag hört. In dem zweiteiligen Seminar ging es genau um dieses Thema: Wie werden Tools wie Unit-Tests, Profiling und Codeanalyse wirklich eingesetzt? Wie werden bestimmte Fehler mit dem Debugger gefunden? Wie verstehe ich meinen oder fremden Code besser? Mit insgesamt 200 Teilnehmern waren beide Trainings gut besucht und das bisherige Feedback zeigt, das dass Thema bei Entwicklern hohes Interesse weckt.

Wer in diesen 135 Minuten noch nicht genug erfahren hat, sollte sich das Training “Visual Studio 2012” bei Developer Media etwas genauer ansehen. Dort beschäftigen wir uns zwei Tage lang mit Tipps, Tricks und HandsOn zu Visual Studio 2012.

Wie in den Webinaren versprochen, gibt es hier nun die Folien, Projekte und Links.

Links
Teil 1 - Projekte und Folien
Teil 2 - Projekte und Folien