Team Foundation Server – Prozess Template anpassen

Wer sich schon immer gefragt hat wie man das Prozess Template anpassen kann kommt auf keinen Fall am “Process Template Manager” des TFS vorbei.

Zu finden ist dieser im “Team Explorer” (z.B. Visual Studio 2005/2008 öffnen) und das Team Explorer Fenster anzeigen (View > Team Explorer). Wenn man dort den TFS Server eingetragen hat, kann man den “Process Template Manager” unter “Team Foundation Server Settings” finden.

 
Process Template Manager starten

Im Manager kann man dann komplette Templates Hoch- und Runterladen sowie löschen.

Process Template Manager

Ein Prozess-Template besteht aus einer Reihe Ordner und Dateien (viel XML). Zum Anpassen eines Templates kann man z.B. ein vorhandenes (Standard-Template bei TFS Installation oder z.B. von Codeplex) in einen lokalen Ordner herunterladen und an der gewünschten Stelle mit Visual Studio bearbeiten.

Ordnerstruktur eines TFS Process Templates

Visual Studio unterstützt sowohl bei der Bearbeitung von Feldern, Layouts, Workflows und Workitem Typen. Das ganze kann man beliebig Komplex betreiben und ist sicher Inhalt vieler weiterer Blogeinträge, Artikel, …

 
TFS Process Template im Visaul Studio bearbeiten

Hat man nun seine gewünschten Änderungen vorgenommen lädt man das angepasste Template über den Process Template Manager wieder hoch (Auswahl des Ordners wo die “ProcessTemplate.xml” liegt). Zuvor sollte man die Bezeichnung des Templates anpassen. War der Upload erfolgreich kann man nun ein neues Projekt mit dem gewünschten Template anlegen.

Viel Spaß beim ersten anpassen eines Templates.

TFS Team Build: Testen von Webservices mit UnitTests auf dem Client und Team Build Server

Damit ein UnitTest, den wir gegen einen WebService (z.B. TOService) ausführen auch auf dem Team-Build Server läuft sind folgende Schritte notwendig:

1. Im UnitTest eine WebReference zum Webservice einfügen:

2. Im UnitTest folgendes Attribut über der UnitTest-Methode einfügen:

[AspNetDevelopmentServer("TOServiceHost",
		"%PathToWebRoot%\\Test.TOServiceHost")]

3. In der UnitTest-Methode den WebServiceHelper verwenden:

var sc = new TOService();
WebServiceHelper.TryUrlRedirection(sc,
			TestContext,"TOServiceHost");
Assert.NotNull(sc.MyMethodForTest());

4. Im Visual Studio unter “Tools” > “Options” > “Test Tools” > “Test Execution” den Pfad eintragen:

Es kann passieren, das auf dem Client der Ordner zum Webservice nicht richtig aufgelöst wird. Dann kann man im VS einstellen, wo der Basisordner (%PathToWebRoot%) liegen soll. Den Ordner, wo der Webservice “Test.TOServiceHost” drin liegt den ihr testen wollt entsprechend einstellen.

 

5. In der .vsmdi Datei den Test in die Liste eintragen, die im Teambuild ausgeführt wird:

In der VSMDI Datei können dann alle UnitTests der Solution in eine Liste eingefügt werden:

Im Teambuild File wird die Liste aus dem VSMDI File angegeben, womit alle UnitTests dieser Liste auf dem Teambuild Server ausgeführt werden:

<MetaDataFile Include=
   "$(BuildProjectFolderPath)/../../Main/Source/Test/test.vsmdi">
   <TestList>AllTests</TestList>
</MetaDataFile>

In der Liste können jetzt auch Tests aufgeführt werden, die einen WebService aus der Solution aufrufen.

6. SolutionFile ggf. bearbeiten:

Wichtig ist, dass der Webservice bzw. die Webapplikation mit auf dem Server compiliert wird. Das kann z.B. über die Solution Configuration “Debug” sichergestellt werden. Wenn hier ein anderer Typ eingeführt wurde (z.B. “Debug_CodeAnalysis”) kann es passieren, dass die Website auf dem Server nicht unter “_PublishedWebsites” kompiliert/abgelegt wird. Dann funktionieren die UnitTests auf dem Server wieder nicht. Es bietet sich an den Solution-Typ “Debug” und für alle gewünschten Projekte (außer Webprojekte) einen anderen Typ z.B. “Debug_CodeAnalysis” zu verwenden:

 

7. Teambuild mit Codeanalysis, CodeCoverage und UnitTests:

Jetzt sind wir schon ziemlich weit gekommen und freuen uns das endlich unser Webservice um den es im Projekt zentral geht auch über UnitTests auf dem Team Build Server jeder Zeit (z.B. jede Nacht – Continuous Integration) getestet werden kann. Verwendet man nun alle Features die zum Team Build dazu gehören, wie Code Analysis und Code Coverage, wundert man sich doch recht schnell warum die Coverage Werte sehr niedrig sind. Ein kleine Recherche in den erzeugten Dateien und Reports ergibt, dass alle UnitTests die über den WebService gelaufen sind nicht im CodeCoverage auftauchen ;(… Das ist natürlich schlecht!!! Wenn ich aber die WebService-Methoden nicht über die WebReference sondern direkt teste fehlt mir wieder der HTTP-Context in den Tests.) Was ist hier nun die beste Lösung? Mocking vom HTTPContext und wieder ohne WebReference testen?

WordPress Tags: Team,Build,Webservice,UnitTests,PathToWebRoot,Test

UnitTests, automatische Tests mit TFS 2008

Fast immer benötigt man für das Ausführen von UnitTests eine Umgebung wie im wirklichen Leben. Es sind also auch z.B. Konfigurationsfiles an einem bestimmten Ort (wie z.B. in einem Unterordner “config”) notwendig. Die Visual Studio UnitTests werden aber in einem eigenen Ordner ausgeführt und genau dort braucht man nun auch diesen Unterordner mit seinen Dateien. Hier gibt es im großen und ganzen zwei Ansätze. Entweder man konfiguriert die Testkonfiguration (siehe 2 Abbildungen):

–> öffnen der Testkonfiguration mit Wizard

–> Definieren von Dateien die für die UnitTests notwendig sind unter “Deployment”

Leider bietet der Wizard keine Möglichkeit einen Unterordner/Zielordner mit anzugeben. Dazu muss man das “.testconfig” File im XML-Editor öffnen und selbst am DeploymentItem-Tag herumeditieren. Dort steht einem nun das Attribut “outputDirectory” zur Verfügung.

<Deployment> <DeploymentItem filename="log4net.conf.xml" outputDirectory="config" /> <DeploymentItem filename="myentlib.config" /> </Deployment>

–> .testconfig File im XML-Editor

Der zweite Ansatz ist über ein Attribut im Testcode selbst zu definieren welche Dateien für den Test notwendig sind:

DeploymentItems (DeploymentItemsAttribute bei MSDN)

[TestMethod()] [DeploymentItem("config\\log4net.conf.xml", "config")] public void MyTest() { ... }

–> DeploymentItemAttribut im Code

DeploymentItems und TFS Team Build:

Leider hat man nun das nächste Problem mit den DeploymentItems und UnitTests im Zusammenhang mit Teambuild. Auf dem Teambuild Server können die UnitTests nur ausgeführt werden, wenn Visual Studio installiert ist. Das VS2008 hat hier wohl einen Bug, denn er sucht die für den UnitTest definierten DeploymentItems nicht im Ordner wo die Tests ausgeführt werden, sondern im Ordner wo Visual Studio auf dem Teambuild Server installiert ist (System.Configuration.ConfigurationErrorsException: The configuration folder ‘D:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\config\log4net.conf.xml’ doesn’t exist).

Geholfen hat jetzt nur ein Workaround im Testcode:

[ClassInitialize()] public static void MyClassInitialize( TestContext testContext) { AppDomain.CurrentDomain.SetData("APPBASE", Environment.CurrentDirectory); }

–> Bei jedem UnitTest in der Initialisierung einzufügen (Forum post hier)

Team Build – Code Coverage – Partially Succeeded

Manchmal kommt es trotz erfolgreichen Build und auch erfolgreichen durchführen aller UnitTests zu dem Status “Partially Succeeded”.

–> “Partially Succeeded” trotz erfolgreichem Build und no failed UnitTests ?!

Ein bisschen Nachforschung bringt einen dann auf den Pfad, dass es ein paar Warnungen gegeben hat, die man auch Abarbeiten kann. Man lädt sich die Testresults auf den lokalen Rechner (Link unter “Test Run” anklicken) und arbeitet die Warnungen ab. Zum Beispiel will Code Coverage zwingend x86 dlls (siehe auch hier). Weiterhin müssen alle dlls die im Code Coverage eingeschlossen sind auch verfügbar sein. Code Coverage wird übrigens auch in der .testconfig Datei definiert und kann mit dem Wizard (siehe oben im Artikel) eingerichtet werden.

Visual Studio AddOns, AddIns, Plugins – Links

Das nackte Visual Studio 2005 und 2008 ist schon ganz nett, aber wenn man dann noch das ein oder andere Plugin installiert wird es ein super Tool. Die meisten der Plugins sind sowohl für Visual Studio 2005 als auch 2008 verfügbar. Die meisten davon verwende ich oder habe ich zumindest schon ausprobiert. Die Reihenfolge gibt keine Aussage über die Wertigkeit oder häufigkeit der Verwendung (wobei Ghostdoc und ReSharper schon zu meinen Lieblingen zählen;) Die Liste ist mit Sicherheit nicht vollständig, aber das ändert sich sowieso ab und zu, wie man auch an dem Inhalt eines früheren Artikels von mir sieht.

• GhostDoc (Dokumentation von Sourcecode)
• ReSharper (Refactoring, Code Analyse, Produktivität, Qualität)
• Guidance Automation Toolkit für Visual Studio 2008 
• Guidance Automation Extension und ein Update dazu
• Software-Factories
  • Web Service Software Factory Modeling Edition
  • Smart Client Software Factory
  • Web Client Software Factory
  • Mobile Client Software Factory
• Silverlight Tools for Visual Studio 2008 SP1 siehe auch Silverlight Seite
• Silverlight Sidebargadget Projektvorlage mit Erläuterung
• Für Subversion – VisualSVN, TortoiseSVN, AnkhSVN
• Visual Studio Team System Management Model Designer Power Tool
• Visual Studio® 2008 Web Deployment Projects mit Erläuterungen
• Visual Studio 2008 Team Explorer und Visual Studio 2005 Team Explorer
• Visual Studio 2005 Team Foundation Server MSSCCI Provider und Visual Studio 2008 Team Foundation Server MSSCCI Provider
• Visual Studio Team System 2008 Team Foundation Server Power Tools – Oktober 2008 Release und Microsoft Visual Studio 2005 Team Foundation Server Power Tools – September 2007 release
• Enterprise Library 4.1 – Oktober 2008 (Sammlung wiederverwend-barer Codeblocks)
• StyleCop (Source Code Style Analyse)

TFS – Verwenden von Areas und Iterations

 

Die Einstellung für Iterations und Areas findet man zum Beispiel im Team System Web Access nach Auswahl des entsprechenden Team Projektes unter Settings > Team Project

Iterations bieten sich an für die Verwendung von geplanten Releases. So kann man Scenarien, Tasks, Bugs usw. schön einem Release zuordnen. Sie können auch als „Sprint“ verwendet werden.

Areas können verwendete werden um die Aufgaben (Scenarien, Tasks, Bugs, usw.) einem bestimmten Teil des Projektes zuzuordnen. So kann man zum Beispiel Areas für die einzelnen Schichten einer Applikation (Frontend, Backend, Datenbank, …) oder auch für Bereiche die mit Code nix zu tun haben (Konzepte) verwenden.

Die Areas und Iterations lassen sich nun sehr komfortabel in entsprechende Queries einbauen. Damit lassen sich die Aufgaben (Scenarien, Tasks, Bugs, usw.) entsprechend Releases und Bereichen zuordnen und der Überblick bleibt auch bei größeren Projekten vorhanden.

Die angelegten Queries lassen sich dann auch für den Entwickler beim CheckIn im Visual Studio auswählen.

Basta 2008 Spring

 

Ich durfte mal wieder dabei sein auf der Basta 2008 Spring Edition und habe doch einige interessante Vorträge gesehen. Der wohl beste Vortrag der mir im Gedächtnis bleiben wird hatte gar nichts mit .NET zu tun, sondern mit Zeitmanagement und wurde von Torsten Weber mit dem Thema „(Keine) Zeit für Herzrasen!“ gehalten. Die Folien und einen Blogeintrag dazu gibt es hier.

Ansonsten habe ich mir einige Themen des VSTS angeschaut und Informatio-nen dazu gesammelt, wie wir unseren TFS 2005 auf TFS 2008 upgraden und die vielen Möglichkeiten besser einsetzen können. Dazu hat u.a. Christian Binder einiges erzählt, wobei man wieder mal das Release von „Rosario“ nicht erwarten kann. Zum Thema Hierarchische Workitems kann vorerst nur ein 3rd Party Tool von http://www.artiso.com Abhilfe schaffen. Dazu findet sich auch ein Blogeintrag auf Christian Binders blog.

Weitere Folien einiger Vorträge der Basta findet man:

• bei Thomas Schissler (Qualitätsmanagement mit VSTS, Programmier-ung mit dem TFS SDK)
• Daniel Walzenbach (ASP.NET Model View Controller, Visualisierung von Geodaten mit Virtual Earth)

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

Die Überraschung

Bei meinem ursprünglichen ersten Blick auf .NET 3.5 dachte ich ich könnte die neuesten und interessantesten Features in einer 8 teiligen Serie darstellen. Bei der Bearbeitung viel mir allerdings auf, dass es an manchen Stellen sinnvoll war schon Features in anderen Teilen mit zu besprechen. Am Ende hatte ich auf einmal nur noch 7 Teile die zu dem Thema waren. Um die Serie nicht früher abzubrechen habe ich mich noch mal umgeschaut und einige weitere Interessante Themen, die mit der Einführung von .NET 3.5 zu tun haben. Da sind zum Beispiel das neue Visual Studio 2008 – warum soll ich umsteigen, was ist neu, was sind die Killer-Features, wann sollte ich nicht umsteigen. Weiterhin werde ich auch nochmal einen kurzen Schritt zurück gehen und nochmal ein paar grundlegende Worte zu .NET 3.5 im Verhältnis zu .NET 2.0 erzählen – was von den neuen Sprachfeatures geht denn auch mit .NET 2.0? Das Thema VSTO hat mich in Verbindung mit VS 2008 ebenfalls interessiert und wird sicher auch einige andere begeistern.

Fange ich mal mit VSTO an. Zusammen mit Visual Studio 2008 wird auch VSTO3.0 mit ausgeliefert. VSTO3.0 geht ab der Visual Studio 2008 Professional Version vollständig in Visual Studio auf und beendet den wirrwarr der bisher vorhandenen VSTO-Versionen. Mit dem neuen Visual Studio 2008 können alle Projektvorlagen für Office 2003 und Office 2007 verwendet werden. Das macht es den Entwicklern natürlich deutlich einfacher. Auf die einzelnen weiteren Neuerungen gegenüber den anderen Versionen will ich hier trotzdem nicht eingehen. Eine will ich trotzdem erwähnen, die Verwendung der Ribbons ist Dank eines Designers  nun deutlich intuitiver.

Was ist denn nun .NET 3.5 im Verhältnis zu .NET 2.0 und welche der beschriebenen Features kann ich denn nun mit .NET 2.0 auch nutzen? Eines ist gegenüber der Erweiterung von .NET 3.0 bei .NET 3.5 gleich geblieben, es wird weiterhin die BCL des .NET 2.0 verwendet. Streng genommen sind wir also immer noch bei .NET 2.0. Mit den Erweiterungen von .NET 3.0 und .NET 3.5 kam es mittels zusätzlicher Assemblies zu einer Funktionserweiterung (WPF, WCF, WF … um nur die bekanntesten von .NET 3.0 zu nennen). Mit .NET 3.5 ist weiterhin ein SP für .NET 2.0 und .NET 3.0 hinzugekommen. Man sollte also aufpassen, wenn man Klassen aus dem Servicepack verwendet, das dieses auch auf der Wirkumgebung vorhanden ist. Mit .NET 3.5 ist zusätzlich ein neuer Compiler hinzugekommen, der die ganzen Spracherweiterungen ermöglicht. Es ist damit kein Problem alle Spracherweiterungen, die keine mit .NET 3.0 oder .NET 3.5 hinzugekommen-en Funktionen verwenden auch mit .NET 2.0 einzusetzen. Der Compiler „trickst“ und wandelt den Code in BCL 2.0 verständlichen Code um. Es muss lediglich der neue Compiler (am besten Visual Studio 2008 verwenden) eingesetzt und das .NET 2.0 als Zielplattform ausgewählt werden. Bei der Verwendung der Extension-Methoden wird der Compiler allerdings die „System.Core.dll“ vermissen, die erst mit .NET 3.5 dabei ist. Da es nur ein Attribut ist das fehlt, kann das im entsprechenden Namespace einfach selbst angelegt werden und die Compilierung sollte funktionieren. Beispiel hier.

namespace System.Runtime.CompilerServices
{
    public class ExtensionAttribute:CustomAttribute
    {
    }
}

Mit der Einführung von Visual Studio 2008 ist das erste Visual Studio verfügbar, dass für mehrere .NET Versionen verwendet werden kann. Ich Denke das ist schnell einleuchtend wenn man bedenkt, dass für .NET 2.0/3.0/3.5 ein und die selbe BCL verwendet wird. Es handelt sich also nicht wie beim Sprung zwischen .NET 1.1 und .NET 2.0 um eine Änderung der BCL. Ich frage mich also, wozu ich noch Visual Studio 2005 verwenden soll, sobald ich Visual Studio 2008 in den Händen habe. Bis heute ist mir noch kein entscheidender Grund eingefallen VS 2005 weiter zu verwenden. Zu bedenken sind nur die Fragen, ob alle Projektvorlagen und VS Erweiterungen die ich nicht entbehren kann vorhanden sind. Als nächstes sollte man bei der Arbeit im Team darauf achten, dass am besten alle gleichzeitig auf die neue VS 2008 Version umsteigen, damit die neuen Solution-Files von allen verwendet werden können. Es ist sogar möglich den TFS 2005 auch mit VS 2008 und dem zugehörigen Team Explorer weiter zu verwenden.

^ Teil 1: Übersicht aller Neuerungen (Einleitung)

< Teil 8: Was geht mit Silverlight

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

Was geht bei Silverlight

In diesem Teil wollte ich mal schauen was denn nun von diesen Sprach-features auch bei Silverlight so geht. Dazu muss man natürlich voranstellen, das ich hier nur über Silverlight 2.0 sprechen werden. Erst bei Silverlight 2.0 kommt nämlich .NET als Entwicklungssystem ins Spiel. Wichtig ist trotzdem zu wissen, das es sich um ein völlig neues und vom eigentlichen .NET Framework losgelöstes System handelt. Diese .NET Laufzeitumgebung ist nur mit dem Silverlight Plugin (z.B. für IE und Firefox) verfügbar. Das Programmiermodell ist trotzdem das gleiche, da natürlich versucht wurde die wichtigsten Klassen und Libaries für Silverlight verfügbar zu machen. Somit wurde natürlich auch versucht die Sprachfeatures von C#3.0 mit in Silverlight hinein zu bringen, auch wenn dies ein anderer Compiler übernimmt. So sind LINQ und die Extension-Methods usw. auch für Silverlight anwendbar.

^ Teil 1: Übersicht aller Neuerungen (Einleitung)

< Teil 7: Linq

> Teil 9: Überraschung

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

LINQ

LINQ … Language INtegrated Query stellt eine Syntax für Abfragen zur Verfügung, die ähnlich der Syntax für relationale und hierarchische Datenabfragen wie SQL und XQuery ist. Die Abfrage beginnt dabei immer mit dem from Ausdruck und endet entweder mit einem select oder group by Ausdruck.

from c in customers
group c.Name by c.Country

Mit diesen Zeile wird aus der Liste der Customers eine nach Ländern sortierte Liste der Customer-Namen erzeugt. Das gleiche kann man auch mit Hilfe der bereits bekannten Extension-Methods und Lambda Expressions schreiben:

customers.GroupBy(c => c.Country, c => c.Name)

Es wird bei genauer Betrachtung schnell deutlich, dass bei LINQ die in den anderen Teilen besprochenen Neuerungen in .NET 3.5 ihre Anwendung finden. Es sind zum einen die Anonymen Typen notwendig, denn das Ergebnis der LINQ-Abfrage ergibt in der Regel einen neuen anonymen Typ. Weiterhin die Extension Methods, denn der Compiler macht aus der LINQ-Abfrage einen Funktionsaufruf, bei dem wiederum die Lambda-Ausdrücke wiederzufinden sind.

from c in customers
where c.Name=="Microsoft"
select c

entspricht:

customers.Where(c => c.Name == "Microsoft");

etwas komplexer:

from c in customers 
where c.Name=="Microsoft"
select c.Country

entspricht:

customers.
Where(c => c.Name=="Microsoft").
Select(c => c.Country);

oder noch etwas komplexer:

from c in customers 
orderby c.Name, c.Balance descending
select new {c.Country, c.Name, c.Balance}

entspricht:

customers.
OrderBy(c => c.Name).
ThenByDescending(c => c.Balance).
Select(c => new { c.Name, c.Country, c.Balance })

Weiterhin können auch mehrfache Abfragen kombiniert und verschachtelt werden:

from c in customers
where c.City == "Dresden"
from o in c.Orders
where o.OrderDate.Year == 2008
select new { c.Name, o.OrderID, o.Total }

entspricht:

customers.
Where(c => c.City == "Dresden").
SelectMany(c =>c.Orders.
Where(o => o.OrderDate.Year == 2008).
Select(o => new { c.Name, o.OrderID, o.Total })

Und noch ein Beispiel mit „into“:

from c in customers 
group c by c.Country 
into g
select new { Country = g.Key, CustCount = g.Group.Count() }

kann auch so geschrieben werden:

from g in     
    from c in customers 
    group c by c.Country
select new { Country = g.Key, CustCount = g.Group.Count() }

entspricht:

customers.
GroupBy(c => c.Country).
Select(g => new { Country = g.Key, CustCount = g.Group.Count()})

Alles in allem ist LINQ wohl die komplexeste Erweiterung in .NET 3.5, da diese auch die meisten der besprochenen in sich vereint. Ich konnte hier also nur ganz kurz und grob auf die Syntax eingehen um einen ersten Start zu dem Thema zu finden. Es ist sicher sinnvoll sich mit LINQ to SQL (Thema O/RM) und mit den verfügbaren Beispielen und HoLs. Weiterhin bieten eine Reihe von Blogs eine Menge an Informationen wie z.B. dieser.

^ Teil 1: Übersicht aller Neuerungen (Einleitung)

< Teil 6: Anonymous Types

> Teil 8: Was geht mit Silverlight

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

Anonymous Types

Ich denke, dass es sich bei den Anonymous Types um ein recht einfach verständliches Feature handelt. Vielleicht wird es als Einzel-Feature nicht unbedingt häufig Anwendung finden, aber spätestens mit LINQ wird auch dieses Feature im Gesamtkonzept eine Daseinsberechtigung haben. Folgendes Codebeispiel würde ich auch zu diesem Context zählen:

class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Auf den ersten Blick erscheint das wie eine abstrakte Klasse oder ein Interface, aber es handelt sich um ein .NET 3.5 Feature. Der Compiler generiert einfach die notwendigen privaten Variablen und macht aus diesen Zeilen Code jeweils einen Standard „getter“ und „setter“. Es spart dem faulen Programmierer einfach ein paar Zeilen Code. Auch folgende erweiterte Variante ist möglich:

class Customer
{
    public string Name { get; protected set; }
    public int Age { private get; set; }
} 

Der Compiler ist auch hier Klever und generiert den entsprechenden Code, wobei in diesem Beispiel der „getter“ und „setter“ jeweils unterschiedliche Access-Modifier aufweisen.

Das folgende Beispiel zeigt wohl die in Zusammenhang mit LINQ häufigere Anwendung(Schreibweise) der anonymen Typen:

var p1 = new { Name = "Anonym", Price = 666.00 };
p1.Name = "Doch nicht Anonym";

Hier wird vom Compiler ein anonymer Typ mit zwei Properties generiert und auf die Variable p1 zugewiesen. Das schöne daran ist auch die vollständige Intellisense Unterstützung von Visual Studio 2008. Sogar folgende Zeilen werden vom Compiler ohne Fehler compiliert:

var p1 = new { Name = „Test1„, Price = 666.00 };
var p2 = new { Name = „Test2„, Price = 777.00 };
p1 = p2;

Hier wird vom Compiler ein und der selbe anonymer Typ für p1 und p2  generiert und somit ist auch die Zuweisung gültig. Das sind eigentlich die wichtigsten Fakten zu diesem Thema, was im nächsten Teil mit LINQ noch extensiver zum Einsatz kommt.

^ Teil 1: Übersicht aller Neuerungen (Einleitung)

< Teil 5: Object und Collection Initializer

> Teil 7: LINQ

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

Object und Collection Initializer

Das Initialisieren von Objekten und Collections ist mit C#3.0 durch eine zusätzliche Möglichkeit bereichert worden. In erster Linie spart man meiner Meinung nach ein paar Zeilen Code und damit natürlich Zeit. Auf dem zweiten Blick erkennt man dann natürlich noch die Notwendigkeit dieser Möglichkeit im Gesamtkonzept von C#3.0. Das wird vielleicht erst ganz am Ende bei Betrachtung aller Neuigkeiten im Gesamtkonzept klar. Ein paar Beispiele erleichtern natürlich die Verständlichkeit. Also hier die neuen Object Initializer:

var c = new Customer {Id = 1, Name = "Microsoft"};

Was der bisherigen Schreibweise entspricht:

Customer c = new Customer();
c.Id = 1;
c.Name = "Microsoft";

Das ganze kann natürlich auch in verschachtelter Form angewendet werden. Im folgenden Beispiel wird eine Linie mit zwei Punkten und deren Koordinaten initialisiert:

var l = new Line{
 P1 = {X = 0, Y = 0},
 P2 = {X = 10, Y = 10}
};

Das entspricht:

Line l = new Line();
l.P1.X = 0;
l.P1.Y = 0;
l.P2.X = 10;
l.P2.Y = 10;

Viel mehr kann man dazu eigentlich nicht erzählen. Also noch was zu den Collection Initializern:

List<int> l = new List<int> {0, 1, 2, 3};

und ein bisschen komplexer:

var c = new List<Customer>{
    new Customer {Name = "Microsoft",
        PhoneNumbers = { "206-555-0101", "425-882-8080" }},
    new Customer {Name = "Basta",
        PhoneNumbers = { "206-666-0101", "425-888-8080" }}
};

was man auch wie folgt schreiben könnte:

var c = new List<Customer>();
var _c1 = new Customer();
_c1.Name = "Microsoft";
_c1.PhoneNumbers.Add("206-555-0101");
_c1.PhoneNumbers.Add("425-882-8080");
c.Add(_c1);
var _c2 = new Customer();
_c2.Name = "Basta";
_c2.PhoneNumbers.Add("206-666-0101");
_c2.PhoneNumbers.Add("425-888-8080");
c.Add(_c2);

Es ist denke ich eines der leichter verständlichen und am schnellsten anwendbaren neuen Features von .NET 3.5
Viel Spaß beim verwenden…

^ Teil 1: Übersicht aller Neuerungen (Einleitung)

< Teil 4: Lambda Expressions

> Teil 6: Anonymous Types

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

Expression Trees und Lambda Expressions

Nach langer langer Zeit will ich mal wieder in meiner kleinen Serie fortfahren. Da es jetzt schon etwas komplexer wird habe ich mich so lange gesträubt hier weiter zu schreiben. Jetzt versuche ich mal wieder so einfach wie möglich in das Thema einzuführen.
Eigentlich liegt der Ursprung in den anonymen Methoden, die mit C# 2.0 eingeführt wurden. Zur Erinnerung ein kurzes Beispiel einer anonymen Methode:

IEnummerable<Customer> list = customers.Where(
	delegate(Customer c)
	{
		return c.Name == "Microsoft";
	});

In diesem Beispiel ist das es das Ziel alle „customers“ mit dem Namen „Microsoft“ in einer Enummeration zusammenzufassen. Hier ist auch das erste mal ersichtlich, dass wir mit der Methode „Where“ auf ein bereits erläutertes neues Feature der Extension Methods zurückgreifen.

public static IEnumerable<T> Where<T>(
	this IEnumerable<T>   source, Func<T, bool> predicate)
{
	foreach(T item in source) {
		if (predicate(item)) yield return item;
	}
}

Mit C#3.0 kann man nun die oben gezeigte anonyme Methode auf eine Zeile Code reduzieren:

IEnummerable<Customer> list =
	customers.Where(c=>c.Name=="Microsoft");

In C# wird ein Lambda-Ausdruck syntaktisch als Parameter-Liste gefolgt von einem => Token und dann gefolgt von dem Ausdruck oder einer ausführ-baren Block-Anweisung (wenn der Ausdruck aufgerufen wird) geschrieben:

params => Ausdruck

also in diesem Beispiel:

c => c.Name == „Microsoft“ oder in ausführlicher Schreibweise
(Customer c) => c.Name == „Microsoft“

x => x + 1     // Implicitly typed, expression body 
x => {return x + 1;}// Implicitly typed, statement body 
(int x) => x + 1    // Explicitly typed, expression body 
(int x) => {return x + 1;} // Explicitly typed, stmnt body 
(x, y) => x * y            // Multiple parameters 
() => Console.WriteLine()  // No parameters 

Im Gegensatz zu anonymen Methoden muss bei Lambda Expression der verwendete Typ nicht explizit angegeben werden. Bei der Schreibweise c=>c.Name ist dem Compiler bereits klar, dass c vom Typ Customer sein muss, da die Extension Methode „Where“ mit einer generischen Liste vom Typ „Customer“ gearbeitet hat. Bei Verwendung von Visual Studio 2008 handelt es sich nicht nur um Compilezeit Support, sondern es wird auch bei der Designzeit mit Intellisense unterstützt.

Einige Dinge müssen beachtet werden:

delegate R Func<A,R>(A arg);

–>

Func<int,int> f1 = x => x + 1; // Ok 
Func<int,double> f2 = x => x + 1; // Ok 
Func<double,int> f3 = x => x + 1; // Error 

In der letzten Zeile ist „x+1″ nicht implizit ein double, weswegen diese Zeile schon beim Compilieren zum Fehler führt.

Was sind nun Expression Trees?

Eines der Dinge warum die Lambda-Ausdrücke so ein mächtiges Werkzeug aus der Entwickler-Perspektive sind, ist dass man sie kompiliert kann. Entweder als delegate-Code (in Form einer IL Methode) oder als Expression Tree Objekt, die benutzt während der Laufzeit benutzt werden können um den Ausdruck zum optimieren, zu analysieren oder zu transformieren. Die Extension Methode „Where“ im oberen Beispiel zeigt wie man diese in Form eines delegate Code kompilieren kann.

Kompilierte Lambda-Ausdrücke funktioniert toll, wenn wir diese für Daten innerhalb des Speichers verwenden wollen. Aber bei Fällen, in denen Sie Abfrage von Daten aus einer Datenbank durchführen wollen, ist das nicht immer der geeignete Weg. Stattdessen würde ich gerne das LINQ zu SQL ORM zur Übersetzung meines Lambda-Filters in einen SQL-Ausdruck verwenden und die Filter-Abfrage in der Remote-SQL-Datenbank durchführen lassen. Auf diese Weise würde ich nur die gefilterten Zeilen als Ergebnis erhalten.

Func<int,int> f = x => x + 1; // Code 
Expression<Func<int,int>> e = x => x + 1; // Data 

Framework-Entwickler können dies erreichen, indem sie die Argumente zu Lambda-Ausdruck vom Typ Expression <T> statt Func <T> erklären. Dies führt dazu, dass ein Lambda-Ausdruck Argument als Expression-Tree kompiliert wird. Dieser kann dann zur Laufzeit analysiert werden:

Expression<Func>Customer, bool>> filter;
filter = c => c.Name = "Microsoft";
BinaryExpression body = (BinaryExpression)filter.Body;

Im Fall von LINQ zu SQL, kann dieser Expression und Lambda-Filter verwendet werden, um diesen in SQL-Standard zu übersetzen und gegen eine Datenbank auszuführen (logisch „SELECT * from Customers where Name = ‘Microsoft’“).

^ Teil 1: Übersicht aller Neuerungen (Einleitung)

< Teil 3: Extension-Methods

> Teil 5: Object und Collection Initializer

.NET 3.5 – Neuerungen bei C#3.0 – Teil 1 von 9 (Einleitung)

In den nächsten Tagen werde ich nach und nach die Neuerungen im .NET 3.5 Framework (im speziellen in C#3.0) hier vorstellen. Das ganze natürlich mit Codebeispielen hinterlegt.

Folgende Teile werde ich betrachten:

• Teil 1: Diese Einleitung
• Teil 2: Implizit typisierte Variablen, Implizit typisierte Arrays
• Teil 3: Extension-Methods
• Teil 4: Lambda Expressions und Expression Trees 
• Teil 5: Object und Collection Initializer
• Teil 6: Anonymous Types
• Teil 7: LINQ
• Teil 8: Was geht mit Silverlight
• Teil 9: Überraschung

Wer es nicht erwarten kann, schaut sich am besten die C#3.0 Spezifikation und die zugehörigen Hands on Labs an.
Linq Samples findet man hier und hier.

Zur Einleitung gehört natürlich neben der Agenda auch ein paar Worte zu C#3.0 bzw .NET 3.5 die hiermit kommen.
Bei dieser neuen Version von C# handelt es sich vor allem um eine mit Features zur Verbesserung der Produktivität und es geht alles um die Verarbeitung von Daten (suchen, teilen, filtern, verarbeiten,…). Es handelt sich im Unterschied zu neuen Versionen bei Java nicht um eine API-Erweiterung, sondern um Spracherweiterungen. Dabei wurde vor allem auf aktuelle moderne beliebte dynamische Sprachen wie Python oder Ruby geschaut. Ich glaube das wird viel Spaß machen und ich hoffe euch macht die Vorstellung der neuen Features auch Spaß.

Bis bald…
> zum Teil 2: Implizit typisierte Variablen, Implizit typisierte Arrays