Der TFs bietet ein relationales Warehouse und einen OLAP-Cube um auf Daten zuzugreifen, z.B. für Reports. Leider gibt es keine Möglichkeit, PlainText-Felder im Warehouse abzulegen. Es gibt aberhin und wieder die Situation, dass man diese Felder ausgeben möchte. Dazu gibt es verschiedene Möglichkeiten. Die sauberste ist, wenn man die Felder über die TFS API ausliest. Einen etwa schnelleren Weg zeige ich hier auf, auch wenn der nicht ganz sauber ist. Dieser Weg geht direkt auf die operational Datenbank des TFS und stellt damit ein von Microsoft nicht supportetes Szenario dar. D.h. Microsoft kann die Datenbankstruktur jederzeit ohne Vorankündigung ändern was dazu führen kann, dass der Ansatz so nicht mehr funktioniert.

Mit folgender Abfrage auf die Datenbank der entsprechenden Team Project Collection kann man beispielsweise das Description-Feld für alle Work Items abfragen. Die Abfrage ist für den TFS 2010 konzipiert.

          SELECT dbo.WorkItemsLatest.ID ,dbo.WorkItemsLatest.Rev
,dbo.WorkItemsLatest.[Work Item Type] ,dbo.WorkItemsLatest.Title
,dbo.WorkItemsLatest.State ,LongTexts.Words FROM dbo.WorkItemsLatest LEFTJOIN (SELECT lt.ID
,lt.Rev ,lt.Words FROM (SELECT t1.* FROM dbo.WorkItemLongTexts
t1 LEFTOUTERJOIN dbo.WorkItemLongTexts
t2 ON t1.ID = t2.ID AND t1.Rev
< t2.Rev WHERE t2.id isNULL)
lt INNERJOIN dbo.Fields ON lt.FldID
= Fields.FldID AND Fields.ReferenceName = 'System.Description')
LongTexts ON dbo.WorkItemsLatest.ID = LongTexts.ID 

Nachdem Unit-Tests in C# und VB.Net inzwischen eine gewisse Verbreitung gefunden habe, werde in letzter Zeit häufiger darauf angesprochen, wie denn C++ Entwickler in Visual Studio Unit-Tests nutzen können. Mein Kollege Thomas Trotzki hat mir dazu mal ein paar Infos zusammengestellt.

Nach dem Unit Tests mit C++ in Visual Studio erstellt werden können aber eben nicht für alle Konstellationen und deshalb möchte ich hier erst mal einen Überblick geben.

Wie man aus der Tabelle ersehen kann, ist es heute (Visual Studio 2010) bereits problemlos möglich, für Managed C++ Unit-Test zu schreiben. Die Experience ist dabei ähnlich zur Experience von C# / VB.Net, nicht zuletzt weil Managed C++ Code auch direkt mit .NET basisierten Unit Tests getestet werden kann. Unmanaged C++ Code hingegen muss in Visual Studio 2010 noch über einen Wrapper getestet werden, da Unit Tests mit der Option /clr:safe erstellt werden müssen, diese aber die direkte Nutzung von Unmanaged Code nicht erlaubt. Dieser kann aber einfach über einen mit der Option /clr erstellten Wrapper angesprochen werden, der dann wiederum im Unit Test eingebunden werden kann.

Hinsichtlich Unit Testing von Unmanged C++ Code gibt es mit der nächsten Version von Visual Studio (Dev11) eine wichtige Neuerung. Dort ist es möglich, auch Unit-Tests in Unmanaged C++ zu schreiben und so Unmanaged C++ Code direkt zu testen.

Weitere Infos finden sich auch noch unter http://msdn.microsoft.com/en-us/library/ms243171.aspx.

Weitere Unit Tests Produkte / Frameworks

Auf Wikipedia wird eine Liste übe verfügbare Unit-Test-Werkzeuge für dieverse Programmiersprachen geführt. Informationen zu C++ gibt’s unter http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C.2B.2B 

Build Integration

TFS Build nutzt MSTest um Unit-Tests auszuführen. Somit lassen sich die Testarten die wir in Visual Studio unterstützt bekommen (z.B. Managed C++ Unit Tests) direkt im Build ausführen.

Mit Dev 11 überarbeitet Microsoft die Unit-Test-Schnittstelle ihrer Build-Werkzeuge. Es wird eine Schnittstelle für die Anbindung anderer Test-Werkzeuge angeboten. Über diese wird eine Anbindung von xUnit und nUnit mit Dev 11 angeboten, somit lässt sich bestehender Test-Code auf dieser Basis auch in Visual Studio und innerhalb der TFS Build Infrastrukur nutzen.

Zusammen mit meinen MVP-Kollegen Sven Hubert und Neno Loje sowie Christian Binder, Daniel Meixner, Patric Boscolo und Uwe Baumann von der Microsoft bin ich am 24.04, 25.04, 26.04 und 10.05 in Deutschland unterwegs um die nächste Version von Visual Studio und TFS vorzustellen.

Agenda

Weitere Informationen und die Anmeldung finden sich hier: http://www.microsoft.com/germany/visualstudio/events/eleven-roadshow.aspx

Visual Studio 11 Beta Roadshow Trailer from MSDN Coding Class (Microsoft) on Vimeo.

Um ein Team Projekt in Microsoft gehosteter TFS Lösung zu löchen, gibt es leider keine Funktion in der UI. Es gibt allerdings einen Commandline-Aufruf, der das erlaubt:

tfsdeleteproject /collection: < TeamProjectCollectionURL> <TeamProjectName>

also z.B.

tfsdeleteproject /collection: https://tfsonline.tfspreview.com/DefaultCollection Demo

Dass die Beta 1 von Visual Studio 11 und Team Foundation Server 11 ab heute veröffentlicht sind, wurde ja bereits an anderern Stellen ausreichend erwähnt. Ich möchte mit diesem Post auf den Ranger “Visual Studio 11 Wave” hinweisen. Die Visual Studio ALM Rangers sind eine Gruppe Freiwilliger die sich aus Mitarbeitern von Microsoft, MVPs und anderen zusammensetzen und die sich zum Ziel gesetzt haben mit Hilfe von Dokumentation, Best Practices, Hands on Labs und Tools die Visual Studio ALM Tools von Microsoft noch produktiver zu machen.

Die Rangers haben zeitgleich mit der neuen Beta einen ganzen Satz von Projekten zu Visual Studio 11 veröffentlicht. Ich selbst habe beim Kanban Projekt und beim Lab Management Projekt mitgewirkt, wer dazu also Fragen hat, kann sich gerne direkt an mich wenden.

Das Build System des TFS bietet die Möglichkeit einfach neue Parameter für den Build-Workflow zu definieren.

In diesem Beispiel habe ich ein neues String-Argument mit dem Namen “ServerPath” hinzugefügt. Dieses Argument können nun in der Build Definition eingestellt werden.

Etwas unschön ist noch, dass wir den Pfad als Text eingeben müssen, schöner wäre hier, wenn wir den Pfad aus der Versionsverwaltung auswählen können. Man kann für die Attribute einen Editor angeben und glücklicherweise gibt es für die Auswahl einer Datei oder eines Pfades aus der Versionsverwaltung bereits einen entsprechenden Editor. Den wollen wir nun einbinden. Dazu müssen wir die Metadaten konfigurieren.

Der Parameter Name muss hier genau dem Argument-Name entsprechen. Und nun kommt der entscheidende Punkt, wir geben im Feld Editor “Microsoft.TeamFoundation.Build.Controls.ServerFileBrowserEditor, Microsoft.TeamFoundation.Build.Controls” ein. Damit wird nun neben dem Eingabefeld in der Build-Definition ein Button angezeigt mit dem sich der entsprechende Editor öffnen lässt.

Thomas Trotzki, ein Kollege von mir, führt im Auftrag von Microsoft die C++ Days durch. Es gibt noch vereinzelt Plätze. Wer also mit C++ arbeitet dem sei diese Veranstaltungsreihe wärmstens empfolen.

C++ geht mit der Zeit – gehen Sie mit! Wir zeigen Ihnen die Neuerungen und Trends in der Microsoft C++-Welt, von neuen Sprachfeatures über effektive Parallelisierung bis hin zu professionellem Software Engineering durch Application Lifecycle Management. Termine gibt es in Berlin, Bad Homburg, Karlsruhe oder Köln. Die Teilnahme ist natürlich kostenlos, aber die Plätze sind begrenzt.

Zugegeben: In den letzten Jahren waren die Neuerungen rund um die „managed“ .Net-Programmierung mit einschlägigen Sprachen wie C# im Fokus der Aufmerksamkeit. So ist .Net zu einer der produktivsten Entwicklungsplattformen gewachsen.

Doch C++ ist zurück im Rampenlicht: Auch im 21. Jahrhundert wird C++ als Programmiersprache nicht weg zu denken sein. In C++ können Sie stets selbst zwischen Performance und Abstraktion wählen. Kein unnötiger Overhead, bei Bedarf volle Kontrolle. Und genau das wird C++ auch in der Zukunft seinen Platz unter den Programmiersprachen sichern – der Trend immer komplexere Anwendungen auf immer kleinere Hardware zu bringen unterstützt dies nachhaltig.

Seit Visual Studio 6.0 hat sich auch in der Microsoft C++-Welt viel getan –also höchste Zeit für ein Wissens-Update.

Wo? Wann?

2.2.2012 14:00- 18:00 Berlin: ANMELDUNG
7.2.2012 14:00- 18:00 Bad Homburg: ANMELDUNG
13.2.2012 14:00- 18:00 Karlsruhe: ANMELDUNG
5.3.2012 14:00- 18:00 Köln: ANMELDUNG
Teilnahme: Kostenlos

Der C++ Day 2012 wird freundlicherweise unterstützt von artiso.

Folgende Themen erwarten Sie:

C++ 11: Modernes C++ im 21. Jahrhundert

C++ bleibt aktuell – neue Sprachfeatures machen den nativen Klassiker fit für neue Herausforderungen. Dieser Vortrag gibt Ihnen einen Überblick über die wesentlichsten Neuerungen in C++ 11 – wie beispielsweise Smartpointer mit Reference-Counting (shared_ptr), Lambda-Expressions, neue Container-Klassen, Iteratoren und Sprachkonstrukte wie for_each sowie RValue References.

Parallel-Power in Visual Studio 11: Konzepte und Tools

Effektive parallele Programmierung erhöht die Performance in vielen Fällen drastisch, braucht aber das richtige Know-How und spezialisierte Tools. Denn bei stetig steigender Anzahl an Cores und CPUs wird es immer wichtiger, das Anwendungsmodell in Richtung Skalierbarkeit hinsichtlich Multiprocessing auszulegen. Auch das Debugging bietet einige Herausforderungen. Verschaffen Sie sich einen Überblick über die neuen Konzepte rund um Parallelisierung in Windows API, Concurrency Runtime und Visual Studio.

Application Lifecycle Management für C++: Die nächste Generation

Application Lifecycle Management ist mittlerweile auch in der nativen Entwicklung Pflicht: Mit Team Foundation Server haben Projektteams jeder Größe ein zentrales Portal für Zusammenarbeit, Versionskontrolle, Work Item Tracking, Build-Management, Prozessunterstützung und Fortschrittsreports . Dies ermöglicht den Mitgliedern von Teams, besser und effizienter zusammenzuarbeiten. Der Haken bisher: Die wichtigsten Features wurden auch für C++ unterstützt, aber bestimmte interessante Features waren der .NET Welt vorbehalten. Die gute Nachricht: Visual Studio 11 zieht hier nun nach – sehen Sie, welche Neuerungen sie erwarten.

Der Referent

Thomas Trotzki ist ALM Consultant bei der artiso AG nahe Ulm und Microsoft-C++-Profi der ersten Stunde.

Mit Microsoft C++ und den MFC beschäftigt er sich intensiv seit den ersten Beta-Versionen zu Microsoft C/C++ 7.0, also bereits vor der Geburtsstunde von Visual C++ und Visual Studio.

Technologisch ist er neben C++ und den MFC auch mit COM/DCOM und der gesamten „Managed Welt“ vertraut und hat umfangreiche Expertise im Application Lifecycle Management. Zurzeit betreut er Kunden bei der Einführung von Microsoft Team Foundation Server und berät bei der Etablierung eines Application Lifecycle Management in deren Entwicklungsabteilungen.

Der TFS bzw. der MTM unterstützen leider keine Versionierung von Test Cases. Wenn man nun für unterschiedliche Versionen einer Software Test Cases verwalten möchte, muss man die Test Cases kopieren. Wie damit die Versionierung von Test Cases abgebildet werden kann, habe ich hier beschrieben.

Um das Kopieren größerer Mengen von Test Cases zu vereinfachen, gibt es nun das Test Case Copy Tool von Anna Russo.

http://www.improvingsoftwarequality.com/2012/01/new-version-of-bulk-copy-test-cases.html

Der TFS bietet die schöne Funktion, Benachrichtigungen per Mail zu versenden. Dafür gibt es eine einfache Einstellung in der Team Foundation Server Administration Console unter dem Punkt „Email Alert Settings“.

Leider kommt es hier manchmal zu dem Problem, dass die Kommunikation zwischen dem TFS und dem SMTP-Server nicht auf Anhieb klappt und der TFS bietet da leider keine vernünftigen Analyse-Möglichkeiten. Um die Kommunikation zu testen kann man sich behelfen indem man einen Telnet-Client benutzt. Dieser ist auf dem Windows 2008 Server nicht mehr standardmäßig vorhanden, also muss man den erst mal installieren. Dazu einfach im Server-Manager unter Features den Telnet-Client hinzufügen.

Dann gibt man in der Kommandozeile folgenden Befehl ein:

telnet mymailserver 25

Damit öffnet sich nun eine Telnet session und der SMTM Server gibt eine entsprechende Meldung aus. Darunter kann man nun Kommandos eingeben. Folgende Abfolge muss man dabei nacheinander eingeben und zwar ohne sich zu vertippen, da eine Korrektur nicht funktioniert. Blau dargestellt sind die jeweiligen Antworten des Systems.

helo

250 VS2010.Mobile.Demo Hello [192.168.77.66]

mail from:tfs@artiso.com

250 2.1.0 tfs@artiso.com....Sender OK

rcpt to:tschissler@artiso.com

250 2.1.5 tschissler@artiso.com

data

354 Start mail input; end with <CRLF>.<CRLF>

Subject: TestMail

Das ist eine Test-Mail

Abgeschlossen wird die Eingabe durch Drücken von Enter, einem Punkt (.) und dann nochmals Enter.

Wenn so eine E-Mail zugestellt wird und man die hier verwendeten Serveradresse und Absender nun auch im TFS einträgt, sollte die Kommunikation auch dort funktionieren. Andernfalls sollte der Telnet eine Fehlermeldung ausgeben. Hilfreich ist, wenn man auf dem TFS mit demselben Account angemeldet ist mit dem auch der TFS läuft da einige SMTP-Server auch den angemeldeten User prüfen.

Eine häufige Frage ist, wie ich mit dem TFS und Microsoft Test Manager (MTM) die Versionierung von Test Cases bewerkstellige. Ziel dabei ist, dass ich verschiedene Releases meiner Software mit den dazu passenden Test Cases testen möchte, also z.B. für die aktuelle Entwicklung nutze ich einen neueren Test Cases da sich die Funktion inzwischen verändert hat aber wenn ich einen Hotfix für eine frühere Version testen möchte, benötige ich dafür natürlich den passenden Test Cases zu diesem Release.

Die aktuelle Lösung sieht im MTM so aus, dass man einen Test-Plan je Version einrichtet. In diesem Test-Plan habe ich dann die Test-Cases für die aktuelle Version referenziert. Für die nächste Version legt man einen neuen Test-Plan an und kopiert die Test-Suites.

Durch dieses Kopieren wird ein neuer Test-Plan angelegt der dann allerdings auf die selben Test Cases verweist wie die der Plan für die erste Version. Das ist ja genau die Ausgangssituation die man in den meisten Fällen haben möchte denn die meisten Test Cases sind ja in der neuen Version gleich wie in der Vorgänger-Version und diese werden ggf. durch neue Test Cases (z.B. 4a) ergänzt. Wenn sich ein Test Case nun ändert, dann darf dieser im neuen Test-Plan nicht angepasst werden, sonst würde ja damit auch der Test-Plan der Vorgängerversion geändert werden. Statt dessen muss der Test Case kopiert und die Kopie (2b) dem neuen Test Plan zugeordnet werden. Die Kopie kann nun geändert werden.

Wer eine größere Menge von Test Cases kopieren muss kann dafür übrigens auch ein Tool verwenden das Anna Russo veröffentlicht hat:

http://improvingsoftwarequality.blogspot.com/2011/11/bulk-copy-test-cases-tool-for-microsoft.html

Will man auf einen TFS über eine Internet-Verbindung zugreifen, dann bieten sich zwei Wege an: Entweder per VPN oder per SSL. Der Weg über SSL ist eigentlich der einfachere, Nachteil dabei ist allerdings, dass man ein Zertifikat von einer offiziellen Registrierungsstelle kaufen muss. Aber es geht auch ohne.

Dazu muss man zunächst ein Tool aus dem IIS 6 Ressource-Kit herunterladen. Das Tool gibt es auch einzeln hier zum Download.

Damit können wir nun ein SSL-Zertifikat generieren.

selfssl /N:CN=my.domain.com /K:2048 /V:730 /P:443 /S:3 /t

Der Parameter /V gibt die Gültigkeitsdauer in Tagen an, der Parameter /P den Port auf dem SSL laufen soll und /S die ID der Web Site des TFS. Letztere bekommt man einfach heraus indem man die Advanced Settings der Web Site aufruft.

Da der TFS im Normalfall ja nicht direkt mit dem Internet verbunden ist, muss der Port noch entsprechend auf der Firewall auf den jeweiligen Server auf dem der TFS läuft weitergeleitet werden. Diese Einstellung hängt natürlich von der jewweils eingesetzten Firewall ab.

Nun können wir eigentlich den Server bereits über den Web Access erreichen, z.B. https://my.domain.com/tfs/web . Achtung hier wird beim Einsatz von SSL kein Port mit angegeben sofern der Standard-Port verwendet wird. Im Browser bekommt man zwar eine Meldung, dass das Zertifikat nicht gültig ist, aber diese kann man entsprechend übergehen.

Das Problem ist, dass Visual Studio sich so nicht verbinden mag. Gibt man im Registrierungsdialog für neue Server die URL ein und stellt das Protokoll auf https dann erhält man folgenden Fehler:

---------------------------
Microsoft Visual Studio
---------------------------
Microsoft Visual Studio

TF31002: Unable to connect to this Team Foundation Server: my.domain.com.

Team Foundation Server Url: https://my.domain.com/tfs

Possible reasons for failure include:

- The name, port number, or protocol for the Team Foundation Server is incorrect.

- The Team Foundation Server is offline.

- The password has expired or is incorrect.

Technical information (for administrator):

The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel.
---------------------------
OK   Help  
---------------------------

Als Lösung müssen wir auf den Clients das Zertifikat installieren. Dazu muss man das Zertifikat auf dem Server zunächst exportieren. Im IIS Manager dazu einfach auf dem Server die Option Server Certificates doppelt klicken.

Dann kann das Zertifikat über die Option Export in eine Datei exportiert werden indem das Ziel und ein Passwort angegeben werden. Diese Datei kopieren wir nun auf den Client und klicken diese dort doppelt an. Es öffnet sich der Certificate Import Wizard. Hier können wir für die ersten beiden Seiten zunächst Weiter klicken. Dann geben wir das Kennwort ein dass wir beim Export angegeben haben. Auf der nächsten Seite geben wir an, dass wir das Zertifikat in einen spezifischen Store importieren wollen, nämlich in den “Trusted Root Certification Authorities”

Nun können wir uns auch mit Visual Studio ohne Probleme auf unseren Server verbinden.

Die SSRS bieten ein nettes Feature womit sich eine Text Box und andere Controls als Link nutzen lassen. Dazu einfach bei der Textbox unter Action die Option “Go to URL” auswählen.

Meine Herausforderung war, dass ich wollte, dass der Link die Zielseite in einem neuen Fenster öffnet, also das selbe wie bei einem <a href=”…” target=”_blank”>. Bei den SSRS muss man allerdings hier zu einem kleinen JavaScript greifen. Der Expression für die URL lautet dann beispielsweise:

="javascript:void(window.open("" http://MyTFS:8080/tfs/web/UI/Pages/WorkItems/WorkItemEdit.aspx?id =" & Fields!System_Id.Value & "&pguid=63302ade-299c-4949-a7ea-351ddd310a32""))"

Beim Deployment einer neuen Environment kommt folgende Fehlermeldung:

TF259115: Team Foundation Server could not find any suitable host to deploy the virtual machine: HPC Template.
Contact your administrator to fix the issues on the hosts below. (Hosts are listed in brackets)
1. Memory requirement of the virtual machine(s) exceeds the available host resources. The placement policy for this host group is set to be conservative and hence virtual machines that are in stopped state are also accounted as consuming host resources. Your administrator can change this policy by running the TfsLabConfig tool. (SarHyperV04)

Der Grund für die Meldung liegt darin, dass das Lab Management zunächst davon ausgeht, dass auf dem Hyper-V Host ausreichend Ressourcen (RAM) verfügbar sein müssen um alle Environments gleichzeitig zu starten um hier auf Nummer sicher zu gehen. Das ist allerdings für die Praxis eher ungeeignet. Hier möchte man auf einem Host mehrere, teilweise sogar viele Environments anlegen von denen dann aber immer nur einzelne laufen.

Glücklicherweise kann man das Verhalten aber konfigurieren. Dazu geht man einfach auf den TFS App-Tier und gibt dort folgenden Befehl ein:

tfsconfig lab /settings /CollectionName:<Collection> /hostGroup /edit /name:<Host Group Name> /labenvironmentplacementpolicy:aggressive

Dabei ist zu beachten, dass für den CollectionName auch wirklich nur der Name und nicht wie an anderen Stellen üblich die URI angegeben wird.

Weitere Infos finden sich hier: http://msdn.microsoft.com/en-us/library/dd547199(VS.100).aspx

Im Team Build lässt sich die Statische Code-Analyse (FxCop) recht einfach aktivieren. 

Leider geht es mit StyleCop nicht ganz so einfach. Eine Möglichkeit ist, in den Projektdateien die StyleCop-Analyse einzutragen und dann auf dem Build-Rechner MSBuild die StyleCop-Analyse auszuführen (siehe http://stylecop.codeplex.com/wikipage?title=Setting%20Up%20StyleCop%20MSBuild%20Integration&referringTitle=Documentation)

Alternativ kann man sich auch einfach eine Build Activity bauen die die StyleCop Analyse ausführt. Eine solche Activity habe ich am Ende dieses Posts zum Download bereitgestellt. Um diese zu nutzen entpackt man einfach die DLLs. Diese werden dann in der Versionsverwaltung abgelegt. Diesen Pfad muss man anschließend auf dem Build-Controller registrieren.

Nun können wir im Visual Studio ein Projekt anlegen. Hier referenzieren wir die DLLs aus der ZIP-Datei und kopieren unseren Build-Workflow hinein. Nun können wir im Workflow ein neues Argument vom Typ StyleCopSettings anlegen.

Dann brauchen wir noch eine Variable

Nun können wir den Workflow erweitern.

          
            
              
                 
<
              
              
                If
              
              
                 
              
              
                Condition
              
              
                =
              "[Not
String.IsNullOrEmpty(StyleCopSettings.StyleCopSettingsFile) And StyleCopSettings.PerformStyleCopAnalysis]" DisplayName="If
StyleCop Settings not empty run StyleCop">   
<If.Then>     
<Sequence>       
<sap:WorkflowViewStateService.ViewState>         
<scg:Dictionary x:TypeArguments="x:String,
x:Object">           
<x:Boolean x:Key="IsExpanded">True</x:Boolean>         
</scg:Dictionary>       
</sap:WorkflowViewStateService.ViewState>       
<mtbwa:ConvertWorkspaceItem DisplayName="Convert
Server Path to Local Path" mtbwt:BuildTrackingParticipant.Importance="Low" 
 Input="[StyleCopSettings.StyleCopSettingsFile]" Result="[StyleCopLocalSettingsFile]" Workspace="[Workspace]" />       
<absa:StyleCopVerifier AnalysisResults="{x:Null}" ViolationCount="{x:Null}" SettingsFile="[StyleCopLocalSettingsFile]" SourcesDir="[SourcesDirectory]" />     
</Sequence>   
</If.Then> 
</If>
          
        

Wenn wir nun auf Basis dieses Workflows eine Build Definition anlegen, können wir die StyleCop Settings dort einstellen und unser Build ob unsere StyleCop Rules auch alle eingehalten werden.

Ich verwende gerne Excel um mein Product Backlog im TFS zu sortieren. Dazu rufe ich die Work Items des PBL einfach aus Excel ab, sortiere diese und verwende dann die Excel Autonummerierungs-Funktion um den Stack Rank neu zu nummerieren. Das funktioniert sehr gut. Einziger Punkt der immer etwas nervt ist das Ausschneiden und Einfügen der Zeilen im Excel um diese zu verschieben. Hier gibt es allerdings eine elegante Lösung die allerdings ein wenig Fingerspitzengefühl erfordert und die nicht gerade intuitiv ist.

Zuerst markiert man die Zeile(n) die man verschieben möchte

Dann fährt man mit der Maus auf die obere Kante der Markierung

Nun kann man mit gedrückter rechter Maustaste die Zeile an eine andere Position schieben. Danach öffnet sich ein Kontext-Menü in dem man dann verschiedene Optionen zur Auswahl hat. “Move here” bedeutet das das Ziel überschrieben wird. Für den oben beschriebenen Fall brauchen wir also “Schift Down and Move” damit die verschobene Zeile eingefügt wird.

Alternativ kann man auch mit der linken Maustaste verschieben und dann im Verschieben die Shift-Taste drücken. Die Einfügezeile passt sich dann entsprechend an um anzuzeigen das die Zeile eingefügt wird und nicht der Inhalt überschrieben wird (ohne gedrückter Shift-Taste)

Wir hatten heute die Anforderung dass wir im Lab eine Software installieren mussten die über eine Lizenz freigeschaltet wird. Diese Lizenz is an die MAC-Adresse der Netzwerkkarte gebunden. Ziel war es nun, dass wir mit der selben Lizenz die Software auf mehreren Lab Environments betreiben können. Dabei ging es nicht darum die Lizenzprüfung auszuhebeln sondern mit der selben Konfiguration auf mehreren Labs zu testen. Was nicht funktioniert, ist dass man im Netz mehrere Netzwerkkarten mit der selben MAC Adresse hat. Aber für die virtuellen Maschinen gibt es da eine einfache Lösung. Man fügt einfach eine virtuelle Netzwerkkarte hinzu die nicht mit dem Netz verbunden ist.

Dazu müssen wir in der VM einen weiteren Netwerkadapter hinzufügen den wir einfach auf “Not connected” stellen und für den wir dann eine MAC-Adresse angeben können.

Heute hatte ich das Problem bei einem Kunden dass neu angelegte Areas nicht sofort auf den Work Items sichtbar waren. Was zuverlässig geholfen hat, war eine Recycle des Application Pools. Das ist aber natürlich auch keine Lösung. Im Web habe ich einige Threads zu diesem Problem gefunden, aber keine wirkliche Lösung. Deshalb möchte ich hier kurz beschreiben, welche Analysemöglichkeiten es hier gibt.

Zunächsteinmal habe ich folgende Zusammenhänge herausgefunden:

Wenn man in einem Client (Visual Studio, Excel, Project, Web Access etc.) eine Iteration anlegt, wird diese in der DB der Project Collection unter der Tabelle tbl_Nodes eingetragen. Dann wird eine Stored Procedure aufgerufen die eine Verarbeitung antriggert. Diese Verarbeitung wird vom Visual Studio Team Foundation Background Job Agent ausgeführt. Dieser schreibt dann einen neuen Eintrag in die Tabelle TreeNodes. Von dort werden die Items für die Work Items gelesen.

Damit ergeben sich folgende Schritte die ich empfehlen kann um das Problem zu untersuchen:

1. Prüfen ob der Visual Studio Team Foundation Background Job Agent Dienst läuft und ob dieser mit dem Account ausgeführt wird mit dem auch der TFS installiert wurde.
2. Prüfen ob die neuen Areas sowohl in tbl_Nodes als auch in TreeNodes eingetragen werden
3. Für den Visual Studio Team Foundation Background Job Agent kann ein Tracing aktiviert werden. In diesem sollte ein entsprechender Eintrag für die Verarbeitung der Area stehen. Man kann einfach nach dem Namen der neuen Area suchen. Das Tracing aktiviert man in der Datei "C:\Program Files\Microsoft Team Foundation Server 2010\Application Tier\TFSJobAgent\TfsJobAgent.exe.config"

             1: ...

             2: 
            <
            system.diagnostics
            >
          

             3: 
            <
            trace
            autoflush
            ="false"
            indentsize
            ="4"
            >
          

             4: 
            <!--To
enable tracing to file, simply uncomment listeners section and set trace switch(es)
below.
          

             5: 
             Directory
specified for TextWriterTraceListener output must exist, and job agent service account
must have write permissions. -->
          

             6: 
            <!--<listeners>
          

             7: 
             <add
name="myListener" 
          

             8: 
             type="System.Diagnostics.TextWriterTraceListener" 
          

             9: 
             initializeData="C:\Replace_Me_With_A_Directory_The_Service_Account_Can_Write_To\jobagent.log"
/>
          

             10: 
             <remove
name="Default" />
          

             11: 
             </listeners>-->
          

             12: 
            </
            trace
            >
          

             13: 
            <
            switches
            >
          

             14: 
            <!--
Trace Switches
          

             15: 
             Each
of the trace switches should be set to a value between 0 and 4, inclusive.
          

             16: 
             0:
No trace output
          

             17: 
             1-4:
Increasing levels of trace output; see Systems.Diagnostics.TraceLevel-->
          

             18: 
            <
            add
            name
            ="API"
            value
            ="0"
            />
          

             19: 
            <
            add
            name
            ="Authentication"
            value
            ="0"
            />
          

             20: 
            <
            add
            name
            ="Authorization"
            value
            ="0"
            />
          

             21: 
            <
            add
            name
            ="Database"
            value
            ="0"
            />
          

             22: 
            <
            add
            name
            ="General"
            value
            ="0"
            />
          

             23: 
            <
            add
            name
            ="traceLevel"
            value
            ="0"
            />
          

             24: 
            </
            switches
            >
          

             25: 
            </
            system.diagnostics
            >
          

             26: ...

Die Zeilen 6-11 müssen einkommentiert und für das Log-File ein gültiger Pfad angegeben werden. Dann kann man die Trace-Levels auf einen Wert zwischen 1 und 4 für die einzelnen bereiche setzen. Ich hatte einfach mall alles auf 4 gesetzt. Natürlich nicht vergessen das nach der Fehleranalyse wieder zurückzusetzen.

Damit sollte sich der Fehler identifizieren und beheben lassen. Viel Erfolg!

Erstellen einer simplen Custom Checkin Policy

In diesem Beispiel wollen wir eine Custom Checkin Policy erstellen die prüft, ob beim Checkin ein Kommentar min einer bestimmten Mindestlänge angegeben wurde. Es gibt ja bereits mit den Powertools eine Policy die prüft, ob überhaupt ein Kommentar angegeben wurde, aber wir wollen auch zu einem gewissen Maße prüfen, ob der Kommentar auch sinnvoll ist indem wir eine Mindestlänge erwarten. Zur Erstellung dieser Policy gehen wir als folgendermaßen vor:

1.)       Wir erstellen ein neues ClassLibrary Projekt in Visual Studio

2.)       Wir fügen eine Referenz zur Microsoft.Teafoundation.VersionControl.Client.dll hinzu. Diese findet man unter ReferenceAssemblies im VS DIE Ordner, also z.B. C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\ReferenceAssemblies\v2.0\Microsoft.TeamFoundation.VersionControl.Client.dll

3.)       Wir leiten unsere Klasse von PolicyBase ab und lassen Stubs generieren. Der Zwischenstand sieht dann so aus:

4.)       Wir setzen nun die Properties mit entsprechenden Werten, z.B.

public override string Description

        {

            get

            {

                return "Will check if the checkin comment is at least 10 letters long." ;    

            }

        }

        public override bool Edit( IPolicyEditArgs policyEditArgs)

        {

            return true;

        }

        public override PolicyFailure [] Evaluate()

        {

            throw new NotImplementedException ();

        }

        public override string Type

        {

            get

            {

                return "Changeset Comments Length Policy" ;

            }

        }

        public override string TypeDescription

        {

            get

            {

                return "This policy will require users to provide checkin comments of a minimum length." ;

            }

        }

Wichtig sind hier vor allem Type und Type Description da diese bei der Auswahl der Policy angezeigt werden.

5.)       Nun wollen wir die Evaluate-Methode implementieren. Diese wird vor dem Checkin ausgeführt und liefert mögliche Verletzungen der Policy zurück. Nur wenn keine Verletzungen gemeldet werden, wird der Checkin ausgeführt. Da wir hier den Checkin Comment prüfen wollen, brauchen wir Zugriff auf das Changeset. Dazu brauchen wir zuerst ein Feld das den Checkin enthält:

private IPendingCheckin currentPendingCheckin;

6.)       Nun überschreiben wir die Initialize-Methode und setzen hier unser currentPendingCheckin:

public override void Initialize( IPendingCheckin pendingCheckin)

{

    base.Initialize(pendingCheckin);

    currentPendingCheckin = pendingCheckin;

}

7.)       Anschließend implementieren wir unsere Validierungslogik in der Evaluate-Methode:

public override PolicyFailure [] Evaluate()

{

    var failures = new List < PolicyFailure >();

    if (currentPendingCheckin.PendingChanges.Comment.Length < 10)

    {

        failures.Add(new PolicyFailure ( "Checkin Comment is too short, at least 10 letters are required" , this));

    }

    return failures.ToArray();

}

8.)       Dann folgt noch ein wichtiger Schritt, wir müssen die Klasse serialisierbar machen

[Serializable]

public class CheckinCommentLengthPolicy : PolicyBase

9.)       Nun kompilieren wir die Solution und kopieren die DLL in einen lokalen Ordner. Anschließend tragen wir in der Registry unter „HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\TeamFoundation\SourceControl\Checkin Policies“ einen neuen String Value ein dem wir den Pfad zu unserer Assembly übergeben. Der angegebene Pfad in der Registry ist dabei für x64 Systeme angegeben. Bei c86 Systemen lautet der passende Pfad „HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\10.0\TeamFoundation\SourceControl\Checkin Policies“.

10.)    Nun starten wir Visual Studio neu und aktivieren die neue Checkin Policy. Dazu klicken wir im Team-Explorer mit der rechten Maustaste auf das Team-Projekt dann unter Team Project Settings / Source Control und dort wechseln wir dann auf den Reiter „Check-in Policy“. Über den Button Add können wir unsere Policy auswählen und hinzufügen.

11.)    Nun können wir einen Eincheckvorgang vornehmen und wir werden sehen, wenn wir einen leere checkin Comment angeben oder einen zu kurzen, erhalten wir eine Meldung.

Konfigurierbarkeit der Policy hinzufügen

Nun wollen wir die Anzahl der Mindestzeichen noch konfigurierbar machen. Dazu erweitern wir unsere Policy.

1.)    Zunächst fügen wir einen Winforms-Dialog hinzu der für die Eingabe des Wertes dient.

2.)    Im Code definieren wir ein public field über das wir die Anzahl übergeben bzw. auslesen können.

public partial class CheckinCommentLengthConfigDialog : Form

{

    public int MinimumCommentLength;

    public CheckinCommentLengthConfigDialog()

    {

        InitializeComponent();

    }

    private void btnOK_Click(object sender, EventArgs e)

    {

        MinimumCommentLength = (int)this.numericUpDown1.Value;

    }

    private void CheckinCommentLengthConfigDialog_Load(object sender, EventArgs e)

    {

        this .numericUpDown1.Value = MinimumCommentLength;

    }

}

3.)    Im Code unserer Policy fügen wir ein private field hinzu in dem wir den Wert speichern können und verwenden diesen in unserer Evaluate Methode. Zusätzlich geben wir im Property CanEdit den Wert true zurück. Und wir implementieren die Edit-Methode so, dass hier unser Formular aufgerufen wird:

public override bool Edit(IPolicyEditArgs policyEditArgs)

{

    using (CheckinCommentLengthConfigDialog dialog = newCheckinCommentLengthConfigDialog())

    {

        dialog.MinimumCommentLength = minimumCommentLength;

        if (dialog.ShowDialog() == DialogResult.OK)

        {

            minimumCommentLength = dialog.MinimumCommentLength;

            return true ;

        }

        return false ;

    }

}

public override bool CanEdit

{

    get

    {

        return true ;

    }

}

4.)    Nach dem Kompilieren können wir dann die DLL an den Ort kopieren den wir in der Registry eingetragen haben (bei mir c:\temp). Damit diese Date überschrieben werden kann, müssen wir Visual Studio beenden. Nun können wir für unsere Policy den Edit-Dialog aufrufen:

Verbessertes Deployment der Policy

Nun wollen wir das Deployment unserer Policy nov vereinfachen. Aktuell wäre es so, dass auf jedem Rechner auf dem die Policy geprüft werden soll die DLL kopiert und der entsprechende Registry-Eintrag vorgenommen werden muss. Das ist natürlich nicht besonders elegant. Wir müssen die Policy zwar auf jedem Rechner installieren, da sonst die Policy immer als verletzt gilt, aber die Installation können wir durch den Einsatz von VSIX deutlich einfacher machen.

1.)    Zunächst müssen wir das Visual Studio SDK herunterladen und installieren. Der Download für die SP1-Version befindet sich unter http://www.microsoft.com/downloads/en/details.aspx?FamilyID=21307C23-F0FF-4EF2-A0A4-DCA54DDB1E21

2.)    Dann fügen wir ein neues Projekt zu unserer Solution hinzu und wählen die Vorlage VSIX Project

3.)    Im Manifest des VSIX Projektes tragen wir nun die entsprechenden Werte ein und fügen unser Policy-Projekt als MEF Component im Bereich Content hinzu.

4.)    Damit unser Eintrag in der Registry noch hinzugefügt wird, fügen wir noch eine Text-Datei mit dem Namen „Policies.pkgdef“ hinzu und schreiben dort folgenden Inhalt rein:

[$RootKey$\TeamFoundation\SourceControl\Checkin Policies]

"artisoCheckinPolicies"="$PackageFolder$\artisoCheckinPolicies.dll"

5.)    Wichtig ist noch, dass wir bei der pkgdef-Datei in den Eigenschaften „Include in VSIX“ auf True stellen.

6.)    Nun kompilieren wir unsere Solution. Wenn alles fehlerfrei erstellt wird, bereinigen wir zunächst unsere manuellen Einstellungen, d.h. wir entfernen zunächst die Policy auf unserem Team-Projekt. Anschließen löschen wir die DLL und die Registry-Einträge die wir im ersten Teil angelegt haben. Dazu müssen wir zuvor Visual Studio wieder beenden. Nach dem Entfernen sollte die Policy in der Liste der verfügbaren Checkin Policies nicht mehr erscheinen. Aus dem Output unseres Setup-Projektes können wir nun die vsix-Datei starten und die Policy installieren.

7.)    Danach sollte sich die Policy genauso aktivieren lassen wie zuvor.

Auf der diesjährigen NRW Conf in Wuppertal hatte ich am ersten Konferenztag einen ganztägigen Workshop zum Thema SCRUM und am zweiten Tag einen Vortrag zum Thema Agile Projektplanung mit Scrum und User Stories. Die Veranstaltung war wieder einmal super organisiert und sowohl der Workshop als auch der Vortrag waren sehr gut besucht.

Die Folien zum Vortrag können hier heruntergeladen werden:

Die .Net Developer-Group Ulm bietet am 13.10. die Möglichkeit sich 1 Tag lang rund um das Thema SCRUM zu informieren. Hochkarätige Sprecher werden ihre Erfahrung und ihr Wissen zu Scrum weitergeben. Die Themen sind dabei breit gefächert. Vom Einsteigervortrag über tiefgreifende Aspekte von Scrum für diejenigen die Scrum bereits nutzen bis hin zu Erfahrungsberichten decken wir ein breites Spektrum ab. Da ist für jeden etwas bdabei, egal ob Entwickler, Scrum-Master, Product Owner oder Entscheider, egal ob sie planen SCRUM einzuführen, sich nur mal informieren wollen oder SCRUM bereits einsetzen.

Für eine Verpflegungspauschale von nur 20,—€ bekommen sie geballte Informationen aus Expertenhand und können sich mit vielen Gleichgesinnten austauschen. Also nicht zögern, sondern am besten gleich anmelden, die Plätze sind limitiert.

Anmeldung unter: http://www.dotnet-ulm.de/Anmeldung.aspx

Weitere Informationen und die Agenda in Kürze.

Zwei Felder auf den Workitems im Team Foundation Server sind Area und Iteration. Das besondere an diesen Feldern ist, dass sie hierarchische Inhalte abbilden. Als Standard-Wert haben diese Felder den jeweiligen Root-Knoten der gleich heißt wie das zugehörige Teamprojekt.

Um zu verhindern, dass Workitems nicht einer spezifischen Area oder Iteration zugeordnet sind und damit von entsprechenden Queries nicht mehr erfasst werden, wäre es ideal, wenn man erzwingen könnte, dass eine spezifische Area oder Iteration ausgewählt sein muss.

Leider schlagen die naheliegenden Lösungsansätze fehl. Wenn man auf dem IterationPath oder der IterationID eine REQUIRED-Rule definiert, dann greift diese nicht, da die Iteration ja nicht leer ist. Wenn man versucht mit deiner PROHIBITETED-Rule den Rootknoten zum ungültigen Wert zu erklären, dann funktioniert das leider auch nicht. Dieser Versuch wird quitiert mit der Meldung

---------------------------
Error
---------------------------
Error importing work item type definition:

TF26062: Rule '<REQUIRED />' is not supported for the field 'System.IterationPath'.
---------------------------
OK  
---------------------------

Deshalb müssen wir hier ein wenig in die Trickkiste greifen. Dazu legen wir zunächst ein neues String-Feld an

          <
          FIELD
          refname
          ="artiso.Iteration"
          name
          ="Iteration"
          type
          ="String"
          >
          <
          WHEN
          field
          ="System.IterationPath"
          value
          ="Training"
          >
          <
          COPY
          from
          ="value"
          value
          ="Empty"
          />
          </
          WHEN
          >
          <
          WHENNOT
          field
          ="System.IterationPath"
          value
          ="Training"
          >
          <
          COPY
          from
          ="value"
          value
          ="Valid"
          />
          </
          WHENNOT
          >
          <
          PROHIBITEDVALUES
          >
          <
          LISTITEM
          value
          ="Empty"
          />
          </
          PROHIBITEDVALUES
          >
          </
          FIELD
          >
        

Wenn das Feld IterationPath den Inhalt “Training” (Root-Knoten) hat, dann wird in dieses Feld “Empty” geschrieben, ansonsten “Valid”. Zusätzlich wird “Empty” als unzulässiger Wert definiert. Dieses Feld fügen wir nicht in’s Layout ein, sondern lassen es unsichtbar. Dadurch haben wir eine Validierung ob im Iterations-Feld ein andeer Wert als der Root-Wert eingetragen ist. Einzige unschönheit dabei ist, dass die Meldung nicht eindeutig zu dem Feld zugeordnet ist. Aber der gleiche Ansatz funktioniert für auch für Areas.

Das Lab Management des Team Foundation Servers eignet sich besonders gut um darin Coded UI Tests automatisiert im Rahmen eines Builds auszuführen. Der Build setzt die VM dabei auf einen Snapshot zurück, deployed die Applikation dann in die VM und führt dann die CUIT aus. Wie das Ganze funktioniert habe ich in einem Webcast beschrieben (http://www.microsoft.com/germany/msdn/webcasts/library.aspx?id=1032476976).

Dabei kann allerdings nun ein Problem auftreten. Der Test meldet bei der Ausführung:

“Automation engine is unable to playback the test because it is not able to interact with the desktop.  This could happen if the computer running the test is locked or it’s remote session window is minimized.”

Das Problem besteht darin, dass der CUIT eine interaktive Desktop Session benötigt um darin ausgeführt werden zu können. Als ich mich mit dem Environment Viewer auf die Environment verbunden habe, konnte ich feststellen, dass die VM beim Anmeldebildschirm stand. Das hatte ich nicht erwartet das die VM mit einem Autologon versehen war und ich den Snapshot auch im angemeldeten Zustand erstellt habe. ich hätte also erwartet, dass die VM nach einem Restore des Snapshots auch wieder angemeldet ist und der Test problemlos laufen kann.

Um die Ursache des Problems zu erläutern müssen wir etwas tiefer einsteigen. Der Environmen Viewer hat 2 Betriebs-Modi. Einmal Host-based und einmal Guest-based. Der aktuelle Modus wird rechts unten im Environment Viewr angezeigt

Host-based ist dabei die Verbindungsart bei der der Environment Viewer über den Hyper-V Host auf die VM zugreift. Dieser Modus erlaubt es auch mit der VM zu interagieren wenn diese noch gar nicht komplett hochgefahren ist, z.B. um aus dem Boot-Menü einen Eintrag zu wählen.

Guest-based ist eine normale RDP (Remote Desktop Protocol) Verbindung. Dafür muss die VM bereits hochgefahren sein. Guest-based Verbindungen sind etwas performanter und erlauben auch zusätzliche Features wie z.B. den Austausch von daten über die Zwischenablage.

Host-based wird dann verwendet wenn:

1.) Der client der den Environment Viewer ausführt als Betriebssystem mindestens Windows XP SP3, Windows Visua SP1, Windows 7 oder Windows Server 2008 ausführt und
2.) Der Benutzer der den Environment Viewer ausführt auch der Ownder der Environment ist

Weitere Informationen zu den verschiedenen Connection Types finden sich unter http://msdn.microsoft.com/en-us/library/ee518907.aspx.

Zurück zu dem obenen beschriebenen Problem. Der Build funktioniert nur dann, wenn der Snapshot auf den der Build zurücksetzt im Host-based Modus erstellt wurde. Andernfalls bekommt man auch in der Build Definition bei der Auswahl des Snapshots einen entsprechenden Hinweis.

Zu beachten ist allerdings, dass dieser Hinweis nur an dieser Stelle kommt, d.h. wenn man den Wizard des Lab BuildProcessTemplates anzeigt oder bei der Ausführung bekommt man keinen Hinweis mehr. Problem bei mir war, dass ich den Snapshot initial im Host-based Modus erstellt hatte und damit den Build angelegt habe. Anschließend habe ich den Snapshot aber gelöscht und neu angelegt und nun war ich im Guest-based Modus.

Problem-Lösung:

Wie lösen wir nun also dieses Problem? Es gibt zwei Möglichkeiten:

1.) Wir erstellen die Snapshots immer im Host-based Modus. Dazu müssen wir im Environment Viewer mit dem Benutzer angemeldet sein der auch der Owner der Environment ist. Wie man den Owner einer Environment ändert ist hier beschrieben: http://blogs.msdn.com/b/lab_management/archive/2010/11/08/enabling-host-based-connection-for-virtual-environments.aspx

2.) Wir verwenden einen Snapshot der im nicht gebooteten Zustand der VM erstellt wird. Der Build startet die VM dann automatisch und die VM nutzt einen Autologon um sich anzumelden. Damit kann der CUIT nun auch ausgeführt werden.

Ich bin vor kurzem auf ein unangenehmes Verhalten der TFS Work Item Queries gestossen. Als Operator für textfelder bietet der TFS hier “Contains” an. Damit kann man nach Teiltexten suchen, also z.B. findet eine Suche nach “Admin” Treffer mit “Admin”, “Administrator”, Administration” etc.

Das funktioniert aber leider nur mit String-Feldern und nicht mit Plaintext. Bei Plaintext funktioniert nur die Suche nach ganzen Wörtern. Das ist auch beim Einsatz des Plugins Search Work Item for TFS 2010 der Fall, da diese Erweiterung im Hintergrund Queries verwendet und man nicht deutlich erkennt, dass man nur eine Teilmenge erhalten hat, da die Suche zwar in String-Feldern Teiltextegefunden hat aber nicht in den Plaintext-Feldern.

Das Problem dabei ist, dass der TFS hier die Full Text Search Engine des SQL-Servers verwendet der dieses Verhalten besitzt. Als Workaround, der allerdings nicht besonders schön ist, kann man sich behelfen indem man die Full Text Search Engine vom SQL-Server deinstalliert. Alss Fallback sucht der TFS dann direkt auf den DB Tabellen und kann dann auch auf Plaintext Teiltexte finden. Natürlich wirkt sich das negativ auf die Performance der Suche aus, aber in einigen Fällen ist dieser Nachteil akzeptabel. Die Full Text Seach Engine kann man übrigens entfernen indem man das SQL Server Setup erneut aufruf und dann auf Remove klickt. Keine Angst, das deinstalliert nicht den gesamten SQL-Server, sondern man kann in einer Liste die zu deinstallierenden Features auswählen.

Auf den ALM Days 2011 am 23.11 werde ich einen Workshop anbieten zum Thema “Scrum mit TFS”. Dabei werde ich zeigen, wie man mit dem TFS Scrumm effizient umsetz, welche Tricks es gibt um bestimmte Szenarien abzubilden und wie Visual Studio 2010 und TFS dabei helfen können Herausforderungen bei agiler Entwicklung zu lösen.

Abstract: Agilität ist in und wer agil sagt, meint fast immer Scrum. Die Konzepte die hinter Agilität stehen versprechen nicht nur effizientere Projekte sondern auch motiviertere Teams mit mehr Spass am Entwickeln. Wer mit Scrum arbeitet steht vor der Wahl, entweder ein Teamboard einzurichten auf dem Artefakte mit Zetteln verwaltet werden oder auf ein Tool zu setzen um die Artefakte elektronisch abzubilden. Der Workshop zeigt, wie sie mit dem TFS Scrum effizient abbilden und dabei die eine oder andere Hürde überwinden. Dabei wird nicht nur auf den Planungsprozess eingegangen sondern es wird auch aufgezeigt, wie Visual Studio 2010 und der TFS verschiedene Herausforderungen im Bereich der agilen Entwicklung wie z.B.agiles Testing lösen. Kurzum, dieser Workshop ist für jeden ein Muss der mit dem TFS arbeitet und agiler werden möchte oder der Scrum einsetzt und sich eine passende Toolunterstützung wünscht.

Weitere Infos unter http://www.teamconf.de/workshops/articles/ganztagesworkshop-1-mein-tfs-kann-scrum-wie-der-tfs-effizient-mit-scrum-genutzt-werden-kann.html

Es gibt häufiger die Situation, dass man die Url des Team Project Portals eines TeamProjects per API ermitteln möchte um beispielsweise im zugehörigen Portal Dokumente zu generieren oder abzulegen etc. Hier kann man natürlich versuchen sich die Url aus Server-URL, Project Collection Name und Project Name zusammenzubauen, also http://<servername>/sites/<ProjectCollection>/<TeamProject>. Problem ist, dass die Url frei konfiguriert werden kann und von diesem Default-Wert abweichen kann.

Mein Szenario ist, dass ich ausgehend von einem Work Item die Url des Projekt Portals ermitteln möchte um für das Work Item ein entsprechendes Dokument anzulegen. Das Projekt zum Work Item lässt sich einfach ermitteln mit myWorkItem.Project aber auf dem Projekt sucht man vergeblich nach einer Eigenschaft für das Portal. Der Zugriff darauf istt leider ein wenig komplizierter. Die einzige Möglichkeit die Prortal Url zu ermitteln geht über den TFS Catalog. Der Code sieht dann so aus:

Wir ermitteln zunächst den CatalogNode für die Project Collection unseres Work Items. Davon ausgehend ermitteln wir dann den Knoten für das Projekt mit Hilfe des Projektnamens den wir von dem Work Item lesen. Vom Projekt aus können wir nun den Project Portal Knoten ermitteln der die Url beinhaltet.

Von artiso gibt es jetzt auch Planning Poker® Karten. Planning Poker® ist eine sehr gute Möglichkeit, im Team Komplexitätsschätzungen für Anforderungen vorzunehmen. Dies ist insbesondere bei agilen Methoden eine sehr gute Vorgehensweise. Am Beispiel von Scrum möchte ich kurz erläutern, wie so eine Planning Poker Runde abläuft:

Der PO trifft sich mit dem Team für ein Estimation. Der PO stellt dem Team eine User Story vor und das Team stell so lange Fragen bis es schätzfähig ist.Dann zieht jeder Teilnehmner eine Karte, hält diese aber zunächst verdeckt um die anderen Teilnehmer bei ihrer Schätzung nicht zu beeinflussen. Alle decken ihre Schätzung gleichzeitig auf. Der Teilnehmer mit der höchsten und mit der niedrigsten Schätzung begründen nun ihre Schätzung. Dabei werden Argumente ausgetauscht warum die Komplexität so hoch bzw. so niedrig ist. Die anderen Teilnehmer können sich natürlich an der Diskussion beteiligen. Unter den neuen Diskussionsaspekten findet dann eine neue Schätzrunde statt. Hat das Team eine Näherung erziehlt, dann wir die häufigste Nennung als Wert für die Schätzung übernommen.

Eine häufige Diskussion ist, ob nur das Team schätzt oder der PO auch eine Schätzung abgibt. Ich bevorzuge es, wenn der PO mitschätzt. Da wir mit Story Points relative Komplexitäten schätzen, sond Bedenken meist unbegründet, dass der PO die Schätzung “drücken” möchte. Aber bei Abweichungen der Abschätzung von PO und Team werden oftmals durch die Diskussion Missverständnisse oder unterschiedliches Verständnis der Anforderung aufgedeckt.

Der Vorteil von Planning Poker® liegt nun nicht nur darin, genauere Schätzungen zu erhalten, sondern man vermeidet die Situation dass bei solchen Schätzrunden wenige aktiv die Schätzung beeinflussen und die anderen passiv dabei sitzen und nur die Vorschläge abnicken.

Die Karten von artiso besitzen noch eine Besonderheit. Hier gibt es zwei Skalen. Mit den Werten auf den weißen Flächen mit der Reihung ?,0,½,1,2,3,5,8,13,20,40,100,∞ werden Story Points geschätzt. Die andere Seite mit den Werten ?,½,1,2,3,4,6,8,10,12,16,20,25 kann dazu genutzt werden, Aufwände in Stunden nach dem selben Vorgehen zu schätzen.

Unter den Lesern meines Blogs verlose ich 5 Sets zu je 8 Decks. Einfach Mail an tschissler (at) artiso.com schicken, die ersten 5 Einsedungen erhalten die Karten umgehend per Post zugeschickt.

Auf der dotnet Cologne war ich dieses Jahr mit 2 Vorträgen vertreten, einmal mit dem TFS 2010 Quickstart wo ich innerhalb des Vortrags in einer Stunde live einen TFS installiert, die Versionsverwaltung und den Build eingerichtet, Requirements und Test Cases angelegt, Testfälle spezifiziert und ausgeführt, Bugs angelegt und die Traceability demonstriert. Im zweiten Vortrag habe ich verschiedene Best Practices zu SCRUM vorgestellt und die Umsetzung mit TFS vorgestellt. Es war wieder eine tolle Konferenz, vielen Dank an das Orga-Team.

Wer sich nochmals die Folien anschauen mag, hier sind die Links zum Download. Wenn es nachträglich noch Fragen gibt, dann könnt ihreuch gerne per Mail an mich wenden.

Reporting Services cachen Reports um eine höhere Ausführungsgeschwindigkeit zu erreichen. Es gibt allerdings einige Szenarien wo dadurch nicht die gewünschten aktuellsten Daten im Report angezeigt werden, vor allem beim Entwickeln von neuen Reports. Deshalb kann es in diesen Fällen sinnvoll sein das Caching abzuschalten. Dazu geht man auf http://<SSRS Server>/reportserver, wechselt zu dem entsprechenden Report und ruft aus dem Dropdonw-Menü dn Punkt Verwalten auf (bei SQL Server 2008 R2, im SQL Server 2008 geht das über den Reiter “Eigenschaften”)

Im Bereich “Verarbeitungsoptionen” (Ausführung bei SQL Server 2008) kann dann die Option “Keine temporären Kopien dieses Berichts zwischenspeichern” ausgewählt werden.

Es gibt verschiedene Situationen in denen man nachträglich Reports oder SharePoint Dokumente nachträglich für ein bestehendes Team Project einrichten möchte, z.B. nach einer Migration von einer älteren TFS Version oder wenn das Projekt ohne Reports oder SharePoint Portal angelegt wurde. Dafür gibt es bei den Team Foundation Server Power Tools die Befehle

• tfpt addprojectportal   Add or move portal for an existing team project
• tfpt addprojectreports  Add or overwrite reports for an existing team project

Mit dieser Methode hatte ich aber bereits mehrfach Probleme und die Einstellungen sind auch nicht so feingranular möglich. Deshalb möchte ich hier eine andere Methode beschreiben. Hierzu legt man zunächst eine XML-Datei an. Für die SharePoint-Dokumente sieht die XML-Datei folgendermaßen aus:

            <?
            xml
            version
            ="1.0"
            encoding
            ="utf-8"?>
<Projectxmlns="ProjectCreationSettingsFileSchema.xsd">
<TFSName>http://vs2010:8080/tfs/sandbox</TFSName>
<LogFolder>c:\Temp\</LogFolder>
<ProjectName>VS2010_Demos</ProjectName>
<AddFeaturesToExistingProject>true</AddFeaturesToExistingProject>
<ProjectSiteEnabled>true</ProjectSiteEnabled>
<ProjectSiteWebApplication>VS2010</ProjectSiteWebApplication>
<ProjectSitePath>/sites/sandbox/vs2010_demos/</ProjectSitePath>
<ProjectSiteTitle>VS2010
Demos</ProjectSiteTitle>
<ProjectSiteDescription>Demo</ProjectSiteDescription>
<ProcessTemplateName>MSF
for Agile Software Development v5.0</ProcessTemplateName>
</Project>

            <?
            xml
            version
            ="1.0"
            encoding
            ="utf-8"?>
<Projectxmlns="ProjectCreationSettingsFileSchema.xsd">
<TFSName>http://vs2010:8080/tfs/sandbox</TFSName>
<LogFolder>c:\temp</LogFolder>
<ProjectName>VS2010_Demos</ProjectName>
<AddFeaturesToExistingProject>true</AddFeaturesToExistingProject>
<ProjectReportsEnabled>true</ProjectReportsEnabled>
<ProjectReportsForceUpload>true</ProjectReportsForceUpload>
<ProjectSiteEnabled>false</ProjectSiteEnabled>
<ProcessTemplateName>MSF
for Agile Software Development v5.0</ProcessTemplateName>
</Project>

Die Parameter sollten weitgehend selbsterklärend sein, eine weitere Beschreibung finden sich hier. Diese XML-Dateien können nun ausgeführt werden indem im Command-Window innerhalb von Visual Studio der Befehl

File.BatchNewTeamProject <XML-Datei>

Der Import wird damit angestoßen. Zu beachten ist, dass der Vorgang eine Weile dauern kann. Den Erfolg des Imports kann man in der Log-Datei im angegebenen Ordner überprüfen.

Inzwischen hat es sich sicher herumgesprochen, dass das SP1 für Visual Studio und den TFS verfügbar ist. Allerdings bekomme ich einige Fragen zu Installation, was muss wo installiert werden. Deshalb möchte ich hier auf einen Blog Post von Brian Harry verweisen der die Details beschreibt.

Und dann möchte ich noch auf einen Punkt aufmerksam machen der vielleicht etwas untergegangen ist. Ab sofort steht den Besitzer einer Visual Studio 2010 Ultimate mit MSDN Subscription der Load Test Virtual User Pack für eine unbegrenzte Anzahl virtueller User zur Verfügung. Damit sind nun Load Tests ohne zusätzliche Lizenzkosten möglich. Und Load Tests sind nicht nur für Stress Tests sinnvoll sondern können auch Concurrency-Probleme aufdecken und eignen sich auch sehr gut um Performance-Tests auch für kleinere Anwendungen. Weitere Infos zur Lizenzänderung gibt es hier: http://www.microsoft.com/visualstudio/en-us/products/2010-editions/load-test-virtual-user-pack

Bei verschiedenen Diagrammtypen, z.B. stacked Areas möchte man das Diagramm am Ende gerade abschneiden und nicht zunächst noch einen 0-Wert anzeigen.

Also statt der Schräge am Ende des Diagramms (zum 23.02 liegen keine Werte vor)

hätte man das lieber sauber abgeschnitten um zu signalisieren, dass die letzten gültigen Werte vom 22.02 sind.

Dies kann man mit Reporting Services Diagrammen relativ einfach erreichen. Zunächst ist wichtig, dass für die Werte ab 23.02 nicht 0 sondern Null bzw. Nothing (für Expressions) als Ergebnis zurückgegeben wird. Dies kann man im Query Designer kontrollieren

Dann muss man in den Properties der Serie noch in den EmptyPoint Einstellungen die Farbe auf “No Color” stellen, d.h. dass leere Datenpunkte nicht gezeichnet werden.

Und schon hat man das gewünschte Ergebnis.

Wir freuen uns, dass der MSDN-Bus auch bei uns in Blaustein halt macht. Im Rahmen des nächsten Treffens der .Net Developer Group Ulm finden im MSDN-Bus 2 Vorträge zum Thema “Windows Azure” und “Schreiben von sicherem Code” statt. Die Veranstaltung ist öffentlich und alle Mitgleider der .Net Developer Group Ulm sowie Gäste sind herzlich willkommen.

Allen Clark hat auf der MSDN Code Gallery Schema Files für die TFS Work Item Type Definition veröffentlicht. Damit bekommt man nun IntelliSense Support und Validierung beim Bearbeiten der XML-Dateien. War kann man über den Process Template Editor der TFS Power Tools ohne direkte XML-Bearbeitung die Work Item Type Definitions über einen grafischen Editor anpassen, jedoch gibt es eine ganze Reihe von Situationen wo das Bearbeiten im XML schneller geht oder einfach nicht zu vermeiden ist. Mit den Schema-Files wird dies nun deutlich angenehmer.

Link zur Code Gallery: http://code.msdn.microsoft.com/TFSchemas

Das MSF for Agile Template kommt mit einer vorgefertigten Excel-Datei für ein Interations- bzw. Sprint-Backlog. Diese liegt im SharePoint unter Shared Documents\Iteration 1\Iteration Backlog.xlsm.

Beim Öffnen der Datei kam es bei mir alledings zu Fehlern:

---------------------------
Microsoft Excel
---------------------------
TF80076: The data in the work item is not valid or you do not have permissions to modify the data. Please correct the problem and retry.
---------------------------
OK  
---------------------------

und

---------------------------
Microsoft Excel
---------------------------
TF208103: The initialization of the workbook to connect to Team Foundation Server was not successful. The workbook will close. You can try to connect again by re-opening the workbook.

If repeated attempts fail to initialize the workbook and you need to work with the data in the workbook, then you should disable the Team Foundation add-in. For new or other workbooks with lists bound to Team Foundation Server, you will need to re-enable the Team Foundation add-in.
---------------------------
OK  
---------------------------

Das Problem liegt darin, dass ich bei mir die Iterationen umbennant habe und das Dokument damit nun nicht mehr zurecht kommt. Es gibt aber einen relativ einfachen Workaround dafür:

1. Zunächst muss man dafür sorgen, dass es wieder einer Iteration “\Iteration 1” gibt. Diese kann man entweder temporär anlegen oder eine bestehende umbenennen.
2. Jetzt lässt sich die Datei ohne Fehler öffnen
3. Dann wechselt man auf das Sheet “Settings”
4. Hier wählt man im Bereich Area & Iteration eine gültige Iteration aus, z.B. \ oder eine der anderen gültigen Iterationen.
   Achtung: In der Liste werden nur Iterationen erlaubt die in dem Sheet “Iteration Backlog” in der Spalte “Iteration Path” vorkommen. Evtl. muss zuvor die Query “Team Queries\Iteration 1\Iteration Backlog” angepasst und hier die entsprechende Iteration als Filter eingestellt werden. Dann kann mit dem Refresh-Button auf dem team Tab im Excel die Liste aktualisiert werden.
   
5. Danach speichert man die Excel-Datei
6. Nun kann die temporär angelegte Iteration gelöscht werden oder die Iteration wieder umbenannt werden. Das Excel-Dokument lässt sich nun ohne Fehler öffnen.

Mit dem Microsoft Test Manager 2010 hat Microsoft sog. Rich Information Bugs eingeführt. Damit sind Bugs gemeint die automatisch mit Informationen zur Testausführung angereichert sind um dem Entwickler das reproduzieren und identifizieren von Bugs erleichtert. Dazu gehören beispielsweise Videos, IntelliTrace Logs, Systeminformationen und weitere. Diese extrem hilfreiche Funktion bringt jedoch leider auch ein Problem mit sich. Diese Informationen werden alle als Attachements and die TestCase Work Items gehängt was dazu führt, dass die TFS Datenbank schnell sehr groß werden kann. Bisher hatte der Datenbankadministrator keine effiziente Möglichkeit zur Anlayse und Bereinigung dieser Daten. Diese Lücke wird nun mit dem Test Attachement Cleaner Power Tool geschlossen.

Mit diesem Tool kann der Datenverbrauch in der Datenbank analysiert und in einerDatei ausgegeben werden. Zudem können bestimmte Löschoperationen ausgeführt werden, z.B. Videos die älter sind als ein bestimmtes Datum, Alle IntelliTrace Logs die größer sind als ein bestimmter Wert etc. Dadurch dass das Tool als Kommandozeilentool implementiert ist, können damit auch automatisierte Datenbereinigungen einfach eingestellt werden.

Sehr viele Software-Projekte nutzen Datenbanken und damit stellt sich die Frage, wie kann die Datenbank im Build so aufbereiten, dass sie für Tests deployed werden kann. Hierzu gibt es auf MSDN eine sehr gute Artiekelserie die Beschreibt wie mit den Datenbankfunktionen im Visual Studio 2010 Datenbanken verwaltet und im Build für Tests deployed werden kann.

http://msdn.microsoft.com/en-us/library/dd193413.aspx

Speziell die Schritt für Schritt Anleitung zur Anpassung des Build Workflows möchte ich empfehlen.

http://msdn.microsoft.com/en-us/library/ff805001.aspx

Der einfachste Weg, um Daten aus dem OLAP Cube im TFS Warehause auszuwerten ist über Excel. Wie dies funktioniert, soll im Folgenden kurz beschrieben werden:

Zunächst müssen dem entsprechenden Benutzer Berechtigungen für den OLAP-Cube eingerichtet werden. Dazu verbindet man sich im Management Studio zu den Analysis Services.

Unter dem Cube im Ordner Roles findet sich dann die Rolle TfsWarehouseDataReader

Hier kann man nun unter Memberschip die entsprechenden Benutzer eintragen

In Excel kann man nun eine Verbindung zum Cube herstellen. Dazu ruft man im Data-Tab die Verbindung zu den Analysis Services auf.

Im folgenden Dialog gibt man nun die Verbindungsdaten ein. Soll der Zugriff auf eine bennante Instanz erfolgen, muss diese angegeben werden, z.B. mySQLServer\MyInstance.

Dann wählt man entweder den Cube oder eine Perspektive aus

Die Verbindung kann man nun speichern. Sie steht dann unter Existing Connections für weitere Anwendungen zur Verfügung.

Im nächsten Schritt kann man eine Pivot Table in das bestehende Excel Workbook einfügen.

Im rechten Bereich kann man nun Felder in die Bereiche für Filter, Spalten, Zeilen oder Werte ziehen. Die Felder lassen sich dabei nach verschiedenen Kategorien über die oberste Dropdownlist filtern.

In einem späteren Post werde ich beschreiben, wie man mit Hilfe der Pivot Tables entsprechende Auswertungen auf dem Cube erstellt.

Beim starten einer Environment im Microsoft Lab Management dauert es meist geraume Zeit, bis die Workflow capabilities bereit zur Ausführung sind.

Will man diese Zeit reduzieren, ist ein einfaches Mittel in den VMs das IPv6 Protokoll auf den Netzwerkkarten zu reduzieren. Bei mir hat das die Wartezeit für die Workflow capabilities von 2:44 Min auf 0:40 Min reduziert.

Beim nächste Treffen der VS ALM User Group hält Ed Blankenship einen Vortrag über die Anpassungen des Builds im TFS2010.

Weitere Infos unter http://www.vsalmug.com

Date: October 7th, 2010
Time: 19:00 CEST (17:00 UTC without summertime)
Add to Calendar: http://tinyurl.com/2wmsfgu
Join meeting: http://tinyurl.com/2v3u8at

In TFS 2010, the automated build infrastructure has been revamped to use Windows Workflow Foundation (WF) instead of MSBuild. In this session, we will explore how to customize the default build process template and how to leverage multiple aspects of the workflow implementation for TFS 2010 Build.

We will cover:
• Explore the basics of Windows Workflow Foundation as it is used in TFS 2010 Build
• Review the high-level parts of the default build process template in TFS 2010 Build
• Adding new functionality to the build process using out of the box workflow activities
• Creating variables and process parameters that can be exposed to the end user
• Thoughts about designing & architecting your build process for reuse
• Building a custom activity for use in the build process template
• Deploying the custom activity to all of the build servers in the build farm

Presenter: Ed Blankenship
Ed is an Application Lifecycle Management (ALM) Consultant with Notion Solutions and a Microsoft Most Valuable Professional (MVP) in Visual Studio ALM & Team Foundation Server.
Ed was voted as the Microsoft MVP of the Year (Visual Studio ALM, TFS) for 2010 by his peers.
His expertise is in Microsoft Visual Studio Team System and Team Foundation Server in which he has been actively using, managing, and implementing for nearly five years since the beginning of those products in 2005. He has been awarded since 2008 as a Microsoft MVP in Visual Studio ALM, Team Foundation Server and Visual Studio Team System.
As an ALM Consultant, he assists organizations with improving their development lifecycle by suggesting improvements to their processes and implementing Application Lifecycle Management tools to assist with that improvement. By using Visual Studio ALM and Team Foundation Server, customers can immediately see value from their improvements.
Ed was previously the Release Engineering Manager at Infragistics where he led a multi-year TFS & Visual Studio Team System implementation to improve the development process lifecycle.
Ed is the lead author of the Wrox Professional Team Foundation Server 2010 book, has been a technical editor for the Wrox Silverlight 1.0, Silverlight 2 Developer's Guide, Silverlight 3 Programmer's Reference, and Silverlight 2 Bible books, author of numerous articles, and has spoken at various user groups, events, radio shows, and conferences.
You can find Ed blogging at http://www.edsquared.com, tweeting at @EdBlankenship (http://www.twitter.com/edblankenship), and more information on his LinkedIn profile page: http://www.linkedin.com/in/edblankenship. His MVP profile is also available at https://mvp.support.microsoft.com/profile/ed.blankenship.

Um mit dem MS Test Framework eine Code Coverage Analyse auszuführen, muss diese zunächst aktiviert werden. Da es hierbei immer wieder zu Fragen / Problemen kommt, möchte ich den Weg hier einmal ausführlich beschreiben:

Zunächst öffnet man eine vorhandene Test Settings Datei

Hier aktiviert man zunächst unter “Data and Diagnostics”´die Code Coverage und öffnet dann die Konfiguration für diesen Data Collector.

Hier wählt man nun die Assemblies für die die Coverage Analyse erstellt werden soll

Anschließend speichert man die Test Settings unter einem eigenen Namen wie beispielsweise “CodeCoverage” ab. Dies kann man als aktive Test Settings selektieren.

Nun kann man Unit-Tests ausführen und anschließend im Test Results Fenster die Code Coverage Results aufrufen.

Die Ergebnisse werden nun tabellarisch angezeigt.

Zusätzlich kann man dann noch die Coverage im Code anzeigen lassen. Hierzu einfach in der Toolbar den gekennzeichneten Butten klicken.

Hier sieht man nun, welche Codebereiche noch nicht durch die Tests abgedeckt sind. Hier sollten also noch ein paar weiter Tests geschrieben werden um die Testabdeckung zu erhöhen. Welche Input-Parameter diese abdecken sollten, zeigt die Coverage Analyse.

Tipp: Sollte die Coverage Anlayse auf dem oben beschriebenen Weg nicht gleich angezeeigt werden, hilft manchmal ein neustart von Visual Studio. Ich hatte schon verschiedendlich Situationen, als die Einstellung nicht sofort übernommen wurde.

Microsoft schließt eine Sicherheitslücke im ASP.Net durch ein Out-of-Band-Ipdate. Da der TFS komplett auf ASP.Net basiert, ist au der TFS von dieser Sicherheitslücke betroffen und wer auf der sicheren Seite sein möchte sollte den nun verfügbaren Patch installieren.

Weitere Details und die Download-Links gibt es auf TechNet unter http://blogs.technet.com/b/michaelkranawetter/archive/2010/09/28/update-out-of-band-updates-f-252-r-asp-net-l-252-cke-verf-252-gbar.aspx

Wenn das TFS Dashboard zu lange braucht um angezeigt zu werden, dann kann ein Grund dafür das “Recent Builds Webpart” sein. Dieses hat offensichtlich noch einen Bug und liest zu viele Informationen vom TFS. Wird die Anzahl der Builds zu hoch, dann hat das Webpart einen sehr deutlichen Einfluss auf die Performance des Dashboards, insbesondere beim erstmaligen Laden.

Microsoft hat das als Bug identifiziert und verspricht mit dem SP1 Abhilfe zu schaffen. Im Moment hilft leider nur, entweder das WebPart vom Dashboard zu entfernen oder die Build-Historie regelmäßig zu löschen.

Die neueste Version (September) der TFS Power Tools enthalten auch eine neue Backupfunktion mit der nicht nur der TFS sondern auch die Reporting Services und der SharePoint Server gesichert werden können. Aktuell rät Microsoft jedoch vom Einsatz der SharePoint Backup-Funktion ab, da diese gegen das Service Agreement verstößt wie genauere Recherchen zusammen mit dem SharePoint-Team ergeben haben. Aktuell wird mit Hochdruck an einer aktualisierten Version gearbeitet.

Quelle: Brian Harrys Blog Update on backing up TFS with Sharepoint

Web Performance Tests zeichnen die HTTP-Kommunikation zwischen einem Client und einem Webserver auf und können diesen dann wieder abspielen. Somit lässt sich der Server-Code relativ einfach “von Außen” testen und diese Tests eignen sich auch sehr gut um Load-Tests zu generieren.

Manche Web-Anwendungen verwenden die URL um die Session ID zu übermitteln, vor allem wenn keine Cookies zur Verfügung stehen. Dann entsteht allerdings das Problem, dass die aufgezeichneten Requests nicht wieder sauber abgespielt wreden können, da diese dann ja auf eine nicht mehr aktive Session verweisen. Dieses Problem kann man allerdings recht elegant lösen:

Zunächst verwendet man einen Request der ohne Session ID arbeitet um die Applikation zu starten. Dieser liefert normalerweise im Response einen Redirect auf die URL inkl. SessionID zurück.

Diesem Request kann nun in der Definition des Web Tests eine Extraction Rule hinzugefügt werden (Rechte Maustaste / Add Extraction Rule). Hier kann mit der Extract Text Rule nun im Response nach einem Text gesucht werden. Dazu wird eine Startsquenz “(S(" und eine Endesequenz “))” angegeben. Der Text dazwischen wird dann extrahiert und in den Parameter “URLSessionID” geschrieben.

Mit einem Find and Replace auf dem wurzelknoten des Tests  können nun alle URLs im Test automatisch aktualisiert werden.

Hier wird einfach die aufgezeichnete Session ID durch den Parameter “{{URLSessionID}}” ersetzt.

Der so modifizierte Test kann nun reproduzierbar ausgeführt werden.

Der Team Foundation Server bietet ein extrem flexibles und leistungsfähiges Konzept zur Definition von Work Items. Damit lassen sich viele Szenarien über eine reine Konfiguration abbilden. Um die Mächtigkeit zu demonstrieren, hier ein paar Beispiele. Diese Beispiele nutzen den Process Template Editor der Bestandteil der kostenlosen Team Foundation Server 2010 Power Tools ist.

1.) Nur bestimmte Benutzer sollen ein Workitem eines bestimmten Typs anlegen dürfen

Ein verbreitetes Szenario ist, dass nur ein bestimmter Personenkreis Workitems eines bestimmten Typs (in diesem Beispiel der Typ Bug) anlegen dürfen, andere Benutzer sollen diese aber weiter bearbeiten können. Auch wenn die Umsetzung nicht ganz ideal ist lässt sich diese Funktion mit dem TFS relativ einfach erreichen.

Wie im Screenshot zu sehen, ist der Status Active für diesen Benutzer ungültig. Damit kann er das Workitem nicht speichern. Wie gesagt, nicht gerade schön aber wirkungsvoll. Wie erreichen wir nun diese Funktion?

Im Process Template Editor sehen wir im Workflow des Bug-WIT eine Transition von nirgendwo nach Active

Diese Transition wird verwendet wenn ein neues Workitem angelegt wird. Auf dieser Transition können wir nun eine Berechtigung einstellen. Dazu geben wir in das Feld “For” eine TFS Gruppe ein die diese Funktion ausführen darf. Alternativ kann bei “Not” eine Gruppe angeben die diese Transition nicht nutzen darf.

Dieses Feature kann natürlich auch für Transitions zwischen zwei Status genutzt werden, also z.B. um zu steuern wer den Bug schließen darf.

2.) Ein Feld muss gefüllt sein wenn ein anderes einen bestimmten Wert hat

In der Praxis kommt es häufiger vor, dass iin Abhängigkeit eines Wertes ein anderes Feld ausgefüllt sein muss. In unserem Beispiel nehmen wir mal an, dass auf dem Bug die Repro-Stepsausgefüllt sein müssen wenn der Bug die Priorität 1 hat.

Dazu stellen wir auf dem Feld Repro Steps eine WHEN-Regel ein

Und sagen wenn diese Bedingung erfüllt ist, dann soll das Feld ein Pflichtfeld sein

3.) Befüllen einer Auswahlliste in Abhängigkeit eines anderen Feldes

Das dritte Beispiel soll uns die Auswahlliste eines Feldes in Abhängigkeit eines anderen Feldes befüllen. In unserem Beispiel soll das Feld Team in Abhängigkeit der Area befüllt werden.

Dazu definieren wir für das Feld Team das wir zuvor hinzugefügt haben 2 When-Regeln

An dieser Stelle verwenden wir für die Regel nicht das Feld AreaPath da hierarchische Felder in Regeln nicht richtig unterstützt werden. Diese produzieren dann beim Import des WIT den Fehler "TF26204: The account you entered is not recognized". Der Umweg über die AreaID umgeht diese Problem.

Dann stellen wir einfach die AllowedValues für die beiden Fälle ein.

Man sieht also, dass der TFS einiges an Flexibiölität zu beieten hat. Es lohnt sich damit mal etwas zu experimentieren. Generell möchte ich aber vor Überregulierung warnen weil dies in der Praxis meist dazu führt, dass die Anwender behindert werden und somit die Akzeptanz des Tools sinkt.

Tritt beim Konfigurieren eines Labs das in einer Workgroup betrieben wird (keine Domänenintegration der VMs) folgender Fehler auf, dann fehlt ggf. ein Shadow-Account: 

--------------------------------------------------

Environment message: Type=Warning; Message=TF267042: One or more machines are not ready to run tests. For more information, see the individual machine errors.;

Machine messages:

Machine name: Windows 7 x64 en

Machine message: Type=Error; Message=TF267055: The machine is not ready to run tests because of the following error: Unable to connect to the controller on ---. The agent can connect to the controller but the controller cannot connect to the agent because of following reason: The server has rejected the client credentials.
The logon attempt failed.;

--------------------------------------------------

Damit der Testagent mit dem Testcontroller korrekt zusammenarbeitet, müssen beide mit unterschiedlichen Accounts laufen. Der Testcontroller verwendet dabei typischerweise einen Domänen-Account, der Testagent arbeitet mit einem lokalen Account. Die jeweiligen Accounts müssen als Shadow-Accounts (gleicher Name und Kennwort) lokal bzw. in der Domäne angelegt werden, also für den lokalen Account ein Shadow-Account in der Domäne und für den Domänen-Account ein lokaler Shadow-Account.

Beispiel:

Die oben beschriebene Meldung erhält man, wenn auf der Labmaschine kein lokaler Shadow-Account angelegt wurde. Wenn man das nachholt und dann auf “Repaiur testing capabilities” klickt, dann sollte das Problem behoben sein.

Clint Edmonson, Architecture Evangelist von Microsoft hat auf Channel 9 eine Serie von Webcasts zum Einsatz der neuen UML-Features in VS 2010 veröffentlicht.

UML with VS 2010 Part 1: Brainstorming a Project

UML with VS 2010 Part 2: Organizing Features Into Use Cases

UML with VS 2010 Part 3: Modeling the Business Domain

UML with VS 2010 Part 4: Capturing Business Workflows

UML with VS 2010 Part 5: Architecting an Application

UML with VS 2010 Part 6: Designing a Project's Physical Structure

UML with VS 2010 Part 7: Sketching Interactions with Sequence Diagrams

UML with VS 2010 Part 8: Revealing Responsibilities with Class Diagrams

Das Processtemplate für Scrum gab’s von Microsoft bereits als Beta, nun wurde die endgültige Version auf der Visual Studio Gallery veröffentlicht.

Folgende Elemente enthält das Template:

• Work Item Types
  • Sprint
  • Product Backlog Item
  • Bug
  • Task
  • Impediment
  • Test Case
• Reports
  • Release Burndown
  • Velocity
  • Sprint Burndown
  • Build Success Over Time
  • Build Summary
  • Test Case Readiness
  • Test Plan Progress
• SharePoint Project Portal

Hier noch Screenshots zum Sprint Burndown und Release Burndown Report.

Download

http://visualstudiogallery.msdn.microsoft.com/en-us/59ac03e3-df99-4776-be39-1917cbfc5d8e

Weitere Informationen zum Template
http://blogs.msdn.com/b/aaronbjork/archive/2010/07/19/announcing-microsoft-visual-studio-scrum-1-0.aspx

Endlich ist es soweit und Microsoft stellt ein VM Image für Visual Studio 2010 und TFS 2010 in der RTM Version bereit. Auf diesem Image sind nicht nur die Produkte sowie einige weitere benötigten Tools installiert, sondern es befinden sich darauf auch Demo-Daten (Tailspin Toys) und 9 Hands-On-Labs. Die VM ist für Hyper-V, Virtual PC 2007 SP1 verfügbar. Die Trial-Versionen auf der VM laufen bis zum 15. Dezember 2010.

Weitere Infos und Hinweise zum Download finden sich hier: http://blogs.msdn.com/b/briankel/archive/2010/06/25/now-available-visual-studio-2010-rtm-virtual-machine-with-sample-data-and-hands-on-labs.aspx

Im Team Foundation Server lassen sich die Work Items sehr einfach anpassen, neue Work Item Types lassen sich erzeugen und damit ein individuelles Process Template erzeugen. Das ganze geht sehr einfach und intuitive wenn mann den Process Template Editor aus den Team Foundation Server Power Tools verwendet (http://visualstudiogallery.msdn.microsoft.com/en-us/3e8c9b68-6e39-4577-b9b7-78489b5cb1da)

Wer mal auf den Geschmack gekommen ist, das Process Template im TFS anzupassen, wird durch ausprobieren und rumspielen schnell vor der Frage stehen, wie kann ich nun in einem bestehenden Projekt einen Work Item Type wieder löschen den ich nicht mehr brauche?

Hier hilft das Kommandozeilentool witadmin weiter das sich dirckt über die Visual Studio Eingabeaufforderung ausführen lässt.

witadmin destroywitd /collection:http://<Servername>:8080/tfs/<Team Project Collection> /p:<Team Projekt Name> /n:<Name des Work Item Types>

löscht den angegebenen Work Item Type.

Vorsicht ,
mit diesem Kommando werden aber auch alle Work Items gelöscht, die diesen Typ verwenden, diese können ja vom System nach löschen der WITD nicht mehr verwaltet werden.

Wenn man also den WIT bestehender Work Items verändern möchte, dann sollte man diesen umbenennen und anschließend so anpassen dass er den neuen Anforderungen entspricht. Zum Umbenennen eines WIT hilft ebenfalls witadmin

witadmin renamewitd /collection:http://<Servername>:8080/tfs/<Team Project Collection> /p:<Team Projekt Name> /n:<Alter Name des Work Item Types> /new:<Neuer Name des Work Item Types>

In diesem Monat möchte ich die Leser meines Blogs auch auf das US-Meeting der Visual Studio User Group aufmerksam machen, da dieses Treffen dieses mal zu einer auch für Europa günstiger Zeit stattfindet (Donnerstag 17. Juni 18:00 Uhr).

Das Thema ist Scrum, TFS und Microsoft. Aaron Bjork wird das neue Scrum Template von Microsoft vorstellen das er maßgeblich verantwortlich ist. Also Informationen aus erster Hand die man nicht verpassen sollte. Für Mitglieder gibt es ein Recording des Meetings im Nachgang auch zum Download.

Das neue “Team Foundation Server Scrum v1.0 Beta” Template kann man sich hier herunterladen: http://visualstudiogallery.msdn.microsoft.com/en-us/59ac03e3-df99-4776-be39-1917cbfc5d8e
Nähere Informationen zum Meeting gibt es hier: http://www.vsalmug.com/Meetings/Announcements/June-2010/June-17,-2010--Scrum,-TFS-and-Microsoft.aspx

Kurzbeschreibung: Dieser Artikel beschreibt, wie Parameter an Reports über die URL übergeben werden können um so über Links oder im SharePoint Dashboard Reports bereits mit voreingestellten Parametern aufzurufen und so z.B. den Burndown eines spezifischen Sprints zu erhalten ohne die Parameter jedesmal von Hand einstellen zu müssen.

Im Team Foundation Server werden sie SQl Server Reporting Services (SSRS) genutzt um Reports zu generieren. Diese Reports geben schnell Auskunft über den aktuellen Status eines Projektes. Ein gutes Beispiel für einen solchen Report ist ein Burndown-Chart:

Solche Reports können sehr einfach aus dem SharePoint Portal oder aus dem TeamExplorer aufgerufen werden.

Nachteil an dieser Methode ist, dass bei jedem Aufruf die entsprechenden Parameter eingestellt werden müssen oder das Report Template immer an den aktuellen Sprint angepasst werden muss. Glücklicherweise unterstützen die SSRS die Übergabe von Parametern in der URL, so dass man sich sehr einfach Links generieren kann die den Report bereits vorkonfigurieren. Hierzu ruft man folgende URL auf:

http://<Reportserver URL oder IP>/ReportServer/Pages/ReportViewer.aspx?%2fTfsReports%2f<Project Collection Name>%2f<Tem Project Name>%2f<Ordner>%2f<Report Name>&rs%3aCommand=Render

In meinem Fall sieht das so aus:

http://myReportServer/ReportServer/Pages/ReportViewer.aspx?%2fTfsReports%2fartisoProjects%2fReportingDemo%2fProject+Management%2fBurndown+and+Burn+Rate&rs%3aCommand=Render

Damit können wir zunächst mal den Report direkt aufrufen. Nun können wir noch ein paar Parameter übergeben. Dazu müssen wir wissen wie die Parameter heißen. Dies kann man am einfachsten rausfinden indem man den Report über das SSRS Frontend aufruft und zwar über

http://<Reportserver URL oder IP>/Reports

und dann zu dem entsprechenden Report navigiert.  Die Seite die man nun erhält sieht ungefähr so aus:

Unter Eigenschaften / Parameter werden nun alle Parameter mit ihrem Namen angezeigt:

Wir wollen nun z.B. das Start- und Enddatum in unserer URL setzen. Dazu ergänzen wir die URL von oben einfach:

http://myReportServer/ReportServer/Pages/ReportViewer.aspx?%2fTfsReports%2fartisoProjects%2fReportingDemo%2fProject+Management%2fBurndown+and+Burn+Rate&rs%3aCommand=Render&StartDateParam=28.05.2010&EndDateParam=10.06.2010

Damit wird bereits das Start- und Endedatum korrekt gesetzt. Nun wollen wir noch die Iteration setzen. Hier ist die Geschichte nicht ganz so trivial, da der TFS recht kryptische Angaben zum Iteration-Pfad erwartet. Das liegt daran, dass das Warehouse Daten aus mehreren Project Collections enthält und vor allem bei einem Rebuild die IDs unverändert bleiben sollen. Diesen Parameter kann man auf verschiedene Arten ermitteln, der mit dem geringsten Vorbereitungsaufwand soll hier kurz beschrieben werden.

Dazu ruft man zunächst das SQL Server Management Studio auf und verbindet sich zu den Analysis Services. Hier erstellt man nun eine neue MDX-Query.

Dann wählt man im Feld “Cube” den Eintrag “Work Item” aus und geht im Baum unter Work Item \ Work Item.Iteration Hierarchy \ Iteration<n> wobei n die Hierarchieebene ist auf der sich die gesuchte Iteration befindet.

Die gewünschte Iteration zieht man nun per Drag & Drop auf die rechte Seite des Fensters und bekommt dort die ID der Iteration.

Diese muss jetzt noch URL-Encodiert werden. Dazu kann man beispielsweise den URLEncoder (http://code.msdn.microsoft.com/URLEncoder/Release/ProjectReleases.aspx?ReleaseId=3629) verwenden.

Damit sieht die IterationID nun so aus:
%5BWork%20Item%5D%2E%5BIteration%20Hierarchy%5D%2E%5BIteration1%5D%2E%26%5B%2D6991474436272448184%5D%26%5B%2D8595730757606272101%5D

Diese können wir nun als Parameter in unsere URL einfügen:
http://myReportServer/ReportServer/Pages/ReportViewer.aspx?%2fTfsReports%2fartisoProjects%2fReportingDemo%2fProject+Management%2fBurndown+and+Burn+Rate&rs%3aCommand=Render&StartDateParam=28.05.2010&EndDateParam=10.06.2010&IterationParam=%5BWork%20Item%5D%2E%5BIteration%20Hierarchy%5D%2E%5BIteration1%5D%2E%26%5B%2D6991474436272448184%5D%26%5B%2D8595730757606272101%5D

Damit bekommen wir alle Parameter wie gewünscht befüllt.

Über zusätzliche Parameter können wir nun das Parameterfeld und den Toolbar auch noch ausblenden. Dazu fügen wir noch die Kommandos &rc:Parameters=false&rc:toolbar=false an unsere URL an. És gibt noch eine ganze Reihe weiterer Commands, über die z.B. auch das Ausgabeformat gesteuert wreden kann. Eine genauerer Beschreibung der Commands findet sich hier: http://technet.microsoft.com/en-us/library/ms152835.aspx.

Damit können wir nun den Report schon über einen einfachen Link aufrufen. Um den Report in unser SharePoint Dashboard einzubauen sind jetzt nur noch wenige Schritte erforderlich. Dazu fügen wir in unser Dashboard zunächst ein Page Viewer Web Part ein.

In der Tool Pane können wir nun die URL für den Report angeben.

Damit lassen sich nun schöne Dashboards im SharePoint aufbauen die alle Reports bereits voreingestellt enthalten. Für einen neuen Sprint nutzt man dann die Funktion “Copy Dashboard” und passt die Parameter in den URLs entsprechend an.

Weitere Hinweise:

Manche Parameter lassen auch eine Mehrfachselektion zu. Diese können ebenfalls in der URL übergeben werden indem einfach der selbe Parameter mit unterschiedlichen Werten angegeben wird.

Weitere Links:

URL Parameter für SSRS: http://technet.microsoft.com/en-us/library/ms153586.aspx
Viewer Commands: http://technet.microsoft.com/en-us/library/ms152835.aspx
Parameter Prefixes: http://technet.microsoft.com/en-us/library/ms153579.aspx

Bei der weltweiten Usergroup Team System User Group Virtual Edition hat sich in den letzten Tagen einiges geändert, z.B. der Name. Wie das Produkt das im Zentrum unserer Aktivitäten steht, wurde die Gruppe in Visual Stuido ALM User Group umbenannt. Gleichzeitig haben wir eine neue Website online geschaltet. Sie finden uns jetzt unter http://www.vsalmug.com/default.aspx

In diesem Zuge werden wir zukünftig die Benachrichtigungen für unsere Meetings nicht mehr per E-Mail zustellen, sondern sie können sich Neuigkeiten unseren Blog mit den Ankündigungen per RSS abrufen (http://www.vsalmug.com/CMSPages/BlogRss.aspx?aliaspath=/Meetings/Announcements).

Zusätzlich ahben wir auf LinkedIn eine Gruppe eingerichtet über die sich die Mitglieder besser untereinander vernetzen können: http://www.linkedin.com/groups?home=&gid=2860483&trk=anet_ug_hm

Abschließend möchte ich auf unseren nächsten Vortrag noch hinweisen. Am Donnerstag, 06.05.2010 ab 19:00 wird Martin Woodward vorstellen wie die Integration mit nicht Microsoft-Plattformen über den Team Explorer Everywhere (vormals Teamprise) gelingt.

Team Explorer Everywhere 2010

Meeting Date: Thursday, May 6th, 2010
Time: 10:00AM PT (UTC-0700)
[Add to Calendar]
[Join Meeting]

Did you know that Team Foundation Server can be used for software development by your entire organization - not just the team using Microsoft platforms and technologies? In this session Martin Woodward will show you how you can get your Java, Mac, Linux, and Eclipse developers on board using Team Explorer Everywhere 2010. This session shows you how you can standardize on Team Foundation Server for the Application Lifecycle Management of your entire enterprise. See how to manage work items, version control, and build automation across technology and platform boundaries in your company and understand the features and functionality available to the people in your organization.

Speaker:  Martin Woodward

Martin Woodward is the Program Manager for the Microsoft Visual Studio Team Foundation Server Cross-Platform Tools Team and co-author of the book "Professional Application Lifecycle Management with Visual Studio 2010". Before joining Microsoft, Martin was voted Team System MVP of the Year and has spoken about Team Foundation Server at events internationally. Not only does Martin bring a unique insight into the inner workings of the product he has experience from over a half-decade of real world use at companies big and small that he is always happy to share. When not working or speaking, Martin can be found at his blog http://www.woodwardweb.com.

So langsam reift bei den letzten Source Safe Moikanern die Erkenntniss, dass es nun langsam Zeit wird sich nach einer anderen Quellcodeverwaltung umzusehen und eigentlich liegt da inzwischen nichts näher als der Team Foundation Server 2010 der nicht nur eine erstklassige Versionsverwaltung mit bringt sondern der acuh eine Vielzahl weiterer ALM-Funktionen beinhaltet und vor allem inzwischen in der MSDN Subscription kostenloas enthalten ist.

Wer wissen will, wie er schnell und einfach von Source Safe auf TFS migriert, findet alle notwendigen Infos hier : http://msdn.microsoft.com/en-us/library/ms253060.aspx

Christian Binder hat einen Deep Zoom zum Thema Testing mit Visual Studio 2010 auf seinem Blog veröffentlicht. Der Deep Zoom erlaubt es aus einer Übersichtsansicht sich tiefer in einzelne Themen hineinzuklicken, bis auf Detaileben. Der Deep Zoom enthält auch Videos die zwar nicht vertont sind aber die einzelnen Teilabläufe anschaulich darstellen. Echn ne coole Sache, also einfach mal selber reinschauen.

http://blogs.msdn.com/cbinder/archive/2010/04/22/einf-hrung-deepzoom-f-r-den-neuen-visual-studio-2010-test-manager-und-lab-management.aspx

In der TFS Adminconsole oder im TFS Configuration Wizard können die Reporting Services für den TFS konfiguriert werden.

Man gibt hier den Server und ggf. die Instanz der Reporting Services an und klickt auf “Populate URLs”, dann werden die entsprechenden URLs automatisch ausgefüllt – normalerweise zumindest. Ich hatte die Situation, dass der User mit dem ich den TFS installiert habe auf dem Server auf dem die Reporting Services liefen kein Administrator war. Normalerweise ist das der einfachste Weg, den TFS Account auf dem Reporting Server als lokalen Administrator einzutragen, das ist aber nicht in allen Fällen erwünscht. Dann bekommt man die Fehlermeldung

TF255050: A connection cannot be made to the Report Server WMI provider. Verify the following:
1. You have entered the correct name for the server, including the instance name.
2. The Windows Management Instrumentation service is running on vs2010rcdemo.
3. The service is not blocked by Windows Firewall.
4. You have the required permissions to connect.

Details:
Access is denied. (Exception from HRESULT: 0x80070005 (E_ACCESSDENIED))

Eine damit verwandte Fehlermeldung ist

TF255186: The following SQL Server Reporting Services Instance could not be found: MSSQLSERVER. The server name is: vs2010rcdemo.

In beiden Fälle fehlen dem User WMI-Berechtigungen auf dem Reporting Server. Im ersten Fall der Remote-Zugriff auf die WMI generell, im zweiten Fall auf den Remote-Zugriff für die Reporting Services in der WMI. Um die gewünschte Operation ausführen zu können muss dem User zunächst Remote-Zugriff auf WMI gegeben werden:

1. Auf dem Reporting Server dcomcnfg.exe starten
2. Im linken Bereich Console Root\Component Services\Computers\My Computer öffnen
3. Aus dem Kontextmenü von “My Computer” den Eintrag “Properties” öffnen
   
4. Im Bereich “Launch and Activation Permissions” auf “Edit Limits” klicken
5. Den Benutzer mit “Add hinzufügen und ihm “Remote Launch” und “Remote Activation” vergeben
   

Anschließend kann der Remote-Zugriff per WMI auf die Reporting Services konfiguriert werden.

1. Auf dem Reporting Server wmimgmt.msc starten
2. Im linken Bereich auf WMI Control (Local) aus dem Kontext-Menü “Properties” auswählen
3. Auf den Reiter Security wechseln und im Baum Root\Microsoft\SqlServer\ReportServer auswählen
   
4. Auf den Button “Security” klicken und den gewünschten benutzer mit “Add” einfügen
5. Dem Benutzer “Enable Account” und “Remote Enable” als Rechte vergeben
   
6. Auf “Advanced” clicken, den Benutzer auswählen und dann auf “Edit” klicken
7. Bei “Apply to” “This namespace and subnamespaces” wählen
   

Mit diesen Einstellungen sollte nun das “Populate URLs” in der TFS Administration Console funktionieren.

Wer sich eine Trial-Version von Visual Studio 2010 oder Team Foundation Server 2010 installiert benötigt einen Key um diese freizuschalten. Wer nun über eine MSDN-Subscription verfügt, kann sich die Vollversion dort herunterladen, jedoch man bekommt keinen Key. Nun kann man entweder neu installieren oder man greift zu einem kleinen Trick:

1. ISO-File vom MSDN herunterladen
2. Im ISO-Image nach der Datei setup.sdb suchen
3. Die Datei mit einem Texteditor öffnen
4. Der Key steht unter dem Eintrag [Product Key] und kann von hier einfach in das Registrierungsformular übertragen werden. Dazu im TFS einfach die Admin-Console öffnen und im Visual Studio unter Help / Register Product aufrufen

Update:

Inzwischen hatte MS ein Einsehen und die Keys bei den MSDN Subscriber Downloads veröffentlicht :-)

Beim Deployment einer Environment auf meinen Host bekam ich den Fehler TF259115:

Speicher war eigentlich genug frei auf meinem Host und so war ich zunächst erstaunt, warum er das nicht deployen wollte. Des Rätsels Lösung liegt darin, dass die Placement Policy standardmäßig auf “Conservative” eingestellt ist. Das bedeutet, dass der Host beim Deployment den Speicherbedarf aller VMs auf dem Host ermittelt, unabhängig davon ob diese gestartet sind oder nicht. Im Betrieb könnten ja dann alle gleichzeitig gestartet werden was dann zu Problemen führt. D.h. im Idealfall hat man immer soviel Ressourcen, dass alle Environments die deployed sind gleichzeitig laufen können, momentan nicht benötigte Environments werden in der Library abgelegt.

Da ich aber auf meinem Demo-Notebook nicht soviel Speicher habe und dabei nie alle Environments gleichzeitig laufen sollen, wollte ich diese Limitierung umgehen. Dies kann man erreichen, indem man die Placement Policy auf Aggresive stellt. Dies erreicht man am besten durch einen TFSConfig-Aufruf:

TfsConfig Lab /hostgroup /CollectionName:labcollection /Edit /Name:"All Hosts"
/LabEnvironmentPlacementPolicy:Aggressive

Logging sent to file C:\ProgramData\Microsoft\Team Foundation\Server Configuration\Logs\CFG_SET_URL_0413_225508.log
Command: lab
TfsConfig - Team Foundation Server Configuration Tool
Copyright (c) Microsoft Corporation. All rights reserved.
Are you sure you want to update the settings for this host group ? (Yes/No) y
The requested changes were successfully applied.

Die TFSConfig findet befindet sich im Pfad C:\Program Files\Microsoft Team Foundation Server 2010\Tools

Weitere Infos unter http://msdn.microsoft.com/en-us/library/dd547199(VS.100).aspx

Heute wurden Visual Studio 2010 und Team Foundation Server 2010 gelauncht. Microsoft neueste ALM Plattform bietet eine große Anzahl neuer Features, so dass sich ein näherer Blick auf jeden Fall lohnt, unter anderem:

• Testmanagement und Testausführung
• automatisierte GUI-Tests
• Virtualisierte Testumgebungen
• Erweiterte Tracking-Funktionen für Versionsverwaltung
• Agile Planungsmethoden
• Build Workflows auf Basis von WF 4.0
• Architektur-Features und UML-Diagramme
• Integrierte SharePoint-Entwicklung
• uvm

Ich werde in den folgenden Wochen in einzelnen Blogbeiträgen verschiedene Funktionen vorstellen, also vorbeischauen lohnt sich …

Weitere Informationen und den Download Link für Inhaber einer MSDN Subscription finden sich hier:

http://msdn.microsoft.com/de-de/vstudio/2010.aspx

Testversionen können hier heruntergeladen werden:
http://www.microsoft.com/germany/visualstudio/try/download.aspx

Team Foundation Server 2010 bietet nun eine verbesserte Integration mit SharePoint. Für die einzelnen Team-Projekte wird die Verbindung zu einer SharePoint Site typischerweise beim Anlegen des Projektes einrichten, alternativ kann man das auch im Nachhinein konfigurieren. Dazu einfach im TeamExplorer auf dem Team Projekt rechte Maustaste und dann unter “Team Project Setting” “Portal Settings” auswählen.

Hier wählt man dann unter “Configure URL” eine der konfigurierten Web Applications aus.

Bekommt mann beim Bestätigen des Fensters folgen Meldung, dann hat der aktuelle Benutzer nicht ausreichen Berechtigungen auf die Site / SiteCollection:

Server was unable to process request. ---> Failed to activate feature 'TeamFoundationWeb' (ID: 310284e3-35d9-4b5d-99b5-c42147379877) at scope 'http://sarmoss02/sites/TFS2008/BI_KaBIS'.

Diese Berechtigungen müssen im SharePoint eingetragen werden.

Für den Release Candidate für VS / TFS 2010 gibt es acuh die passenden Power-Tools die viele nützliche Funktionen hinzufügen.

Kostenloaser Download: http://visualstudiogallery.msdn.microsoft.com/en-us/a4f8a47e-1f6b-49d6-8f6e-34f705a2001b

Will man in einer Winforms-Anwendung einen String URL-encodieren, dann kann mann dafür einen einfachen Aufruf verwenden:

Das einzige wass man dafür tun muss, ist die System.Web.dll zu referenzieren. Eine kleine Hürde gibt es bei Visual Studio 2010, da hier standardmäßig “.Net Framework 4 Client Profile” als Target-Framework ausgewählt ist und das Client Profile die System.Web nicht enthält. Deshalb muss man in den Eigenschaften des Projektes das Target-Framework umstellen, z.B. auf .NET Framework 4.

Wollte heute ganz einfach eine Benachrichtigung für eine Liste im SharePoint einrichten. Das Ganze stellte sich als problematischer heraus als gedacht. Eigentlich ist das eine einfache Sache. Im Actions-Menü die Option “Aletr Me” aufrufen…

… , Einstellungen vornehmen und schon kommt eine Fehlermeldung:

The following users do not have e-mail addresses specified: <UserName>. Alerts have been created successfully but these users will not receive e-mail notifications until valid e-mail addresses have been provided

Der Link darunter mit “Set my e-Mail address” war auch nicht sehr hilfreich. Nach einigen Recherchen bin ich dann auf ein paar weitere Details gestoßen.

Zunächst habe ich herausgefunden, dass SharePoint die Benutzerprofile mit dem ActiveDirectory abgleicht, aber nur, wenn das konfiguriert ist. Das kann man unter Central Administration \ Shared Services Administration einstellen. Dort kann man im Dropdown-Menü des SharedService die Option “Open Shared Services Admin Site” aufrufen.

Unter “User Profiles and My Sites” kann nun die Option “User profiles and properties” gewählt werden.

Hier sollte zunächst geprüft werden, ob der Dienst der die User Profile mit dem ActiveDirectory abgleicht auch zur Ausführung eingeplant ist. Mit den unteren Links kann ein manueller Abgleich gestartet werden.

Über “View user profiles” kann man sich die importierten Profile anzeigen lassen, mit “View import log” kann man sich ein Protokoll zum Abgleich anzeigen lassen.

Sollen die Benutzer aus einer anderen Domäne importiert werden als die in der der SharePoint Server läuft, kann man über “View Import Connections” eine weitere Domäne hinzufügen.

Bei mir bestand dann noch das Problem, dass das Profil für meinen User nicht sauber durch den Import aktualisiert wurde. Nachdem ich den User aus der entsprechenden Site entfernt und neu hinzugefügt hatte, hat es problemlos funktioniert und ich kann jetzt meine Alerts problemlos einrichten und bin immer auf dem Laufenden was den Inhalt meiner SharePoint-Listen anbelangt.

Mit TFS 2010 kommen nun endlich hierarchische Workitem Queries und erfreulicherweise lassen diese sich auch im SharePoint Portal schön darstellen.

Was mich an der Geschichte nur etwas gestört hat, dass ist, dass die Hierarchie nach dem Laden immer vollständig aufgeklappt ist. Es gibt zwar einen Button “Collapse All” aber den dann immer extra zu drücken um erst mal einen Überblick zu bekommen, ist doch etwas lästig. Zunächst habe ich deshalb versucht die Query entsprechend anzupassen, jedoch gibt es an dieser Stelle leider noch keinen Parameter um das einzustellen. Für das SharePoint-Portal habe ich allerdings eine Lösung gefunden und die geht so:

1.) Ein neues Content Web Part auf der Seite einfügen:

2.) Auf dem Content Editor Web Part den Source Editor starten

3.) Hier folgendes Script eintragen:

               1: <script
language="javascript">

               2:
              function collapseQuery() 

               3: { 

               4: _ctl00_m_g_1409303e_8eb2_4dc3_80b0_822628dfcc28_ctl00.tryToggle(false, true);

               5: }

               6:  

               7: WPSC.RegisterForEvent("urn:schemas-microsoft-com:dhtml","onload",collapseQuery);

               8: </script>

Die ID des Webparts (_ctl00_m_g_1409303e_8eb2_4dc3_80b0_822628dfcc28_ctl00) lässt sich relativ einfach im HTML-Source der Seite ermitteln (z.B. IE 8 F12 drücken um in die Developer Tools zu gelangen). Hier kann man dann über Find / Select Element by Click durch Anklicken des WebParts die Stelle im Code einfach finden und die ID zu ermitteln. Zu beachten ist dabei, dass das die ID des Controls etwas anders lautet als das WebPart selbts, so muss am Anfang ein _ stehen und das Control auf _ctl00 enden.

Mit dem TFS 2010 ist es nun möglich, denn Application-Tier über einen NLB-Cluster zu betreiben. Damit kann man Ausfallsicherheit und Load-Balancing für den App-Tier erreichen. Mit einem SQL-Cluster als Data-Tier skaliert der TFS nun sehr schön, sowohl in Punkte Performance als auch in Bezug auf die Ausfallsicherheit.

Nun liegt es natürlich nahe, die Reporting Services ebenfalls über den NLB zu betreiben, was an sich auch kein Problem ist. Man muss nur ein paar Einstellungen vornehmen. So hats bei mir funktioniert:

1.) Das Scale-out Deployment für die Reporting-Services auf beiden Servern aktivieren (setzt SSRS Enterprise voraus)

2.) Die Web Service URL auf die IP-Adresse des NLB einstellen

3.) In der TFS Admin Console die Reporting Services über den NLB registrieren. Das hat bei mir nur über die IP-Adresse funktioniert, nicht über den Namen. Da muss ich bei Gelegenheit mal danach schauen.

4.) In der Datei C:\Program Files\Microsoft SQL Server\MSRS10.MSSQLSERVER\Reporting Services\ReportServer\rsreportserver.config unter <Service> folgendes Tag einfügen:

<Hostname>sartfsnlb01</Hostname>

5.) In der Web.config unter C:\Program Files\Microsoft SQL Server\MSRS10.MSSQLSERVER\Reporting Services\ReportServer\ und unter C:\Program Files\Microsoft SQL Server\MSRS10.MSSQLSERVER\Reporting Services\ReportManager\ im Abschnitt <system.web> folgenden Tag einfügen:

<machineKey validationKey="627BF72BB33AA8D28CA2C3E80920BA4DF0B726F97EEFBB0F4818350D63E6AFA380811F13ED1F086E386284654DB3DAF676707464EEB73EBF79858F477D8E4F5C"
decryptionKey="F40B6E5A02B29A181D2D213B5ED8F50B73CFCFD0CC56E137" validation="SHA1" />

Achtung die Parameterwerte dürfen nuicht umgebrochen werden. Einen eigenen Key kann man sich einfach unter http://aspnetresources.com/tools/keycreator.aspx generieren lassen.

6.) Reporting Srevices neu starten.

7.) Nun werden bei einem Ausfall eines App-Tiers alle Reporting-Anfragen über den anderen App-Tier abgewickelt, der Anwender merkt davon nichts außer dass es beim ersten Zugriff nach dem Ausfall ein wenig länger dauert.

Dieses Jahr ist nach längerer Zeit die TechEd, die wichtigste Microsoft-Konferenz in Europa, wieder in Deutschland, genauer gesagt vom 09.Nov – 13. Nov in Berlin. Ich werde dort als ATE (Ask the Experts) zum Thema Visual Studio ALM vertreten sien und darüber hinaus mit Christian Binder und Neno Loje ein Q&A Session zu den Themen TFS, ALM und Visual Studio 2010 zu machen. Die Session wird in Deutsch sein, also wenn ihr Fragen rund um den Themenbereich habt, besucht unsere Q&A-Session. Soviel geballtes Wissen auf einmal gibts nicht so bald wieder :-)

Visual Studio Team Foundation Server Q&A
Mittwoch, 11. November
14:00 – 15:00 Uhr
Community Stage im Zentrum der Ausstellung Halle 4.2

Hype-V ist ein klasse Virtualisierungssystem das vor allem in der neuesten Version eine Reihe nützlicher Funktionen mitbringt. Besonders hilfreich sind Snapshots mit denen es gefahrlos möglich ist, auch auf dem Server mal was zu testen. Man kann sich aber mit Shanpshots leicht selber überlicsten oder gar in’s Knie schießen. Deshalb möchte ich hier ein paar Erfahrungen zum Besten geben:

Funktionsweise von Snapshots

Die Virtuellen Maschinen von Hyper-V schreiben ihre Daten in virtuelle Harddisks (VHD), also eine Datei auf der Platte des Hosts. Wird nun ein Snapshot gemacht, passiert vereinfach gesagt, Folgendes. Die VHD-Datei wird schreibgeschützt, so dass daran keine Änderungen mehr vorgenommen werden können. Statt dessen wird nun eine AVHD-Datei angelegt und alle Änderungen auf der Platte der VM werden nun dort hineingeschrieben. Wird erneut ein Snapshot erstellt, wird die AVHD gesperrt und eine weitere angelegt.

Dies hat nun zweierlei Folgen:

1. Je mehr Snapshots erstellt werden, desto langsamer wird der Zugriff auf die virtuelle Disk, da Hyper-V ja aus der VHD und den verschiedenen AVHDs nun die Daten zusammensammeln muss.
2. Nur die VHD und alle AVHDs zusammen ergeben den aktuellen Stand der virtuellen Disk, mit der VHD alleine hat man nur den Stand vom ersten Snapshot.

Gerade der letzte Punkt ist beim Verschienen der VM oder beim Backup zu berücksichtigen, da man hier schnell Daten verlieren kann, wenn man vergisst die AVHDs zu berücksichtigen.

Aus beiden oben genannten Gründen macht es Sinn, Snapshots zu löschen, sobald diese nicht mehr gebraucht werden. Snapshots sind keine Technik zur Erstellung von Backups! Zum löschen eines Snapshots wird dieser einfach selektiert und dann mit “Delete” gelöscht. Aber ACHTUNG! Die Daten liegen nun immer noch in der AVHD. Erst wenn man die VM in den Save-State fährt, beginnt Hyper-V mit einem Merge, d.h. die Änderungen der AVHDs werden jetzt in die jeweils vorausgegangene AVHD bzw. VHD gemerged, sind alle Snapshots gelöscht, bleibt nur noch die VHD übrig.

Erst nach Abschluss des Merge-Vorgangs erhält man durch eine Kopie der VHD eine komplette Sicherung der virtuellen Disk der VM.

Die .net Developer Group Ulm bietet am 27.10.2009 eine kostenlose Ganztagesveranstaltung rund um Visual Studio 2010 ALM (vormals VSTS 2010). Die Nachfrage für diese Veranstaltung ist so hoch, dass wir uns entschieden haben, die Veranstaltung am 26. November nochmals mit gleichen Sprechern und gleichem Inhalt zu wiederholen. Wer also noch Interesse hat, sollte sich bald möglichst unter http://www.dotnet-ulm.de/vsts2010/ registrieren, wir haben noch ein paar Plätze frei.

Christian zeigt in einem schönenn Blog-Beitrag wie einfach sich der TFS Basic installieren lässt (sogar auf einem Client-Betriebssystem) und wie schnell und einfach damit der Einstieg in die Versionsverwaltung und das Workitem-Tracking gelingt. Da kann nun wirklich jeder diese Features nutzen, auch Solo-Entwickler.

http://blogs.msdn.com/cbinder/archive/2009/10/19/vs2010-beta2-f-r-einsteiger-tfs-auf-win7-installieren-und-version-control-plus-bug-tracking-nutzen.aspx

Die Beta 2 von Visual Studio 2010 ist nun für MSDN Subscribers verfügbar, für alle anderen wird es noch bis Mittwoch dauern. Es gibt eine reihe von wichtigen Änderungen die Microsoft mit Visual Studio 2010 ankündigt:

• Es gibt eine abgespeckte Version von TFS (TFS Basic) die auch auf Client-Betriebssystemen installiert werden kann.
• TFS ist jetzt in alle versionen von Visual Studio 2010 enthalten (meines Wissen nach nur bei denen mit MSDN)
• Es gibt ein vereinfachtes Modell der Produkt SKUs (Editionen)
• Neues Logo (siehe oben)

Was ich persönlich schade finde: Die Bezeichnung “Team System” verschwindet, es gibt nun nur noch

• Microsoft® Visual Studio® 2010 Express
• Microsoft® Visual Studio® 2010 Professional
• Microsoft® Visual Studio® 2010 Professional with MSDN
• Microsoft® Visual Studio® 2010 Premium with MSDN
• Microsoft® Visual Studio® 2010 Ultimate with MSDN
• Microsoft® Visual Studio® Test Elements 2010 with MSDN
• Microsoft® Visual Studio® Team Foundation Server 2010
• Microsoft® Visual Studio® Team Lab Management 2010
• Microsoft® Visual Studio® Load Test Virtual User Pack 2010

Positiv ist aber, dass die Beta 2 eine Go-Live-Lizenz enthält. Der Launch-Termin wirde von Microsoft für den 22. März 2010 angekündigt.

http://blogs.msdn.com/somasegar/archive/2009/10/19/announcing-visual-studio-2010-and-net-fx-4-beta-2.aspx

In Expression Blend gibt es ein cooles Feature, mit dem Beispieldaten für Databinding erzeugt werden können. Damit können beispielsweise Listboxen etc. mit Daten befüllt werden um z.B. DataTemplates im Designer testen zu können.

Und auch bei der Ausführung der Anwendung stehen die Daten zur Verfügung. Damit können schnell und einfach Oberflächenprototypen erstellt werden.

Eine detaillierte Beschreibung der Funktion findet sich hier.

Auf der diesjährigen ADC hatte ich zwei Vorträge:

• Effektive Prozesse durch Architektur
• Organisation von Entwicklerteams

Zu beiden Vorträgen gibt es die Unterlagen über den jeweiligen obenstehenden Link.

Hat man eine Query die zwei Spalten mit dem gleichen Namen enthält, dann mekert der Reporting Services Designer “The query contains more than one unnamed or duplicated field name. Please specify unique column aliases.”

In der MDX-Abfrage Aliase zu vergeben ist mir nicht gelungen. Glücklicherweise gibt es aber einen einfacheren Weg das Problem zu lösen. Man geht einfach in die Eigenschaften des Datasets und dort auf “Fields”. Hier kann man nun einfach einen eindeutigen Alias angeben.

Oft möchte man Werte, z.B. Prozentwerte als kleine Balken in einem Report darstellen:

Wie man das mit Hilfe der Reporting Services bewerkstelligt, ist im Folgenden kurz beschrieben.

• Zunächst erstellt man sich eine Grafik mit dem gewünschten Verlauf
• Dann fügt man eine neue Spalte mit dieser Grafik in den Report ein. Der Grafik gibt man ein günstige Breite, z.B. 100px.
• Für die Grafik stellt man nun ein Padding für den rechten Rand ein und zwar über eine Expression:

• In der Expression gibt man nun eine Formel ein, die den rechten Rand so berechnet, dass er bei 0 die Breite des Bildes erreicht und beim Maximalwert 0.

• In obigem Beispiel hat das Bild eine Breite von 100pt und soll einen Maximalwert von 1.5 anzeigen, so dass bei 1.5 der Wert für das Padding 0 ist und bei 0 ist er 100 (1,5 * 75). Damit zeigt der Balken die Werte grafisch an. Auf Wunsch kann man natürlich den Wertebereich auch min Min() und Max() ermitteln.

http://blogs.msdn.com/bobmeyers/archive/2005/10/15/481342.aspx

Meinem SQL-Server kam bei einer meiner Datenbank-Tabellen was supekt vor jedenfalls zeigte er in Klammern hinter der Tabelle ein (Suspect) an und ich konnte auf die Tabelle nicht mehr zugreifen. Ärgerlich war, dass es sich dabei um die Config-Datenbenk meines SharePoint-Servers handelte und damit mein kompletter SharePoint-Srever lahm gelegt war. Glücklicherweise fand ich ein kleines Script, das das Problem in Sekunden behoben hat.

EXEC sp_resetstatus 'DBname'

ALTER DATABASE DBname SET EMERGENCY

DBCC checkdb('DBname')

ALTER DATABASE DBname SET SINGLE_USER WITH ROLLBACK IMMEDIATE

DBCC CheckDB ('DBname', REPAIR_ALLOW_DATA_LOSS)

ALTER DATABASE DBname SET MULTI_USER

Dort habe ich einfach meinen Datenbanknamen entsprechend eingesetzt und schon lief der SharePoint wieder. Vielen Dank an der Stelle an Mohamad.

http://mshehadeh.blogspot.com/2007/09/restoring-sql-server-2005-suspect.html

Mit Team Foundation Server 2010 wird der TFS nun auch für kleinere Teams noch interessanter als bisher. Es gibt eine Reihe von Vorteilen gegenüber der aktuellen Version:

• Preis
  Es gibt im Moment noch keine abschließenden Informationen über das Pricing, aber voraussichtlich wird der Preis zukünftig wohl kaum noch ein Argument sien, den TFS nicht zu nutzen.
• Systemanforderungen
  Die Anforderungen an das System sind deutlich geringer als bei TFS 2008. So kann der TFS nun auf einem Domänen-Controller und sogar auf Client-Betriebssystemen installiert werden. Zudem können nun einige Komponenten wie SharePoint und Reporting optional installiert werden.
• Installation
  Der Installationsvorgang wurde deutlich vereinfacht.

Damit kommt Microsoft dem Slogen “ALM for the masses” einen großen Schritt näher.

Weitere Details gibt es auf dem Blog von Brian Harry:
http://blogs.msdn.com/bharry/archive/2009/10/01/tfs-2010-for-sourcesafe-users.aspx

Mit dem Work Item Type Designer (WIT Designer) können Work Item Type Definitionen einfach und bequem angepasst werden. Der WIT Designer ist Bestandteil der TFS Power Tools.

Mit dem WIT Designer kann man auch die Workflows auf den Work Item Types grafisch bearbeiten. Dazu kann man aus der Toolbox einfach neue States und Transistions auf das Workflow-Diagramm ziehen … zumindest wenn die Toolbox Elemente enthält. Sollte die Toolbox einmal leer sein, dann gibt es eine nicht ganz elegante aber wirksame Methode, man löscht einfach alle toolbox*.tdb Dateien und zwar au dem Ordner

C:\Users\<USERNAME>\AppData\Local\Microsoft\VisualStudio\8.0.

Danach erscheinen die Elemente ganz normal.

Wir haben einen neuen Nachbarn bekommen :-)

In Augsburg gibt es nun auch eine .net Usergroup. Diese wird von Tobias Schmid geleitet. Damit ist nun also die Lücke zwischen München und Ulm geschlossen und ich freue mich auf eine gute Zusammenarbeit.

Apropos Zusammenarbeit, ganz besonders freut es mich, dass ich am 14.10.2009 beim Gründungstreffen einen Vortrag zum Thema “Durchgängige Entwicklungsprozesse mit Visual Studio Team System” halten darf.

Dann auf gute Nachbarschaft :-)

http://www.ug-augsburg.net/

Mit Martin Woodward haben wir einen der weltweit bekanntesten Team System MVPs zu Gast der in seinem Vortrag über die neuen Möglichkeiten des Build Systems im TFS 2010 informieren wird. Dass sich beim Build in TFS2010 einiges getan hat, wird bereits aus der Auflistung der Hauptpunkte von Martins Vortrag ersichtlich. Es wird um Private Builds, Gated Checkins und um die neuen workflow-basierten Builddefinitionen gehen.

Über TSUG-VE
Die Team System User Group – Virtual Edition ist eine weltweite Usergroup zum Thema Team System. Die Treffen finden virtuell in Live Meeting statt. Weitere Informationen gibt’s unter http://www.tsug-ve.com.

Am 27.10.09 veranstaltet die .net Developer Group eine kostenlose Informationsveranstaltung rund um Visual Studio Team System 2010. Ein Tag voll gepackt mit wertvollen Informationen rund um die neue Version der Microsoft ALM-Plattform.

Mit Visual Studio Team System 2010 führt Microsoft voraussichtlich Anfang nächsten Jahres eine neue Version seiner Entwicklungsplattform ein, die mit zahlreichen Neuerungen aufwartet. Diese neue Version wartet mit einer großen Zahl umfangreicher Neuerungen auf wie z.B.:

• Architektur-Diagramme und UML-Support
• Erweiterte Funktionen für Test-Planung und Test-Durchführung
• Unterstützung von UI-Tests
• Verbesserte Verwaltung von Builds
• Verbesserte Verwaltung von Work Items
• Neue Reporting-Funktionen speziell für kleinere Teams
• Und vieles mehr

Um diese Umfangreichen Neuerungen alle vorstellen zu können, veranstaltet die .Net Developer-Group Ulm erstmalig einen ganztägigen Event um damit der Fülle von Funktionen auch gerecht zu werden. Dabei werden die beiden Referenten Christian Binder (http://blogs.msdn.com/cbinder) und Thomas Schissler (http://www.artiso.com/problog) nicht nur die neuen Funktionen vorstellen, sondern auch aufzeigen, welche Probleme aus dem Entwickler-Alltag damit gelöst werden können. Der Vortrag richtet sich dabei nicht nur an Entwickler und Projektleiter die bereits mit Team System arbeiten, sondern erläutert auch grundsätzliche Konzepte und bereits bestehenden Funktionen der Tools Visual Studio Team System und Team Foundation Server und bietet damit auch denjenigen einen guten Einstieg, die sich noch nicht intensiv mit Microsofts ALM-Plattform auseinandergesetzt haben.

Für die Veranstaltung ist eine Registrierung erforderlich. Interessenten können sich unter http://www.dotnet-ulm.de/vsts2010 kostenlos registrieren.

Beim Installieren eines Team Foundation Server 2010 Beta 1 habe ich einen Fehler TF254038 bekommen. Beim Anlegen einer SharePoint Web Application auf dem TFS hat der Wizard behauptet ich hätte die SharePoint Extensions nicht installiert.

Ich habe für den TFS und den SharePoint Server zwei getrennte Maschinen. Das Problem lag letztendlich darin, dass die Firewall auf der SharePoint Maschine den Zugriff auf die SharePoint Central Administration (Port 17012) geblockt hat. Nachdem ich den freigegeben habe, lief die Installation problemlos durch.

Wie in diesem Blog bereits an anderen Stellen erläutert, eignet sich das UIA (UI Automation Framework) sehr gut, um UI-Tests aufzubauen. Wer sich mit dieser Möglichkeit beschäftigt wird aber früher oder später auf das Problem stoßen, dass UIA Support bei WinForms Controls nicht flächendeckend gegeben ist, vor allem bei 3rd Party Controls sieht es da oft eher mau aus.

Ich habe hier beschrieben, wie man mit einem ServerSide Provider diese Lücken selbst schließen kann. Das Standardvorgehen sieht dabei vor, dass man ein eigenes Control erstellt, das man dann von dem Ausgangscontrol ableitet. Diese Vorgehen ist in der Praxis allerdings nicht unproblematisch. Zum einen muss man die abgeleiteten Controls für jedes neue Release der Ausgangscontrols aktualisieren und zum zweiten ist es nicht gerade schön in einer bestehenden Anwendung alle Controls gegen die abgeleitete Variante austauschen zu müssen.

Deshalb möchte ich hier einen alternativen Weg vorstellen. Die Idee beruht darauf, dass die Controls, denen es an Accesibility fehlt jeweils in ein Panel platziert werden und auf diesem Panel dann die entsprechenden Patterns implementiert werden. Das Panel kann die Operationen dann an das Control in seinem Bauch weiterleiten.

Ich habe mal ein Beispiel für Janus Calendar Controls gebaut. Zunächst habe ich mir ein UIA-Panel erstellt, von dem ich dann die weiteren Panels für die spezifischen Controls ableiten kann.

               1:
              using System;

               2:
              using System.Drawing;

               3:
              using System.Security.Permissions;

               4:
              using System.Windows.Automation;

               5:
              using System.Windows.Automation.Provider;

               6:
              using System.Windows.Forms;

               7:  

               8:
              namespace WindowsFormsApplication1

               9: {

               10:
              public
              partial
              class UIAPanel
: Panel, IRawElementProviderSimple

               11: {

               12:
              public UIAPanel()

               13: {

               14:
              this.BackColor
= Color.Yellow;

               15:
              this.Height
= 0;

               16:
              this.Width
= 0;

               17:
              this.AutoSize
= true;

               18: }

               19:  

               20: [PermissionSetAttribute(SecurityAction.Demand,
Unrestricted = true)]

               21:
              protected
              override
              void WndProc(ref Message
m)

               22: {

               23:
              //
0x3D == WM_GETOBJECT
            

               24: Int32
param = 0;

               25:
              if (Int32.TryParse(m.LParam.ToString(), out param))

               26: {

               27:
              if ((m.Msg
== 0x3D) && (param == AutomationInteropProvider.RootObjectId))

               28: {

               29: m.Result
= AutomationInteropProvider.ReturnRawElementProvider(

               30: Handle,
m.WParam, m.LParam, (IRawElementProviderSimple)this);

               31:
              return;

               32: }

               33: }

               34:
              base.WndProc(ref m);

               35: }

               36:  

               37:
              #region IRawElementProviderSimple
Members

               38:  

               39:
              public
              object GetPatternProvider(int patternId)

               40: {

               41:
              if (patternId
== ValuePatternIdentifiers.Pattern.Id)

               42: {

               43:
              return
              this;

               44: }

               45:
              else
            

               46: {

               47:
              return
              null;

               48: }

               49: }

               50:  

               51:
              public
              object GetPropertyValue(int propertyId)

               52: {

               53:
              if (propertyId
== AutomationElementIdentifiers.ClassNameProperty.Id)

               54: {

               55:
              return
              "CalendarPanel";

               56: }

               57:
              else
              if (propertyId
== AutomationElementIdentifiers.ControlTypeProperty.Id)

               58: {

               59:
              return ControlType.MenuBar.Id;

               60: }

               61:  

               62:
              if (propertyId
== AutomationElementIdentifiers.HelpTextProperty.Id)

               63: {

               64:
              return
              "Help
for CalendarPanel";

               65: }

               66:  

               67:
              if (propertyId
== AutomationElementIdentifiers.AutomationIdProperty.Id)

               68: {

               69:
              return
              this.Name; 

               70: }

               71:  

               72:
              if (propertyId
== AutomationElementIdentifiers.IsEnabledProperty.Id)

               73: {

               74:
              return
              true;

               75: }

               76:  

               77:
              else
            

               78: {

               79:
              return
              null;

               80: }

               81: }

               82:  

               83:
              public IRawElementProviderSimple
HostRawElementProvider

               84: {

               85: get

               86: {

               87:
              return AutomationInteropProvider.HostProviderFromHandle(Handle);

               88: }

               89: }

               90:  

               91:
              public ProviderOptions
ProviderOptions

               92: {

               93: get

               94: {

               95:
              return ProviderOptions.ServerSideProvider;

               96: }

               97: }

               98:  

               99:
              #endregion
            

               100:  

               101: }

               102: }

Dieses Panel stellt einen ServerSide Provider zur Verfügung. Wir können nun von diesem Control ableiten und ein entsprechendes Pattern, z.B. das SetValue Pattern implementieren:

               1:
              using System;

               2:
              using System.Windows.Automation.Provider;

               3:
              using System.Windows.Forms;

               4:  

               5:
              namespace WindowsFormsApplication1

               6: {

               7:
              public
              partial
              class CalendarPanel
: UIAPanel, IValueProvider

               8: {

               9:
              private Janus.Windows.Schedule.Calendar
control;

               10:
              public Janus.Windows.Schedule.Calendar
Control

               11: {

               12: get

               13: {

               14:
              if (control
== null)

               15: {

               16:
              if (this.Controls.Count
> 0 && this.Controls[0].GetType() == typeof(Janus.Windows.Schedule.Calendar))

               17: control
= (Janus.Windows.Schedule.Calendar)this.Controls[0];

               18: }

               19:
              return control;

               20: }

               21: }

               22:  

               23:
              #region IValueProvider
Members

               24:  

               25:
              public
              bool IsReadOnly

               26: {

               27: get 

               28: {

               29:
              return
              false;

               30: }

               31: }

               32:  

               33:
              public
              void SetValue(stringvalue)

               34: {

               35:
              this.BeginInvoke((MethodInvoker)delegate()

               36: {

               37: DateTime
date = DateTime.Parse(value);

               38: Control.SelectionRange
= new Janus.Windows.Schedule.DateRange(date, date);

               39: });

               40: }

               41:  

               42:
              public
              string Value

               43: {

               44: get 

               45: {

               46:
              return Control.SelectionRange.End.ToShortDateString(); 

               47: }

               48: }

               49:  

               50:
              #endregion
            

               51: }

               52: }

Wenn wir nun das Calendar_Control nicht direkt auf unserer Form platzieren, sondern in einem solchen CalendarPanel ablegen, können wir eine Automatisierung über die UIA gegen dieses Panel implementieren. Was nun noch optimiert werden soll, ist dass die ganzen Controls nicht händisch in die jeweiligen Panels platziert werden sollen, sondern dies soll nach Möglichkeit automatisiert werden. der Ansatz hierbei ist, dass alle Controls auf der Form beim Laden untersucht werden und für die gewünschten Controls dynamisch entsprechende Panels erzeugt werden sollen, in die dann die Controls platziert werden. Dieser Ansatz bietet zudem den Vorteil, dass man die UIA-Panels nur dann nutz, wenn man UI-Test ausführen möchte. Bei der Release-Version sind diese dann nicht enthalten. Zwar unterscheidet sich dadurch Release und Test-Version geringfügig, jedoch sollten diese Implikationen vernachlässigbar sein, vor allem dann, wenn beim Entwickeln komplett auf die Panels verzichtet wird und diese wirklich nur für die UI-Tests genutzt werden.

Der Code dazu sieht dann so aus:

               1:
              private
              void PlaceControlsIntoPanel(Control.ControlCollection
controls)

               2: {

               3: Panel
uiaPanel;

               4:  

               5:
              foreach (Control
automationControl in controls.OfType<Control>().ToList())

               6: {

               7:
              switch (automationControl.GetType().ToString())

               8: {

               9:
              case
              "Janus.Windows.CalendarCombo.CalendarCombo":

               10: {

               11: uiaPanel
= new CalendarComboPanel();

               12:
              break;

               13: }

               14:
              case
              "Janus.Windows.Schedule.Calendar":

               15: {

               16: uiaPanel
= new CalendarPanel();

               17:
              break;

               18: }

               19:
              default:

               20: {

               21:
              if (automationControl.HasChildren)

               22: {

               23: PlaceControlsIntoPanel(automationControl.Controls);

               24: }

               25:
              continue;

               26: }

               27: }

               28: uiaPanel.Name
= "p_" + automationControl.Name;

               29: uiaPanel.Top
= automationControl.Top;

               30: uiaPanel.Left
= automationControl.Left;

               31: uiaPanel.Controls.Add(automationControl);

               32: automationControl.Top
= 0;

               33: automationControl.Left
= 0;

               34: controls.Add(uiaPanel);

               35: }

               36: }

Wird die Anwendung dann inkl. Test-Client ausgeführt, sieht das so aus:

Im Juni werden wir beim EMEA-Meeting der Team System User Group Virtual Edition Ed Blankenship als Sprecher haben. Ed ist MVP für Team System und Release Manager bei Infragistics, dem führenden Hersteller von UI-Komponenten. Er wird in seinem Vortrag über die Erfahrungen bei der Einführung von VSTS bei Infragistics berichten. Dabei werden die verschiedenen Bereiche wie Versionsverwaltung, Build Management, Work Item tracking, das Management globaler Teams, automatisiertes Testen und vieles mehr aus einer Anwendersicht beleuchtet. Ein wirklich sehenswerter Erfahrungsbericht aus der Praxis.

Weitere Informationen unter www.tsug-ve.com.

Im Team Foundation Server werden Änderungen an den Inhalten der Workitems in einer Historie festgehalten. Diese Historie kann man auf jedem einzelnen Workitem einsehen.

Mit einem kostenlosen Excel-Addin können diese Auswertungen auch massenhaft durchgeführt und so über ganze Projekte Auswertungen über die Historie erstellt werden. Dazu wird zunächst ein Zeitraum und ein Intervall ausgewählt (alternativ kann man auch einen bestimmten Zeitpunkt wählen):

Nun werden für jeden gewählten Zeitpunkt die Work Items in dem jeweiligen Zustand in eine Excel-Tabelle eingetragen. Diese kann nun sehr schön über eine Pivot-Tabelle oder ein Pivot-Chart ausgewertet werden um so den zeitlichen Verlauf bestimmter Kennwerte abzubilden.

Natürlich lassen sich solche Ergebnisse auch über das DataWarehouse im TFS ermitteln, jedoch besitzt dieses Tool zwei Vorteile:

1. Es ist wesentlich einfacher zu bedienen und übersichtlicher, so dass damit auch Ad-Hoc Reporting für Anwender möglich wird.
2. Es grift auf alle Workitem-Daten zurück, nicht nur auf die, die im DataWareHouse konfigurierten. Einzige Ausnahme sind Links und Attachments, die in beiden Varianten nicht Teil der Historie sind.

Weitere Informationen und den kostenlosen Download gibtes unter http://www.alm-tools.de/?Product=5

Ein Video das die Fuinktionsweise des Tools demonstriert kann hier agezeigt werden.

Eigentlich versuche ich meinen Blog weitgehend werbefrei zu halten. Diesesmal möchte ich aber doch kurz auf die Seite www.alm-tools.de hinweisen, die mein Arbeitgeber artiso betreibt. Hier haben wir vor Kurzem eine Reihe neuer Tools rund um das Thema TFS und ALM (Application Lifecycle Management) veröffentlich, zum Teil kostenlos. Zudem gibt es hier inzwischen auch ein kleines Archiv mit Videos rund um das Thema das wir kontinuierlich ausbauen.

Mein Kollege Mark Bulmahn hat in einem Screencast ein Problem näher untersucht, das beim Merge in der TFS Source Countrol auftreten kann. Dabei geht es vor allem darum, dass Verschiebe-Operationen im Visual Studio Solution Explorer in der Source Control nicht als Verschiebe-Operation sondern als Delete und Add ausgeführt wird. Das führt dann zu Problemen bei einem späteren Merge.In dem Screencast sieht man, wie dieses Problem vermieden und auch wieder repariert werden kann.

Wenn schon mit Pre-Releases arbeiten, dann richtig habe ich mir gedacht und versucht den Team Foundation Server 2010 Beta 1 auf dem Windows 2008 Server R2 RC zu installieren. Nach einer kurzen Recherche im Internet bin ich auf diesen Blog-Post gestoßen. Mit den Informationen dort ist es mir tatsächlich gelungen, den TFS 2010 Beta1 und VSTS 2010 Beta1 auf dem Win2008R2 RC zu installieren. Damit komme ich nun auch auf meiner Demo-Maschine in den Genuss der Desctop-Experience von Win2008R2 :-)

Im Mai haben wir bei der TSUG-VE Ian Ceicis als Sprecher zum Thema Projekt Management mit TFS 2010. Er wird in seinem Vortrag die Neuerungen rund um das Workitem-Tracking in TFS 2010 vorstellen.

Want to get the skinny on the latest enhancements coming in TFS 2010, come see demos of the updated MSF Agile template, the new Agile workbooks, the new Excel reports, and the Microsoft Project client improvements such as Hierarchical work items, rollups, and project summary tasks. This session will be packed with demos from  Beta 1 and will be a great way to start getting familiar with the new tools coming in 2010. Bring your hardest questions, join the conversation, and walk away with the ability to see how your next project will run smoothly if you start using TFS 2010.

This month's meeting is being presented by Ian Ceicys.  Ian is a member of Microsoft's Global ALM Practice and an active member of the VSTS Rangers.

 

Das Treffen findet am Donnerstag, 21.05.2009 um 19:00 statt.

Weitere Infos unter http://www.tsug-ve.com

Unter http://msdn.microsoft.com/en-us/library/dd831853(VS.100).aspx steht inzwischen auch die Dokumentation für das .Net Framework 4 Beta 1 und Visual Studio 2010 Beta 1 zur Verfügung. Für die Beta 1 wird es nur eine Online-Version der Dokumentation geben, eine lokale Installation wird erst mit einer späteren Version verfügbar sein, was sicher bei einer Beta-Dokumentation auch Sinn macht.

Nachdem es bisher nur Gerüchte gab, nun ist es offiziell. Visual Studio 2010 Beta 1 wird noch heute für MSDN-User verfügbar sein. Für die Öffentlichkeit gibt es den Download dann ab Mittwoch.

Diesmal aus einer verlässlichen Quelle (Soma Somasegar, Corporate Vice President Microsofts)

Visual Studio 2010 and .NET FX 4 Beta 1 ships!

Update: Ich habe die Bits inzwischen runtergeladen. Da haben die Jungs wirklich noch einiges reingepackt gegenüber den früheren CTPs.

    &  

Mit der Version 3 des Design-Tools für WPF und SilverLight, Expression Blend bekommt nun endlich die Unterstützung für den Team Foundation Server um die Source-Dateien in der Versionsverwaltung abzulegen. Hierzu muss ein entsprechendes Hotfix installiert werden. Dann hat man im Project-View zusätzliche Icons die den Auscheck-Status der Dateien anzeigt und im Kontext-Menü befinden sich entsprechende Kommandos für die Versionsverwaltung.

Hinweis: Damit das beim ersten Start auch wirklich funktioniert, muss man im Visual Studio den Team Explorer wenigstens einmal gestartet haben und dort den Server registrieren. Sonst bekommt man die Meldung "Unable to determine workspace" im Expression Blend.

Beim Checkin ist auch die sehr nützliche Funktion zur Verknüpfung von Workitems beim Checkin verfügbar.

Damit kann Expression Blend nun endlich in den Entwicklungs-Prozess von Software-Anwendungen integriert werden und steht nicht nur als separates Design-Tool bereit.

Nach rund einer Woche ist bereits die Hälfte der Plätze beim .Net Open Space Süd 2009 vergeben. Stand heute haben wir 33 Anmeldungen und es sind ein paar hochkarätige .Net Experten darunter. Wer also noch dabei sein will, sollte nicht zögern, sondern sich gleich auf die Teilnehmerliste eintragen.

Wir sehen uns am 11/12. Juli in Ulm!

Auf einer neuen TFS-Instanz hatte ich eben ein seltsames Phänomen. Ich konnte das erste Team-Projekt problemlos anlegen. Dazu verwendete ich einen Team_Explorer mit einer Visual Studio Shell Installation auf dem Server. Als ich allerdings das zweite Projekt anlegen wollte, kam eine Fehlermeldung, dass mir die Berechtigungen auf den Reporting Services fehlen. Seltsam nur, dass es beim ersten Projekt geklappt hat und dazwischen nichts geändert wurde. Mit einem kleinen Trick konnte ich dann doch ein zweites Projekt anlegen, nämlich indem ich alle Projekte aus dem Team-Explorer entfernt habe. Dann konnte ich wieder genau ein neues anlegen.

Die eigentliche Lösung für das Problem brachte aber die Installation des SP1 auf dem Server. Dabei ist zu beachten, dass das SP1 für den Team-Explorer nicht Bestandteil des Team Foundation Server SP1 ist, sondern des Visual Studio SP1. Also das Visual Studio SP1 installiert und danach lief es wunderbar.

Letzte Woche habe ich bei der .Net Developer-Group Ulm einen Vortrag zum Thema “10 Gründe warum Software-Projekte fehlschlagen – und was hilft ALM"?” gehalten. Es gab zu diesem Vortrag eine reihe interessanter Diskussionen. Die Folien gibt’s hier zum herunterladen:

Bei der TeamConf handelt es sich um eine Konferenz mit dem Focus auf Themen rund um VSTS und TFS. Da durfte ich natürlich nicht fehlen ;-)

Leider war mein Vortrag der letzte der Konferenz und dazu noch parallel zum VSTS 2010 Vortrag von Christian Binder. Dennoch fand sich eine interessierte Runde zum Thema “Requirements Management in leichtgewichtigen Prozessen” zusammen. Hier noch meine Folien zum Download:

Termin: 19.05.2009 - 18:00 Uhr

Veranstaltungsort:

Referent:

Vortrag:

As Developers, when we see a given demand, we always think on how to solve on a very imperative way (first do this, then this, finally that). Why not starting thinking on a more functional level, where we do not need to break one given task into so small imperative steps? This session will introduce Microsoft's new language F#, a typed functional programming language for the .NET Framework that combines the succinctness, expressivity and compositionality of functional programming with the runtime support, libraries, interoperability, tools, and object model of .NET. We'll take a look at why Microsoft is adding the language to the suite of those available on .NET and at some of simple language constructs that make programming in F# a dream.

Pedro Castelo Branco Lourenço is a Brazilian guy that moved into Germany to work as Innovation manager at Savcor IT GmbH(http://www.savcor.de), MVP (Microsoft Most Valuable Professional) on C#, Microsoft Certified Professional Developer(Web & Windows), independent consultant to companies that build software using .Net platform, speaker in some well known technical events such as Tech Ed 2005, 2008(Brazil), Community Days, Developers On The Road, União.Net. Bachelor degree in computer science, member of moderator’s team of .Net Raptors community (www.dotnetraptors.com.br). During his free-time he is studying German to make his family life easier!

Im zweiten Teil wurde anhand eines kleinen Demos die konkrete Implementierung von WCF-Anwendungen erläutert. Es wurde ein Chat-System auf Basis der WCF erstellt. Das Demo gibt es hier zum Download. Außerdem möchte ich hier noch auf eine Einführung in die WCF hinweisen die man hier findet

Beim ersten Termin wurden die Grundlagen zu verteilten Anwendungen im allgemeinen und der WCF im speziellen vermittelt.

Eines der coolsten Features in Windows 7 ist für mich der Problem Steps Recorder. Damit lassen sich Benutzeraktionen aufzeichnen und als MHT-File mit Screenshoots ausgeben. Diese Funktion eignet sich sehr gut um z.B. Installationsanleitungen oder auch Dokumentationen von Testdurchläufen zu erstellen. Hierzu wird einfach der Problem Steps Recorder über den Befehl PSR gestartet.

Nach einem Klick auf Start Record werden nun die Benutzeraktionen aufgezeichnet. Heraus kommt dann ungefähr so etwas:

Problem Step 15: User left double click on "Name (editable text)" in "WorkItem_Manager_Open_1.0.0_Installer[1]"

Previous Next

Problem Step 16: User left click on "Run (push button)" in "Open File - Security Warning"

Previous Next

Problem Step 17: User left click on "Next > (push button)" in "artiso Workitem Manager Open"

Diese Aufzeichnungen funktionieren sowohl mit Web- als auch Windows-Anwendungen. Und natürlich können die erzeugten MHT-Files in Word oder anderen Editoren noch bearbeitet werden. So können z.B. überflüssige Zwischenschritte entfernt und Texte editiert werden. Es können auch währen des Aufzeichnungsvorgangs Kommentare erfasst und diesen ein bestimmter Bildausschnitt zugeordnet werden.

Grade erst wurden die EMEA-Meetings der Team System User Group Virtual Edition ins Leben gerufen, schon können wir mit einem Highlight aufwarten. Für unser April-Meeting konnten wir Brian Harry als Sprecher gewinnen. Brian wird über die Internal Adoption von VSTS sprechen. Brian ist Technical Fellow und Manager der Product Unit für den team Foundation Server.

Also gleich als Mitglied registrieren und am 16. April dabei sein!

Weitere Informationen zum Meeting gibt’s unter www.tsug-ve.com.

Der Tatsache, dass Testen eine wichtige Bedeutung in der Software-Entwicklung hat, trägt Microsoft ja bereits seit einiger Zeit Rechnung indem eine spezielle Edition des Visual Studio für Tester generiert wurde. Diese Edition besitzt umfangreiche Funktionenzu verschiedenen Test-Methoden. Das Ranger-Team hat nun einen Quick Reference Guide veröffentlicht der auf 83 Seiten diese Funktionen beschreibt und verschiedene Best Practices anbietet. Hierbei sind die Erfahrungen eingeflossen, die Service Labs, ein großes Test-Center, bei der Adaption von Team Test gemacht hat. Das Dokument enthält viele wertvolle Hinweise, wie VSTT in der Praxis eingesetzt und individuell erweitert werden kann.

Definitiv lesenswert für jeden, der etwas mehr über dieses Toolset erfahren möchte.

Download VSTT 2008 Quick Reference Guide

Das Thema Test Driven Development oder auch Test First Developent gewinnt immer mehr an Beachtung. Keine Konferenz, keine Zeitschrift, kein Sprecher der was auf sich hält kommt um das Thema herum. Doch nach dem überzeugenden Vortrag sitzt man zu Hause im Büro vor einem leeren Project und wie nun anfangen? Hier scheitern bereits die ersten, weil entsprechende Publikationen oft zwar die Vorteile ausführlich schildern, aber nicht den Einstieg darstellen. Deshalb möchte ich hier einen entsprechenden Einstieg geben und mit einem wirklich leeren Projekt beginnen.

Die Theorie um TDD will ich hier einfach weglassen. Hierzu gibt es bereits Informationen genug. Und wir werden verschiedene Vereinfachung vornehmen, über die Profis etwas die Nase rümpfen werden, aber damit erhalten wir ein einfaches und praktikable Einstiegsszenario.

Zum Einsatz kommen hierbei die Testfunktionen von Visual Studio 2008 die ab der Professional Edition enthalten sind. Wir beginnen mit einer komplett leeren Solution.

Die Frage, die nun im Raum steht, ist: Wie schreibe ich einen Test ohne eine Methode zu haben. Ein Unit-Test besteht ja im Prinzip darin, dass wir eine Methode aufrufen und den Rückgabewert mit einem Erwartungswert vergleichen. Der Test wird aber nicht einmal kompilieren, solange die Methode nicht definiert ist. Der Workaround an dieser Stelle sieht dann oft so aus, dass man von der Methode und ihrer Klasse erst einmal einen Stub anlegt der im wesentlichen eine “ThrowNotImplemented”-Exception wirft. Damit haben wir aber eigentlich schon mehr implementiert als nach dem TDD uns lieb ist.

Ein etwas eleganterer Ansatz geht über die Definition von Interfaces. Diese Vorgehensweise eignet sich besonders gut bei einer komponentenorientierten Architektur mit einem Contract First Ansatz. Dabei werden die Schnittstellen der einzelnen Komponenten erst über Contracts (Interfaces) beschrieben bevor diese implementiert werden. Den TDD-Ablauf Rot > Grün > Refactor erweitern wir ein wenig. Damit ergibt sich folgende Abfolge:

Contract definieren > Test implementieren > Rot > Funktion implementieren > Grün > Refactor

D.h. wir erstellen in einem ersten Schritt einen Contract (genau genommen machen wir damit kein TDD sondern ein Test First. Beim TDD ist der Test das erste was erstellt werden muss, aber das ist in meinen Augen eher Haarspalterei, so funktioniert es einfach in der Praxis). Wir erstellen ein neues ClassLibrary-Projekt und erstellen dort ein Interface.

               1:
              namespace Contracts

               2: {

               3:
              public
              interface IOrderCalculator

               4: {

               5:
              decimal CalculateShippinghCosts(decimal sum, decimal freeShippingMin, decimal shippingCosts);

               6: }

               7: }

Wir wollen hier ein überschaubares, aber auch nicht zu triviales Beispiel verwenden. Die Methode CalculateShippingCosts soll zu einem gegebenen Rechnungsbetrag Versandkosten hinzuaddieren, wenn ein bestimmter Mindestbetrag nicht erreicht ist. So damit haben wir den Contract erstellt. Nun wollen wir einen Test dazu erstellen. Das geht am schnellsten durch einen Rechts-Klick auf die Methode und dann “Create Unit-Tests”.

Hier wird standardmäßig ein neues Test-Projekt angelegt. Darin wird ein entsprechender Unit-Test generiert.

               1: [TestMethod()]

               2:
              public
              void CalculateShippinghCostsTest()

               3: {

               4: IOrderCalculator
target = CreateIOrderCalculator(); // TODO: Initialize
to an appropriate value

               5: Decimal
sum = new Decimal(); //
TODO: Initialize to an appropriate value

               6: Decimal
freeShippingMin = new Decimal(); //
TODO: Initialize to an appropriate value

               7: Decimal
shippingCosts = new Decimal(); //
TODO: Initialize to an appropriate value

               8: Decimal
expected = new Decimal(); //
TODO: Initialize to an appropriate value

               9: Decimal
actual;

               10: actual
= target.CalculateShippinghCosts(sum, freeShippingMin, shippingCosts);

               11: Assert.AreEqual(expected,
actual);

               12: Assert.Inconclusive("Verify
the correctness of this test method.");

               13: }

Damit können wir den Test bereits zum ersten mal ausführen und er geht wie erwartet auf Rot. Aber Moment, wie funktioniert das. Wie kann der Test eine Methode auf einem Interface aufrufen? Es gibt ja noch keine Implementierung des Interfaces und ein Interface selbst lässt sich ja nicht instanziieren. Hier baut Visual Studio einen kleinen Workaround. In Zeile 4 im obigen Code sieht man, dass eine Instanz des target-Objektes über die Methode CreateIOrderCalculator() erstellt wird. Diese Methode wollen wir mal etwas genauer anschauen.

               1:
              internal
              virtual IOrderCalculator
CreateIOrderCalculator()

               2: {

               3:
              //
TODO: Instantiate an appropriate concrete class.
            

               4: IOrderCalculator
target = null;

               5:
              return target;

               6: }

Hier wird das Objekt einfach mit null initialisiert. Ein einfacher, aber wirkungsvoller Workaround. Damit erreichen wir unser Ziel, dass der Test kompiliert aber fehlschlägt. Nach der Implementierung ersetzen wir das null einfach durch die entsprechende Initialisierung. Damit können wir nun unsere Testcases Implementieren.

               1: [TestMethod()]

               2:
              public
              void CalculateShippinghCosts_Sum_Below_FreeShippingMin()

               3: {

               4: IOrderCalculator
target = CreateIOrderCalculator();

               5: Decimal
sum = 1;

               6: Decimal
freeShippingMin = 10;

               7: Decimal
shippingCosts = 5;

               8:
              //
We are below min, so we have to add shippingCosts
            

               9: Decimal
expected = 6;

               10: Decimal
actual;

               11: actual
= target.CalculateShippinghCosts(sum, freeShippingMin, shippingCosts);

               12: Assert.AreEqual(expected,
actual);

               13: }

               14:  

               15: [TestMethod()]

               16:
              public
              void CalculateShippinghCosts_Sum_Above_FreeShippingMin()

               17: {

               18: IOrderCalculator
target = CreateIOrderCalculator();

               19: Decimal
sum = 20;

               20: Decimal
freeShippingMin = 10;

               21: Decimal
shippingCosts = 5;

               22:
              //
We are above min, so we don't add shippingCosts
            

               23: Decimal
expected = 20;

               24: Decimal
actual;

               25: actual
= target.CalculateShippinghCosts(sum, freeShippingMin, shippingCosts);

               26: Assert.AreEqual(expected,
actual);

               27: }

               28:  

               29: [TestMethod()]

               30:
              public
              void CalculateShippinghCosts_Sum_Equal_FreeShippingMin()

               31: {

               32: IOrderCalculator
target = CreateIOrderCalculator();

               33: Decimal
sum = 10;

               34: Decimal
freeShippingMin = 10;

               35: Decimal
shippingCosts = 5;

               36:
              //
We are equal min, so we don't add shippingCosts
            

               37: Decimal
expected = 10;

               38: Decimal
actual;

               39: actual
= target.CalculateShippinghCosts(sum, freeShippingMin, shippingCosts);

               40: Assert.AreEqual(expected,
actual);

               41: }

Damit haben wir unser Szenario ausreichend beschrieben. Wir können nun an die Implementierung gehen.Dazu legen wir ein neues Projekt an in dem wir eine Klasse definieren die wir von unserem Interface ableiten.

               1:
              namespace Components

               2: {

               3:
              public
              class cOrderCalculator
: IOrderCalculator

               4: {

               5:
              public
              decimal CalculateShippinghCosts(decimal sum, decimal freeShippingMin, decimal shippingCosts)

               6: {

               7:
              //
If sum is greater than Min then don't add shipping costs
            

               8:
              if (sum
> freeShippingMin)

               9:
              return sum;

               10:
              else
            

               11:
              //
else add shipping costs
            

               12:
              return sum
+ shippingCosts;

               13: }

               14: }

               15: }

Nun müssen wir unbedingt noch daran denken, die Initialisierung des Testobjektes in unserer Testmethode anzupassen.

               1:
              internal
              virtual IOrderCalculator
CreateIOrderCalculator()

               2: {

               3: IOrderCalculator
target = new cOrderCalculator();

               4:
              return target;

               5: }

Nun können wir die Tests ausführen.

Oh, ein Test schlägt fehl. Bei genauerer Betrachtung stellen wir fest, dass wir bei der Implementierung den Fall dass die Summe gleich der Grenze ist nicht richtig berücksichtigt haben. Also hat sich hier der TDD-Ansatz schon bewährt und wir können den Fehler beheben. Damit sind alle Tests grün und wir können weiter fortfahren. Wir könnten nun z.B. auf unserem Interface weitere Methoden definieren und dafür Tests anlegen.

Also eigentlich gar nicht so schwer das mit dem TDD, oder? Freue mich auf euer Feedback.

Die Solution gibt es zum Download.

Happy Testing!

Letzte Woche war ich als Trainer beim Team System Camp. Eine wirklich bemerkenswerte Veranstaltung! Schon der Veranstaltungsort selbst war bemerkenswert. Das Häckers Kurhotel in Bad Ems stellte einen durchaus würdigen Rahmen für die Veranstaltung dar und auch der Seminarraum hatte durchaus Stil:

Die Verpflegung war dem Ambiente angemessen, Mittags und Abends ein vorzügliches 3-Gänge-Menü und auch das Rahmenprogramm passte. Mit Kart-Fahren, Casino-Besuch und weiteren Aktivitäten konnte ein paar Momente entspannt werden. Das war auch dringend nötig. Denn trotz all dieser Annehmlichkeiten kamen natürlich die Inhalte nicht zu kurz. Zwei Trainer auf 5 Teilnehmer ist sicher schon ein ungewöhnlicher Schnitt. Aber dass die Trainings von 9:00 Uhr bis 23:00 gehen ist schon heftig. Also wurde nach dem Kart-Fahren noch was gegessen und dann ging’s im Seminar-Raum weiter. So konnten die Teilnehmer sicher einen sehr guten Überblick über den Team Foundation Server und VSTS bekommen. Und durch die kleine Gruppengröße konnte auch auf individuelle Fragen ausführlich eingegangen werden.

Mir hat’s jedenfalls viel Spaß gemacht und bin beim nächsten mal gerne wieder dabei.

Die Integration von Visual Studio 2005 / 2008 mit dem TFS ist ideal gelöst. Jedoch gibt es auch noch andere Entwicklungs-Plattformen die keine direkte Integration mit dem Team-Explorer erlauben wie z.B. ältere Visual Studio Versionen und leider auch immer noch das SQl Server Management Studio. Diese IDEs überstützen doch recht häufig den sog. MSSCCI-Standard und es gibt bereits seit längerer Zeit einen entsprechenden MSSCCI-Provider für den TFS 2008. Dieser hatte bisher immer noch den nachteil, dass er reine Sourcecontrol Features unterstützt hat und z.B. das Verknüpfen von Workitems beim Checkin nicht möglich war. In der neuesten Version ist dies nun auch möglich und somit ist auch bei IDEs die den Team Explorer nicht integrieren ein komfortables Arbeiten mit dem TFS möglich. Ich habe hier mal ein Beispiel für das SSMS 2008.

Zunächst muss der TFS MSSCCI-Provider unter Optionen eingestellt werden.

Legt man nun ein Datenbankprojekt an, dann kann man das in gewohnter Art und Weise mit der Source Control verbinden und man erhält Fenster “Pending Checkins”.

Führt man hier nun den Checkin aus, kommt der aus dem Team-Explorer bekannte Dialog

Hier können nun z.B. Checkin-Kommentare angegeben oder Workitems verknüpft werden.

Sogar die Checkin-Plicies funktionieren hier wie gewohnt.

Damit ist ein komfortables und problemloses Arbeiten auch mit solchen Umgebungen möglich, die den Team-Explorer nicht direkt integrieren. Und damit wieder ein Grund mehr, nun endlich auf den TFS zu setzen und SourceSafe und Konsorten endlich in Rente zu schicken.

Bei der Team System Usergroup – Virtual Edition (TSUG-VE) handelt es sich um eine weltweite Online-Community die sich auf die Themen Visual Studio Team System und Team Foundation Server konzentriert hat. Die Treffen finden dabei zeitgleich in SecondLife und LiveMeeting statt. SecondLife bietet den Vorteil, die sozialen Aspekte einer Community besser in der Online-Welt abzubilden, LiveMeeting wird als Präsentationssystem genutzt. Die virtuellen Treffen unterscheiden sich vom Ablauf und Inhalt kaum von denen entsprechender Offline-Communities. Während und nach den Vorträgen können ganz normal Fragen gestellt werden. Die Vorträge werden aufgezeichnet und stehen Mitgliedern im nachhinein im LiveMeeting-Portal zur Verfügung.

Um die Vortragszeiten für die Teilnehmer rund um den Globus komfortabler zu gestalten, wurde nun eine europäische Sektion der TSUG-VE ins Leben gerufen. Diese Sektion organisiert Meetings in einer komfortablen Zeit für die EMEA-Zone (19:00 Uhr deutscher Zeit). Natürlich steht den Mitgliedern jederzeit die Möglichkeit offen, an den Treffen der US-Sektion oder für den Bereich Asian-Pacific (momentan im Aufbau) teilnehmen zu können oder die Videos nachträglich abzurufen ohne sich hierfür separat registrieren zu müssen. Alle Treffen werden in englischer Sprache abgehalten.

Die Leitung der EMEA-Zone habe ich übernommen und würde mich freuen, in Zukunft mehr Mitglieder aus dem Europa begrüßen zu dürfen. Kritik und Anregungen zur Organisation sind sehr willkommen, da wir im Moment noch dabei sind Erfahrungen im Betreiben einer Online-Community sammeln.

VISfire sit eine Charting-Komponente für Silverlight und WPF. Das coole daran ist, dass die Charts animiert werden können.  Einen schnellen Eindruck bekommnt man über die Silverlight Chart Gallery. Die componente ist unter GPL und einer kommerziellen Lizenz verfügbar.

Wie so oft lautet die Antwort es kommt darauf an. Un hier bietet die Seite ShineDraw eine gute Vergleichsmöglichkeit. In der Gallery befinden sich zahlreiche Beispiele die sowohl in Silverlight als auch in Flash implementiert sind. Da kann man nicht nur das Ergebnis in beiden Varianten vergleichen sondern auch den Code der in der jeweiligen Technologie erforderlich ist. Darüber hinaus kann man sich den einen oder anderen effekt abschauen und sieht auch gleich wie der implementiert wird. Der Quellcode ist unter der GNU General Public License, Version 3 bereitgestelt.

http://www.shinedraw.com/flash-vs-silverlight-gallery/

Die Initiative Clean Code Developer (CCD) (http://www.clean-code-developer.de/) hat sich zum Ziel gesetzt bestimmte Grundsätze bei der Entwicklung von Software bei den Entwicklern besser zu verankern. Bei diesen Grundsätzen handelt es sich um Prinzipien, Regeln und Praktiken deren Einhaltung zu qualitativ höherwertigem Code führt. Grundsätzlich ist eine Schrittweise Einführung dieser Prinzipien, regeln und Praktiken unterteilt in Grade vorgesehen. Zu jedem Grad gibt es ein farbiges Armband, das den Träger zum Einen als CCD ausweist und ihn zudem stets daran erinnert diese Grundsätze in seiner täglichen Arbeit zu befolgfen. Mit Sefan Lieser und Ralf Westphal stehen hinter diesem Projekt zwei ausgewiesene Experten.

Die .Net Developer-Group Ulm (www.dotnet-ulm.de) möchte diese Aktion unterstützen und ruft seine Mitglieder auf sich zu beteiligen. Beim nächsten Treffen am 19.03.09 wird diese Aktion im Detail vorgestellt und es besteht die Möglichkeit die Armbänder zu einem vergünstigten Preis zu erwerben. Zudem ist angedacht, dass sich die beteiligten regelmäßig nach den UG-Meetings austauschen und gegenseitig über Erfahrungen berichten und die Konzepte des CCD miteinander diskutieren.

Natürlich freue ich mich auf eine rege Teilnahme und natürlich sind Gäste gerne willkommen.

Nähere Infos unter http://www.dotnet-ulm.de/Cleancodedeveloper.aspx

Mit diesem Sidebar-Gadget kann man sich den Status seiner Build schnell und einfach anzeigen lassen.

Jim Lamb : Team Build Monitor – Vista Sidebar Gadget

Bei unserem nächsten Treffen am 19.03 haben wir Gregor Biswanger und Robert Walter zu Gast. Diese werden in ihrem Vortrag verschiedene Aspekte zu Test Driven Development beleuchten. Nähere Infos gibts hier:

http://www.dotnet-ulm.de/Treffen.aspx#19032009

Am 16.03.09 geht ein neuer Webcast von mir online mit dem Thema "Team Build mit Custom Build Tasks erweitern". Ich möchte hier schon mal die entsprechenden Infos veröffentlichen.

In TeamBuild lassen sich eigene Build-Task integrieren. Diese können sehr einfach erstellt werden. Hierzu wird eine Klasse erstellt und diese von Task abgeleitet. Im folgenden Beispiel wird ein Build-Task erstellt, der im Rahmen des Builds die Version der Anwendung setzt. Und zwar soll hier die Build-Nummer in der Versionsnummer der Assembly abgebildet werden. Dies bietet Vorteile, wenn zu einer bestimmten Anwendungsversion der entsprechende Build identifiziert werden soll.

               1:
              using System;

               2:
              using System.Collections.Generic;

               3:
              using System.Text;

               4:
              using Microsoft.Build.Utilities;

               5:
              using Microsoft.Build.Framework;

               6:  

               7:
              namespace Artiso.BuildTasks

               8: {

               9:
              ///
<summary>
            

               10:
              ///
Creates a AssemblyVersion out of a BuildNumber
            

               11:
              ///
</summary>
            

               12:
              ///
<remarks>
            

               13:
              ///
AssemblyVersion.Minjor and AssemblyVersion.Minor will be defined fiexed in
            

               14:
              ///
the Build-Script. If the BuildNumber is Dev_Versioning_20090305.4 we use 
            

               15:
              ///
two digit year and month for AssemblyBuildNumber and day and 3 digit BuildRevision
            

               16:
              ///
for AssemblyRevision. BuildRevisio 
            

               17:
              ///
</remarks>
            

               18:
              ///
<example>
            

               19:
              ///
Dev_Versioning_20090305.4 => xx.yy.0903.05004
            

               20:
              ///
</example>
            

               21:
              public
              class ExtractRevision
: Task

               22: {

               23:
              #region [rgn]
Fields(3)

               24:
              private
              string buildRevision;

               25:
              private
              string buildVersion;

               26:
              private
              string buildNumber;

               27:
              #endregion
            

               28:  

               29:
              #region [rgn]
Properties(3)

               30:
              ///
<summary>
            

               31:
              ///
Input Build Number
            

               32:
              ///
</summary>
            

               33: [Required]

               34:
              public
              string BuildNumber

               35: {

               36: set
{ buildNumber = value; }

               37: }

               38:  

               39:
              ///
<summary>
            

               40:
              ///
Returns the sortened date of the build
            

               41:
              ///
</summary>
            

               42: [Output]

               43:
              public
              string BuildVersion

               44: {

               45: get
{ return buildVersion; }

               46: }

               47:  

               48:
              ///
<summary>
            

               49:
              ///
Returns the Build Revision (number of build at this day
            

               50:
              ///
</summary>
            

               51: [Output]

               52:
              public
              string BuildRevision

               53: {

               54: get
{ return buildRevision; }

               55: }

               56:
              #endregion
            

               57:  

               58:
              #region [rgn]
Methods(1)

               59:
              public
              override
              bool Execute()

               60: {

               61: buildVersion
= "0";

               62: buildRevision
= "0";

               63:  

               64:
              if (buildNumber
!= null && buildNumber.Contains("."))

               65: {

               66:
              string[]
buildNumberParts = buildNumber.Substring(buildNumber.LastIndexOf('_')+1).Split('.');

               67:  

               68:
              //
Dev_Versioning_20090305.4 -> 0903.02005
            

               69:
              //
use year (2 digits) and mont for buildversion
            

               70: buildVersion
= buildNumberParts[0].Substring(2, 4);

               71:  

               72:
              //
use day and number of build in this day for build revision
            

               73: buildRevision
= buildNumberParts[0].Substring(6) + buildNumberParts[1].PadLeft(3, '0');

               74: }

               75:
              return
              true;

               76: }

               77:
              #endregion
            

               78: }

               79: }

Das Property BuildNumber wird als Input-Parameter verwendet und mit dem Attribut [Required] versehen. Darüber kann die BuildNumber in unseren Task übergeben werden. Durch das Attribut [Output] werden die beiden Properties BuildVersion und BuildRevision als Rückgabewerte definiert. Beim Ausführen des Builds wird die Methode Execute aufgerufen. Hier werden nun aus der Build-Number die entsprechenden Informationen extrahiert und diese dann in BuildVersion und BuildRevision zurückgeschrieben. Dies ist natürlich nur ein einfaches Beispiel, aber mit diesen Grundlagen können nun beliebige Build-Tasks definiert werden. Im nächsten Schritt schauen wir uns an, wie wir diesen Custom Build Task nun in unseren Build-Prozess einbinden. Hierzu kopieren wir zunächst die Assembly in einen entsprechenden Ordner. Hier bietet sich an unter c:\Program Files\MSBuild einen entsprechenden Ordner anzulegen und dort die Assemblies abzulegen.

Nun muss das Build-Script entsprechend angepasst werden. Diese liegt in der Quellcode-Verwaltung und muss zum Bearbeiten zuerst aus- und danach wieder eingechecked werden. Um diesen Vorgang zu vereinfachen empfehle ich die TFS Sidekicks (http://www.attrice.info/downloads/index.htm) die direkt im Kontextmenü des TeamExplorers entsprechende Kommandos einfügt. Das nun ausgecheckte PROJ-File kann nun bearbeitet werden.

               1:
              <?
              xml
              version
              ="1.0"
              encoding
              ="utf-8"?>

               2:
              <!--
DO NOT EDIT the project element - the ToolsVersion specified here does not prevent
the solutions 
            

               3:
               and
projects in the SolutionToBuild item group from targeting other versions of the .NET
framework. 
            

               4:
               -->
            

               5:
              <
              Project
              DefaultTargets
              ="DesktopBuild"
              xmlns
              ="http://schemas.microsoft.com/developer/msbuild/2003"
              ToolsVersion
              ="3.5"
              >
            

               6:  

               7:
              <!--
Do not edit this -->
            

               8:
              <
              Import
              Project
              ="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\TeamBuild\Microsoft.TeamFoundation.Build.targets"
              />
            

               9:
              <
              Import
              Project
              ="$(MSBuildExtensionsPath)\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets"
              />
            

               10:  

               11:
              <
              UsingTask
              AssemblyFile
              ="$(MSBuildExtensionsPath)\ArtisoBuildTasks\ArtisoBuildTasks.dll"
            

               12:
              TaskName
              ="ExtractRevision"
              />
            

               13:  

               14:
              <
              PropertyGroup
              >
            

               15:
              <!--
Assembly version properties. Adjust here Major and Minor Version-->
            

               16:
              <
              AssemblyMajorVersion
              >1</AssemblyMajorVersion>

               17:
              <
              AssemblyMinorVersion
              >3</AssemblyMinorVersion>

               18:
              <
              AssemblyBuildNumber
              >1</AssemblyBuildNumber>

               19:
              <
              AssemblyRevision
              >1</AssemblyRevision>

               20:
              </
              PropertyGroup
              >
            

               21:  

               1: ...

               2:
              <
              Target
              Name
              ="AfterGet"
              >
            

               3:
              <
              ItemGroup
              >
            

               4:
              <
              AssemblyInfoFiles
              Include
              ="$(SolutionRoot)\**\assemblyinfo.cs"
              />
            

               5:
              </
              ItemGroup
              >
            

               6:  

               7:
              <
              Message
              Text
              ="Get
Revision Number from BuildNumber &quot;$(BuildNumber)&quot;."
              />
            

               8:
              <
              ExtractRevision
              BuildNumber
              ="$(BuildNumber)"
              >
            

               9:
              <
              Output
              TaskParameter
              ="BuildRevision"
            

               10:
              PropertyName
              ="AssemblyRevision"
              />
            

               11:
              <
              Output
              TaskParameter
              ="BuildVersion"
            

               12:
              PropertyName
              ="AssemblyBuildNumber"
              />
            

               13:
              </
              ExtractRevision
              >
            

               14:  

               15:
              <!--
Update all the assembly info files with generated version info -->
            

               16:
              <
              Message
              Text
              ="Modifying
AssemblyInfo files under &quot;$(SolutionRoot)&quot;."
              />
            

               17:
              <
              Attrib
              Files
              ="@(AssemblyInfoFiles)"
              Normal
              ="true"
              />
            

               18:
              <
              FileUpdate
              Files
              ="@(AssemblyInfoFiles)"
            

               19:
              Regex
              ="AssemblyVersion\(".*"\)\]"
            

               20:
              ReplacementText
              ="AssemblyVersion("$(AssemblyMajorVersion).$(AssemblyMinorVersion).$(AssemblyBuildNumber).$(AssemblyRevision)")]"
              />
            

               21:
              <
              FileUpdate
              Files
              ="@(AssemblyInfoFiles)"
            

               22:
              Regex
              ="AssemblyFileVersion\(".*"\)\]"
            

               23:
              ReplacementText
              ="AssemblyFileVersion("$(AssemblyMajorVersion).$(AssemblyMinorVersion).$(AssemblyBuildNumber).$(AssemblyRevision)")]"
              />
            

               24:
              <
              Message
              Text
              ="AssemblyInfo
files updated to version &quot;$(AssemblyMajorVersion).$(AssemblyMinorVersion).$(AssemblyBuildNumber).$(AssemblyRevision)&quot;"
              />
            

               25:
              </
              Target
              >
            

               26:  

               27:
              </
              Project
              >
            

           1:
          <
          Target
          Name
          ="AfterCompile"
          >
        

               2:
              <
              CreateItem
              Include
              ="..\Binaries\Release\**\*.*"
              Exclude
              ="..\Binaries\Release\**\*.pdb;..\Binaries\Release\**\*codeanalysis*"
              >
            

               3:
              <
              Output
              ItemName
              ="ZipFiles"
              TaskParameter
              ="Include"
              />
            

               4:
              </
              CreateItem
              >
            

               5:  

               6:
              <
              Message
              Text
              ="Zipping
Buildresult to \\tfs\deploy\BuildDemo\BuildDemo_$(AssemblyMajorVersion).$(AssemblyMinorVersion).$(AssemblyBuildNumber).$(AssemblyRevision).zip"
              />
            

               7:  

               8:
              <
              Zip
              ZipFileName
              ="\\tfs\deploy\BuildDemo\BuildDemo_$(AssemblyMajorVersion).$(AssemblyMinorVersion).$(AssemblyBuildNumber).$(AssemblyRevision).zip"
            

               9:
              Files
              ="@(ZipFiles)"
            

               10:
              WorkingDirectory
              ="..\Binaries\Release\"
              />
            

               11:  

               12:
              <
              Mail
              SmtpServer
              ="tfs"
            

               13:
              To
              ="tschissler@tfs"
            

               14:
              From
              ="build@tfs"
            

               15:
              Subject
              ="BuildDemo
v$(AssemblyMajorVersion).$(AssemblyMinorVersion).$(AssemblyBuildNumber).$(AssemblyRevision)
released"
            

               16:
              Body
              ="A
new version of the BuildDemo was released. Please find the newest files attached to
this mail. You can also download them from the download folder."
            

               17:
              Attachments
              ="\\tfs\deploy\BuildDemo\BuildDemo_$(AssemblyMajorVersion).$(AssemblyMinorVersion).$(AssemblyBuildNumber).$(AssemblyRevision).zip"
              />
            

               18:
              </
              Target
              >
            

Hier sammeln zunächst alle Dateien aus dem Build-Drop-Verzeichnis exklusive der PDB- und Codeanalyse-Dateien In Zeilen 8-10 werden diese Dateien in ein ZIP-File verpackt dem wir im datei-Name die Version mitgeben. Anschließend versenden wir eine e-Mail der wir dieses ZIP-File als Attachment anhängen.

Als zweite Variante wollen wir im Rahmen des Builds ein Click-Once Paket erstellen. Die Herausforderung bei der Erstellung des ClickOnce-Paketes ist dass dort die Deployment-Url hinterlegt werden muss. Vor allem wenn verschiedene Pakete für unterschiedliche Kunden erstellt werden sollen, ist dies nur durch eine Automatisierung im Rahmen des Builds sinnvoll handelbar. Hierzu ersetzen wir den AfterCompile-Target durch folgendes Script:

               1:
              <
              Target
              Name
              ="AfterCompile"
              >
            

               2:
              <!--
Publish using ClickOnce -->
            

               3:
              <
              Message
              Text
              ="modify
Publish directory for $(SolutionRoot)"
              />
            

               4:
              <!--
Update directory where to publish the project -->
            

               5:
              <
              ItemGroup
              >
            

               6:
              <
              ProjectFiles
              Include
              ="$(SolutionRoot)\Source\Dev\BuildDemo\BuildDemo.csproj"
              />
            

               7:
              </
              ItemGroup
              >
            

               8:
              <
              PropertyGroup
              >
            

               9:
              <
              PublishDir
              >\\tfs\Deploy\BuildDemo\ClickOnce\</PublishDir>

               10:
              <
              InstallUrl
              >\\tfs\Deploy\BuildDemo\ClickOnce\</InstallUrl>

               11:
              </
              PropertyGroup
              >
            

               12:
              <
              Attrib
              Files
              ="@(ProjectFiles)"
              Normal
              ="true"
              />
            

               13:
              <
              FileUpdate
              Files
              ="@(ProjectFiles)"
            

               14:      Regex="<PublishUrl>.*</PublishUrl>"

               15:
              ReplacementText
              ="<PublishUrl>$(PublishDir)</PublishUrl>"
              />
            

               16:
              <
              FileUpdate
              Files
              ="@(ProjectFiles)"
            

               17:
              Regex
              ="<InstallUrl>.*</InstallUrl>"
            

               18:
              ReplacementText
              ="<InstallUrl>$(InstallURL)</InstallUrl>"
              />
            

               19:  

               20:
              <
              MSBuild
              Projects
              ="@(ProjectFiles)"
            

               21:
              Properties
              ="PublishDir=$(PublishDir);ApplicationVersion=$(AssemblyMajorVersion).$(AssemblyMinorVersion).$(AssemblyBuildNumber).$(AssemblyRevision)"
            

               22:
              Targets
              ="Publish"
              />
            

               23:  

               24:
              </
              Target
              >
            

In den Zeilen 5 bis 7 lesen wir das csproj-File der Anwendung in eine ItemGroup. Anschließend definieren wir zwei Properties für PublishDir und InstallUrl. Diese werden dann über eine Ersetzung in die csproj-Datei eingefügt. Anschließend wird ein MSBuild-Task gestartet der das ClickOnce-Paket erstellt und an der angegebenen PublishDir und mit der Versionsnummer veröffentlicht.

Das Ganze wird in dem genannten Webcast Live demonstriert. Über Feedback würde ich mich sehr freuen.

Details zur Veranstaltung: Team Build mit Custom Build Tasks erweitern [1032405249] - Microsoft Deutschland GmbH

After logging in, be sure to visit all the options under Configuration in the Admin Menu Bar above. There are 26 themes to choose from, and you can also create your own.