Eine Neuerung von C# 3.0 sind Erweiterungsmethoden. Erweiterungsmethoden bieten die Möglichkeit bereits vorhandene Klassen mit weiterer Funktionalität auszustatten. Dabei können auch Klassen oder Strukturen erweitert werden, die als sealed gekennzeichnet sind oder Bestandteil des .NET Frameworks sind.

In folgendem Beispiel wird System.Int32 um eine Methode erweitert, die den aktuellen Wert mit einem Faktor multipliziert. Dazu wurde eine neue statische Klasse Extension hinzugefügt. Innerhalb dieser Klasse gibt es eine Methode mit dem Namen Multiplizieren. Diese Methode hat zwei Parameter, wobei eigentlich nur der erste interessant ist. Auffällig ist das Schlüsselwort this. Mit Hilfe dieses Schlüsselwortes erweitert der Compiler den Datentyp int um die angegebene Methode.

static class Extension
{
    public static int Multiplizieren(this int instance, int factor)
    {
        return instance * factor;
    }
}

Auch im Visual Studio IntelliSense ist diese Methode bereits vorhanden und wird dort mit einem speziellen Symbol und der Kennzeichnung (extension) angezeigt.

Natürlich können Erweiterungsmethoden auch in Verbindung mit generischen Typen verwendet werden. In folgendem Beispiel wird die generische Liste um Methode HasElements erweitert. Diese Methode soll ausgeben, ob Elemente in der Liste enthalten sind.

static class Extension
{
    public static bool HasElements(this List list)
    {
        return list.Count > 0;
    }
}

Auch hier wird die neue Methode ebenfalls sofort im IntelliSense angezeigt.

Der geübte C# 2.0 Entwickler kennt bereits anonyme Methoden. Mit C# 3.0 werden die Methoden um anonyme Typen ergänzt. Hauptsächlich bei der Arbeit mit LINQ wird häufig Gebrauch von dieser neuen Entwicklung gemacht. In einem Satz werden anonyme Typen wie folgt definiert:

Anonyme Typen erlauben dem Entwickler Datentypen zu deklarieren, ohne dabei eine zugehörige formelle Definition dieser Typen zu erstellen.

Basis eines jeden anonymen Typs ist das Schlüsselwort var. Im Vorfeld muss zunächst ein Verständnis für dieses Schlüsselwort entwickelt werden. Daher ein kleiner Exkurs. Das Schlüsselwort var erlaubt dem Compiler die Bestimmung des zugrunde liegenden Datentyps – und zwar zurzeit des Kompilierens und nicht zur Laufzeit. Ein kleines Beispiel verdeutlicht dieses Vorgehen

var myInt = 10;
var myString = "Kai";
var myDouble = 100.5;

Mit Hilfe des .NET Reflector kann der Code, welcher durch den Compiler generiert wurde, analysiert werden.

Die Analyse zeigt, dass tatsächlich die korrekten Datentypen deklariert wurden.

Das Verständnis und den verbundenen Nutzen von anonymen Typen, wird am besten anhand eines Beispiels deutlich. Innerhalb einer Logik wird ein Datentyp benötigt um mehrere Daten zu speichern und weiterverarbeiten zu können – Bsp. ein Kunde. Dieser Kunde soll jeweils durch einen Namen und eine Zahl definiert werden. Unter normalen Umständen würde nun eine Klasse mit dem Namen Customer erstellt werden. Mit Hilfe von anonymen Typen ist dies jedoch nicht nötig.

var customer = new { Name = "Kai", Zahl = 100 };

Das Ergebnis ist ähnlich der Klasse, die erstellt werden würde: Ein Typ mit den Eigenschaften Name und Zahl. Dies wird auch durch das Visual Studio IntelliSense deutlich

Auch wenn diese Erweiterung viele Dinge einfacher macht, so sollte sie dennoch mit Vorsicht genossen werden. Das Schlüsselwort var sollte grundsätzlich nur dann benutzt werden, wenn tatsächlich mit anonymen Typen gearbeitet wird. Alle anderen Definitionen von Datentypen sollten weiterhin auf die althergebrachte Weise durchgeführt werden.

Wann die Verwendung von anonymen Typen tatsächlich angebracht ist, muss jeder Entwickler für sich selbst entscheiden. Das angegebene Beispiel schildert doch recht deutlich, dass häufig Anwendungsfälle gefunden werden können.

Ein häufiges Konstrukt um unter C# 2.0 Eigenschaften zu erstellen, ist dieses hier:

private string myProperty;

public string MyProperty
{
    get { return myProperty; }
    set { myProperty = value; }
}

In C# 3.0 kann eine solche Eigenschaft mit viel weniger geschriebenem Code erzeugt werden, genauer gesagt mit einer einzigen Zeile Code.

public string MyProperty { get; set; }

Das zugehörige Feld und der Getter bzw. Setter werden automatisch durch den Compiler erzeugt.

Dass dies tatsächlich so ist kann mit Hilfe des .NET Refletor überprüft werden. Der generierte Code ist jeweils mit dem Attribut [CompilerGenerated] gekennzeichnet.

Natürlich können automatische Eigenschaften immer nur mit Getter und Setter erzeugt werden. Damit der Setter nur innerhalb der Klasse benutzt werden kann, muss dieser einfach als private deklariert werden.

public string MyProperty { get; private set; }

Der generierte Code zeigt nun jeweils einen privaten Setter und öffentlichen Getter.