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 
    LEFT JOIN
(SELECT
     lt.ID
    ,lt.Rev
    ,lt.Words
FROM 
(SELECT t1.* FROM 
dbo.WorkItemLongTexts t1
LEFT OUTER JOIN dbo.WorkItemLongTexts t2
ON t1.ID = t2.ID AND t1.Rev < t2.Rev
WHERE t2.id is NULL) lt
    INNER JOIN
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

Ich hatte im IE das Problem, dass sich das Download-Fenster nicht mehr öffnen ließ. Sowohl aus der Download-Leiste am unteren Fensterrand als auch über “View Downloads” ist einfach nichts passiert.

Das Problem ließ sich aber ganz einfach lösen (wenn man weiß wie’s geht ). Man muss nur die Download-History löschen.

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)

Für unseren SCRUMit-Event bei der .net Developer Group Ulm ist nun die Agenda finalisiert. Wer also Interesse am Thema Scrum hat, sollte unbedingt mal auf unserer Seite vorbeischauen und sich über den Event informieren. Für schlappe 20,—€ bekommt man hochwertige Informationen von hochkarätigen Sprechern.

Veranstaltungsdaten:

Agenda:

Hier noch die Links auf unserer Seite:

Agenda

Abstracts & Informationen zu den Referenten

Anmeldung zur Veranstaltung

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 = new CheckinCommentLengthConfigDialog())

    {

        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"?>
<Project xmlns="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"?>
<Project xmlns="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.

See english version below.

In Scrum ist eine zentrale Frage, wann ist eine User Story erledigt, also done? Dies wird durch die sog. “Definition of Done” festgelegt die sich das Team selbst gibt. Die Definition of Done beschreibt Aspekte die erfüllt sein müssen, damit eine Story als done gelten kann und somit im Review dem Product Owner präsentiert wird. Dies können beispielsweise Testausführung, Code-Reviews oder anderes sein. Genau festzuhalten, welche Punkte der DoD für eine User Story bereits erfüllt sind, ist Zweck des DoD Work Item Controls für den Team Foundation Server.

Am Ende des Posts gibt es einen Downloadlink für das Control. Im Folgenden wird kurz erklärt, wie das Control eingerichtet wird. Zuerst müssen wir ein Feld auf dem User Story Workitem Type anlegen.

<FieldDefinition refname="artiso.UserStory.DefinitionOfDoneState" name="Definition of Done State" type="Integer" />

Danach fügen wir für das Feld ein neues Control ein. Für das Control müssen verschiedene Einstellungen im Bereich CustomControlOptions vorgenommen werden:

• Zunächst geben wir im Attribut DoneState den Status an, auf den die User Story gesetzt werden soll wenn alle DoD Kriterienj erfüllt sind, also die User Story done ist.
• Unter ActiveState wird ein Status angegeben auf den die User Story gesetzt wird wenn von den vollständig gesetzten DoD Kriterien wieder eines entfernt wird, also z.B. wenn doch noch Bugs gefunden werden.
• Unter DoDCriteria werden nun die individuellen Kriterien der DoD angegeben. Jedes Kriterium braucht eine eindeutige ID. Aus den aktivierten Checkboxen wird durch eine 2er Potenz der ID eine Summe gebildet die im Integer-Feld abgelegt werden. Somit mit darauf geachtet werden, dass beim Ändern der ID die Aussage der bestehenden Work Items verändert wird.

<Control FieldName="artiso.UserStory.DefinitionOfDoneState" Type="DefinitionOfDoneControl" Label="Definition of Done:" LabelPosition="Top">
  <CustomControlOptions>
    <DoneState value="Done" />
    <ActiveState value="Implemented" />
    <DoDCriteria>
      <Criterion Text="All acceptance criteria of PO are fulfilled" ID="1" />
      <Criterion Text="Code Reviews are executed without findings" ID="2" />
      <Criterion Text="UI Reviews are executed without findings" ID="3" />
      <Criterion Text="All Test Cases are executed without findings" ID="4" />
      <Criterion Text="Test Cases are reviewed" ID="5" />
      <Criterion Text="No known bugs for this User Story" ID="6" />
      <Criterion Text="All Issues related to the User Story are closed" ID="7" />
    </DoDCriteria>
  </CustomControlOptions>
</Control>

Nun ist die Userstory einsatzbereit und alle im Team haben einen genauen Überblick, was noch zur Fertigstellung einer Story getan werden muss.

Das Control kann hier heruntergeladen werden.

English version

One of the big questions in a Scrum project is, when is a User Story “done”? This is defined by a so called “Definition of Done” which is defined by the team itself. The Definition of Done describes aspects which have to be fulfilled to declare a User Story to be done und so can be presented in the Sprint Review to the Product Owner. These aspects can be test execution, code reviews or other points. To track exactly which aspects of the DoD for a specific User Story is already fulfilled is the purpose of this Work Item Control for Team Foundation Server.

You’ll find a link to download the control at the end of this post. Here is described how to configure the control. First we have to define a field on the Work Item Type for the User Story to store the data.

<FieldDefinition refname="artiso.UserStory.DefinitionOfDoneState" name="Definition of Done State" type="Integer" />

Then we add for the new field a control to the form. For the control we have to do some settings in the CustomControlOptions:

• First we provide in the attribute DoneState the status to which the User Story will be set after fulfilling all DoD criterias (the Use Story is done)
• With ActiveState provide a state to which the User Story will be set after for a done User Story we uncheck one of the DoD criteria e.g. when later bugs are found
• With DoDCriteria you can provide individual criterias for your DoD. Every criteria needs a unique ID. From the checked checkboxes we create a sum with binary operations which will be stored to the integer field. So you should keep in mind that the meaning of your DoD status will be changed if you change the IDs.

<Control FieldName="artiso.UserStory.DefinitionOfDoneState" Type="DefinitionOfDoneControl" Label="Definition of Done:" LabelPosition="Top">
  <CustomControlOptions>
    <DoneState value="Done" />
    <ActiveState value="Implemented" />
    <DoDCriteria>
      <Criterion Text="All acceptance criteria of PO are fulfilled" ID="1" />
      <Criterion Text="Code Reviews are executed without findings" ID="2" />
      <Criterion Text="UI Reviews are executed without findings" ID="3" />
      <Criterion Text="All Test Cases are executed without findings" ID="4" />
      <Criterion Text="Test Cases are reviewed" ID="5" />
      <Criterion Text="No known bugs for this User Story" ID="6" />
      <Criterion Text="All Issues related to the User Story are closed" ID="7" />
    </DoDCriteria>
  </CustomControlOptions>
</Control>

Now the User Story is ready to use and everyone on the team has a good overview what is left to do to finish a Story.

The control can be downloaded here.

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.

Mit dem Team Foundation Build ist es einfach, Tests im Rahmen von automatisierten Builds auszuführen. Standardmäßig werden die Tests jedoch auf dem Buildrechner selbst ausgeführt. Das ist in verschiedenen Szenarien jedoch nicht erwünscht, sondern man möchte die Tests in einer Referenzumgebung ausführen die der Zielumgebung, in der die Anwendung ausgeführt werden soll, möglichst nahe kommt. Vor allem für GUI-Tests ist dieses Szenario wichtig.

Mit Visual Studio 2010 gibt es dafür LabManagement um virtualisierte Testumgebungen bereitzustellen und über ein vorbereitetes Build Template Tests darin auszuführen. Jedoch lässt sich diese Funktion auch ohne LabManagement erreichen, z.B. wenn ein anderes Virtualisierungssystem als Hyper-V oder rein physikalische Testumgebungen eingesetzt werden sollen. Im Folgenden soll beschrieben werden, wie dieses Szenario einzurichten ist.

Hierzu muss zunächst ein Testcontroller eingerichtet werden. Dieser kann beispielsweise auf dem TFS Server installiert werden. Auf der Testmaschine muss anschließend ein Testagent installiert und auf den Testcontroller registriert werden. Weitere Hinweise zur Installation und Konfiguration von Testcontrollern und –agents finden sie unter http://msdn.microsoft.com/de-de/library/dd648127.aspx. Es sollte beachtet werden, dass der Test Agent als interaktiver Prozess konfiguriert sein muss, wenn UI-Tests auf der Testmaschine ausgeführt werden sollen. Und der Testagent muss auf dem Testcontroller registriert  sein.

Der Testcontroller darf nicht für ein Teamprojekt registriert sein.

Anschließend können wir einen Build für das gewünschte Projekt einrichten. Der Build soll in unserem Szenario auf einem separaten Buildcomputer ausgeführt werden. Um das Deployment des Buildergebnisses auf die Testmaschine zu bewerkstelligen, passen wir das Buildtemplate ein wenig an. Dazu legen wir zunächst 2 neue Arguments an. Anschließend Platzieren wir unterhalb der „If BuildSettings.HasProjectToBuild“ Activity eine If-Condition auf der wir auf das Argument DeployForTest prüfen. Im Then-Zweig fügen wir dann eine CopyDirectory-Activity ein für die wir als Source die Droplocation und als Destination das Argument DeployForTestTarget einstellen. Damit wird unser Buildergebnis in dan Verzeichnis kopiert das wir in unserer Build Definition einstellen können.

Das BuildTemplate können wir nun unter einem neuen Namen speichern und einchecken. Auf dieser Basis erstellen wir nun mal einen ersten Build. In den Process Einstellungen definieren wir nun, dass das Deployment auf die Testmaschine ausgeführt werden soll und wir geben den UNC-Pfad an wohin die Dateien deployed werden sollen.

Nach dem Ausführen des Builds können wir prüfen, ob die Dateien korrekt auf die Testmaschine deployed wurden. Die Tests die wir in unserem Projekt haben werden allerdings immer noch auf unserer Buildmaschine ausgeführt. Um das zu ändern, müssen wir die Testsettings anpassen. Unter Test / Edit Test Settings  wählen wir zunächst Local aus um diese Einstellung anzupassen.

Hier müssen wir Remote Execution einstelle und den entsprechenden Build Controller auswählen. Diese Einstellungen können wir dann unter einem neuen Namen abspeichern und einchecken.

Anschließend wählen wir diese Test Settings in unserem Build aus.

Damit werden unsere Tests die wir in der Solution definiert haben nun auf unserer Testmaschine ausgeführt. Dies können sowohl Unit-Tests als auch Coded UI Tests sein. Als erweitertes Szenario können z.B. im Rahmen des Build Setups erstellt werden die dann über die CopyDirectory Activity auf die Testmaschine kopiert werden. Dann kann mit Hilfe eines Coded UI Tests das Setup ausgeführt und anschließend die Funktionen der Anwendung getestet werden.

Ein wichtiger Punkt ist noch, dass wir aktuell nicht kontrollieren können, auf welchem Testcomputer die Tests ausgeführt werden, wenn wir auf dem Testcontroller mehrere Agents registriert haben. Das wollen wir nun noch ändern. Dazu wählen wir unter Test / Manage Test Controllers unseren Testcontroller und den entsprechenden Agent aus.

Über Properties können wir dem Agent nun Attribute zuordnen, z.B. ein MachineName.

Nun können wir in unseren Testsettings einstellen auf welchem Agent unsere Tests ausgeführt werden sollen. Dazu fügen wir erst eine Rolle hinzu und wählen aus, dass auf dieser Rolle Tests ausgeführt werden können. Nun Geben wir das zuvor definierte Attribut mit dem selben Wert an.

Nun können wir eindeutig steuern, wo die Ausführung der Tests erfolgen soll und wir können beispielsweise mehrere Testcomputer mit verschiedenen Betriebssystemen zur Ausführung der Tests nutzen.

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(string value)

  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!