.NET 3.5 – Neuerungen bei C#3.0 – Teil 3 von 9

Extension-Methods
Extension Methods erweitern den Kontrakt für bestehende Klassen, ohne dass der Code der bestehenden Klassen verändert wird oder von der Klasse eine Ableitung erzeugt wird. Extension-Methods werden beim compilieren durch den Compiler aufgelöst, wenn der Namespace in dem die Extension-Method definiert wurde an der gewünschten Stelle eingebunden wurde.

Hier das erste einfache Beispiel:

namespace ExtensionMethods {
 public static class Extensions {
   public static string EliminateWhiteSpace(this string param) {
     return param.Replace(' ', string.Empty);
   }
 }
}

--> Verwendung:

using ExtensionMethods;

namespace ConsoleApplication {
  class Program {
    static void Main(string[] args) {
      Console.WriteLine("Hallo Welt!".EliminateWhiteSpace());
      Console.ReadLine();
    }
  }
}

Dank des „using ExtensionMethods;“ wird der Compiler keinen Fehler melden, denn der Compiler macht daraus:

Console.WriteLine(Extensions.EliminateWhiteSpace("Hallo Welt!"));

Dieses erste Beispiel zeigt schon sehr viele Regeln die bei der Verwendung von Extension-Methods beachtet werden müssen:

1. Die Klasse in der eine Extension-Method erstellt wird, muss static sein. Das gleiche gild für die Extension-Method selber.
2. Der erste Parameter in einer Extension-Method wird mit dem Modifier this versehen und entspricht dem Typ auf dem die Extension-Method angewendet werden kann.
3. Instanz-Methoden haben immer vor Extension-Methods Vorrang. Es kann also keine vorhanden Funktion durch eine Extension-Method ersetzt werden.
4. Extension Method kann nur auf die öffentlichen Member/Methoden eines Typs zugreifen.

Trotz der schönen Anwendungsfälle die man sich da überlegen könnte (z.Bsp.: Implementierung eines Interfaces durch eine Extension-Method…) ist dazu angeraten dieses Feature nur Sparsam einzusetzen um Wildwuchs und schlecht wartbaren Code zu vermeiden.

Zum Schluss noch ein weiteres Beispiel mit Generics:

public static class Extensions
{
  public static T[] Slice<T>(this T[] source,
	int index, int count)
  {
    if (index < 0 || count < 0 ||
	source.Length - index < count)
            throw new ArgumentException();
    T[] result = new T[count];
    Array.Copy(source, index, result, 0, count);
    return result;
  }
}

...

int[] d = {0, 1, 2, 3, 4};
int[] a = d.Slice(4, 3); //entspr. Extensions.Slice(d, 4, 3)

…und noch eins zur Veranschaulichung einer Rahmenbedingung:

public static class E
{
 public static void F(this object obj, int i) { }
 public static void F(this object obj, string s) { }
}
class X { }
class Y
{
   public void F(int i) { }
}
class Z
{
   public void F(object obj) { }
}
class X
{
 static void Test(X x, Y y, Z z) {
   x.F(1);        // E.F(object, int)
   x.F("hello");  // E.F(object, string)
   y.F(1);        // Y.F(int)
   y.F("hello");  // E.F(object, string)
   z.F(1);        // Z.F(object)
   z.F("hello");  // Z.F(object)
 }
}

^ Teil 1: Übersicht aller Neuerungen (Einleitung)

< Teil 2: Implizit typisierte Variablen, Implizit typisierte Arrays

> Teil 4: Lambda Expressions

.NET 3.5 – Neuerungen bei C#3.0 – Teil 2 von 9

Implizit typisierte Variablen und implizit typisiserte Arrays Der Teil 2 ließ lange auf sich warten, aber nun versuche ich die 9 Teile zügig weiter fortzuführen. Heute gleich mit einem recht einfach verständlichem Thema. Wofür das gut ist und wozu das bei .NET 3.5 eingebaut wurde wird euch sicher bei den nächsten Teilen deutlich bzw. ich werde sicher darauf nocheinmal hinweisen. Variablen und Arrays können implizit mit dem Schlüsselwort var deklariert werden. Dieses kann nur bei Lokalen Variablen, for-Initializern, Resource-Aquisition und bei foreach-Statements verwendet werden. Z. Bsp:

var a = 4711;
var b = "Hallo Welt";
var c = 1.0;
var nums = new int[] {0, 1, 2, 3, 4};
var products = new Dictionary<int,Product>();

Dies entspricht:

int a = 4711;
string b = "Hallo Welt";
double c = 1.0;
int[] nums = new int[] {0, 1, 2, 3, 4};
Dictionary<int,Product> products = new Dictionary<int,Product>();

Implizit typisierte Variablen und Arrays können nur unter folgenden Rahmenbedingungen verwendet werden:

• Die Variable muss initialisiert werden
• Der Initializer muss ein Ausdruck (expression) sein.
• Der Initializer Ausdruck muss zur Compile-Zeit einen Typ besitzen der kein null Typ ist.
• Die Deklaration der lokalen Variable darf keine mehrfachen Deklaratoren besitzen.
• Der Initializer darf keine deklarierte Variable referenzieren

Folgende Beispiele zeigen fehlerhafte Verwendung die zu einem Compiler-Error führen:

var a; // Error, kann kein Typ zur Compilezeit ermittelt werden. 
var b = {0, 1, 2, 3}; // Error, collection initializer nicht mgl. 
var c = null; // Error, null ist nicht erlaubt 
var a = b => c + 1; // Error, lambda expr. haben keinen Typ
var i = i++; // Error, Initializer darf nicht sich selbst ref.

Beispiel für foreach:

int[] nums = { 0, 1, 2, 3, 4 };
foreach (var n in numbers) Console.WriteLine(n);

Beipiele für implizit typisierte Arrays:

var a = new[] { 1, 10, 1000 };    // int[]
var b = new[] { 1, 1.5, 2, 2.5 }; // double[]
var c = new[] { "hello", null, "world” }; // string[]
var d = new[] { 1, "one", 2, "two" };     // Error

Verschachtelte Varianten sind auch möglich. Hier wird eine anonyme Datenstruktur innerhalb eines Arrays aufgebaut, die wiederum ein implizit typisiertes Array verwendet:

var c = new []{
    new {Name = “Microsoft“,
        PhoneNumbers = new []{ “206-555-0101“, “425-882-8080” }},
    new {Name = “Basta“,
        PhoneNumbers = new []{ “206-666-0101“, “425-888-8080” }}
};

^ zum Teil 1: Einleitung

> zum Teil 3: Extension Methods