Named & Optional Arguments, Co- & Contravariance, Dynamic und COM Interop

Written By: Mario Priebe - Mrz• 12•10

Ich hab kürzlich die BASTA Spring 2010 besucht (über 500 Teilnehmer). Es war wirklich eine sehr informative Veranstaltung über aktuelle Entwicklungen im .NET Bereich. Folgender Abriss soll die Neuerungen im .NET Framework 4.0, Entity Framework 2, VisualStudio 2010, WPF 4 und Silverlight 4, aufzeigen.

Im folgenden Artikel möchte ich “Named Arguments”, “Optional Arguments”, “Co- und Contravariance”, “Dynamic”, “COM Interop” mit wenigen Worten vorstellen.

Named Arguments

Mit Named Arguments ist es möglich, die entsprechenden Parameter beim Methodenufruf zu bezeichnen. Das macht Sinn und hilft enorm, wenn wirklich viele Parameter erwartet werden.

Beispiele

alt:

MeineMethode(0, 10) ;

neu:

MeineMethode(start: 0, ende: 10);

die Parameter können so auch in unterschiedlicher Reihenfolge übergeben werden:

MeineMethode(end: 10, start:0);

Weiter ist es auch möglich die übergebenen Parameter während des Aufrufs zu manipulieren:

MeineMethode(end: 10+5, start: 0+1);

Optional Arguments

Parameter können jetzt auch mit Default-Werten vorbelegt werden. Dazu definiert man in der Methode den Parameter mit einem konstanten Wert. Diese Parameter dürfen jedoch erst am Ende der Parameterliste definiert werden!

MeineKlasse(string nachName, string vorName, int start = 0, int ende = 10){...}

Beim Aufruf der Methode / Konstruktor müssen die mit Defaultwerten versehende Parameter auch nicht mehr mit angegeben werden.

MeineKlasse mk = new MeineKlasse("Mustermann", "Max");

Wenn man in einem .NET 4.0 Compiler eine existierende .NET 3.5 Interop Klasse verwendet, können jene Methoden, ebenfalls so aufgerufen werden. (Beispiel weiter unten bei “COM und Interop Verbesserung”)

Aber, so gut auch das neue Feature ist, muss man hier aufpassen. Denn definiert man in einer Lib Default-Parameter und ändert diese später, darf nicht nur die Assembly neu gebaut werden, sondern unbedingt auch die verwendende Assembly. Also sollte man hier genau abschätzen, wann diese “Defaults” einen Sinn machen und man sollte sicher stellen, dass diese möglichst nie wieder geändert werden müssen …

Co- und ContraVariance

Mehrere generische Schnittstellen und Delegaten in .NET 4.0 unterstützen jetzt Kovarianz und Kontravarianz.

Quellen:

Wikipedia Kovarianz und Kontravarianz [1]
MSDN Covariance and Contravariance in Generics [2]

Dynamic

Mit .NET 4.0 bekommt das Framework einen neuen statischen Typ namens Dynamic. Nach einer Zuweisung von Dynamic, erlaubt der Compiler einen Aufruf von beliebigen Methoden mit einer beliebigen Anzahl von Parametern. Indexer, Properties und Delegaten werden dynamisch dispatched (versendet). Dieser ist auch als Binder für verschiedene Sprachen geeignet (JavaScript, Ruby, Reflection) Eine Überprüfung findet jedoch erst zur Laufzeit statt!

Ein kleines Beispiel soll das verdeutlichen: Wir haben eine Klasse und wollen die an einer Stelle verwenden, wo wir diese nicht kennen. Durch eine Methode lassen wir uns eine Instanz erstellen. Anschließend definieren wir uns ein dynamic und greifen wir auf die Properties und eine Methode zu. Wie schon gesagt, eine Intellisense haben wir hier nicht, einen Compilerfehler gibt es aber auch nicht, wenn man sich hier verschreiben sollte. Ein Fehler fällt somit erst zur Laufzeit auf.

public class MyClass
{
    public string Name { get; set; }
    public DateTime Birthday { get; set; }
 
    public void Print()
    {
        Console.WriteLine("Name: {0}, Birtday: {1}", Name, Birthday);
    }
}
public static MyClass MyMethod()
{
    return new MyClass();
}
static void Main(string[] args)
{
    dynamic mO = MyMethod();
 
    mO.Name = "Max";
    mO.Birthday = new DateTime(1973, 01, 23);;
    mO.Print();
}

COM und Interop Verbesserung

Besserer COM Interop durch Named und Optional Arguments, und durch das dynamic Keyword ist es nun möglich, einfacher auf COM Objekte zuzugreifen

Beispiel Speichern eines ExcelDokuments:

mit .NET 3.x wurde das bisher wie folgt implementiert:

using Excel = Microsoft.Office.Interop.Excel;
namespace COMInterop
{
   class Program
   {
      static void Main(string[] args)
      {
         var excelApplication = new Excel.Application();
         excelApplication.Visible = true;
         var excelWorkBook =
            excelApplication.Workbooks.Add(
            System.Reflection.Missing.Value);
         Excel.Worksheet wkSheetData = (
            Excel.Worksheet)excelWorkBook.ActiveSheet;
         excelWorkBook.SaveAs("Testfile.xls",
            System.Reflection.Missing.Value,
            System.Reflection.Missing.Value,
            System.Reflection.Missing.Value,
            System.Reflection.Missing.Value,
            System.Reflection.Missing.Value,
            Excel.XlSaveAsAccessMode.xlShared,
            System.Reflection.Missing.Value,
            System.Reflection.Missing.Value,
            System.Reflection.Missing.Value,
            System.Reflection.Missing.Value,
            System.Reflection.Missing.Value);
      }
   }
}

unter .NET 4.0 bedarf es nur noch folgenden Code

using Excel = Microsoft.Office.Interop.Excel;
namespace COMInterop
{
   class Program
   {
      static void Main(string[] args)
      {
         var excelApplication = new Excel.Application();
         excelApplication.Visible = true;
         dynamic excelWorkBook = excelApplication.Workbooks.Add();
         Excel.Worksheet wkSheetData = excelWorkBook.ActiveSheet;
         excelWorkBook.SaveAs("Testfile.xls", AccessMode: Excel.XlSaveAsAccessMode.xlShared);
      }
   }
}

Wie man in diesem Beispiel sehen kann, sind alle drei Neuerung verwendet worden. Man muss hier nicht mehr alle Parameter übergeben (Optional Arguments) und auch die Reihenfolge kann Dank Named Arguments beeinflusst werden. Durch die Zuweisung der dynamic Variable können hier die Excel Methode direkt über die PunktNotation aufgerufen werden.

Auch die Verwendung ist durch dynamic nun etwas einfacher geworden. Folgende kleinen Beispiele verdeutlichen dieses:

Alt

((Excel.Range)excel.Cells[1, 1]).Value2 = "Hello";

Neu

excel.Cells[1, 1].Value = "Hello";

Alt

Excel.Range range = (Excel.Range)excel.Cells[1, 1];

Neu

Excel.Range range = excel.Cells[1, 1];

Im nächsten Artikel geht es Parallele Programmierung mit dem .NET 4.0 Framework – PLINQ, Task, Concurrency

Biggle's Blog