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

Der Team Foundation Server verwendet in den Versionen bis 2008 eine XML-Datei um den Build-Prozess zu steuern. Diese Datei wird Build Project File genannt und wird in der Versionsverwaltung abgelegt um vom Buildcomputer genutzt werden zu können. Jeder der diese Datei aber schon manuell bearbeitet hat, kennt das umständliche Vorgehen umd die Date erst aus der Quellcode-Verwaltung auszuchecken, und nach dem Bearbeiten wieder einzuchecken. Einfacher geht das mit den TFS Sidekicks, die direkt im Context-Menü des Team-Explorers eine Checkout und Checkin-Funktion für das Project-File anbietet.

Darüber hinaus bieten die TFS Sidekicks noch weitere sehr nützliche Funktionen, auf jeden Fall ist das Tool einen näheren Blick wert.

Attrice Corporation - Team Foundation Sidekicks

Der artiso Workitem Manager ist ein Tool mit dem sich Workitems hierarchisch organisieren lassen. Diese hierarchische Organisation bietet verschiedene Vorteile. Neben einer besseren Strukturierung und einer erhöhten Übersichtlichkeit vor allem auch eine visuelle Traceability. Damit ist gemein, dass durch die Hierarchie sichtbar wird welche Tests und Implementierungsaufgaben einem Feature zugeordnet sind. Die ist z.B. sehr hilfreich, wenn sich das Feature ändert zu erkennen, welche Workitems auf mögliche Auswirkungen überprüft werden können. Wie hierarchische Workitems in Projekten hilfreich eingesetzt werden, habe ich zusammen mit Christian Binder in diesem MSDN-Webcast erörtert.

Leider bringt der TFS in der Version 2008 diese Hierarchie nicht von Haus aus mit. Deshalb hat artiso den Workitem Manager entwickelt. Diesen gibt es nun auch als Open-Version. Die Open-Version ist kostenlos und wird auch als Source-Code bereitgestellt. Wie sich der Workitem Manager Open zur Vollversion unterscheidet kann man der unten stehenden Funktionsmatrix entnehmen. Weiter unten gibt's noch eine Screenshot.

Den Donload für das Setup und den Source-Code findet man unter http://www.alm-tools.de. Gerne freue ich mich über euer Feedback zu dem Tool.

Microsoft Research hat vor kurzer Zeit PEX zum freien Download veröffentlicht. Hinter diesem unscheinbaren Kürzel verbirgt sich ein Tool das absolut genial und beeindruckend ist und klar mach, warum Microsoft ein research center unterhält. Das Tool verspricht nichts weniger als die automatische Generierung von Unit-Tests und den dazugehörigen Testcases um eine möglichst hohe Code-Abdeckung zu erzielen. Detaillierte Informationen bietet das Whitepaper, wer sich auf die schnelle einen Einblick verschaffen möchte findet einen Überblick im Folgenden (na ja, für einen Überblick ist der Post vielleicht doch ein wenig lang geraden, aber ich konnte mich nicht bremsen vor Begeisterung):

Darf ich vorstellen - PEX

Gegeben sei folgende Methode die getestet werden soll:

               1:
              public
              string SimpleTest(int x1, int x2)

               2: {

               3:
              if (x1
> x2)

               4:
              return
              "x1
> x2";

               5:
              if (x1
< x2)

               6:
              return
              "x1
< x2"; 

               7:
              else
            

               8:
              return
              "x1
== x2";

               9: }

Für das versierte Auge eines Entwicklers ist sofort klar, da brauchen wir 3 Testcases um eine vollständige Code-Abdeckung zu erzielen. Mal sehen, was PEX daraus macht. Zunächst mal muss PEX heruntergeladen und installiert sein.  Dann kann man einfach einen "Parameterized Unit Test Stub" erzeugen. Dazu in der Methode rechts klicken und den Befehl aus dem Pex-Menü auswählen.

Im folgenden Dialog können Sie verschiedene Parameter angeben. Das wichtigste hier ist das Testprojekt in dem der Stub erzeugt werden soll.

Der erzeugte Stub sieht dann so aus:

               1:
              ///
<summary>
            

               2:
              ///
This class contains parameterized unit tests for Calculation
            

               3:
              ///
</summary>
            

               4: [TestClass]

               5: [PexClass(typeof(Calculation))]

               6:
              public
              partial
              class CalculationTest

               7: {

               8: [PexMethod]

               9:
              public
              string SimpleTest(

               10: [PexAssumeUnderTest]Calculation
target,

               11:
              int x1,

               12:
              int x2

               13: )

               14: {

               15:
              string result
= target.SimpleTest(x1, x2);

               16:
              return result;

               17:
              //
TODO: add assertions to method CalculationTest.SimpleTest(Calculation, Int32, Int32)
            

               18: }

               19:
            

               20: }

Bei diesem Stub handelt es such um eine Vorlage für einen parameterisierten Unit-test. Toll, und was lässt sich damit nun machen? Wir können eine "Exploration" starten.

Diese Exploration versucht nun Input-Parameter zu finden die zu einer möglichst 100%igen Code-Abdeckung führen. Und hier beginnt nun die Magic von PEX. Ohne unser Zutun findet PEX 3 Kombinationen von Input-Parametern die tatsächlich eine komplette Code-Abdeckung erzielen- WOW! Dazu analysiert PEX wirklich den von uns erstellten Code und kann daraus definieren, mit welchen Input-Parametern die einzelnen noch nicht abgedeckten Zweige erreicht werden können.

Und das schönste, PEX baut uns automatisch 3 Unit-Tests die diese Testcases implementieren:

               1: [TestMethod]

               2: [PexGeneratedBy(typeof(CalculationTest))]

               3:
              public
              void SimpleTest01()

               4: {

               5:
              string s;

               6: Calculation
calculation = new Calculation();

               7: s
= this.SimpleTest(calculation, 1, 2);

               8: Assert.AreEqual<string>("x1
< x2", s);

               9: }

               10:  

               11: [TestMethod]

               12: [PexGeneratedBy(typeof(CalculationTest))]

               13:
              public
              void SimpleTest02()

               14: {

               15:
              string s;

               16: Calculation
calculation = new Calculation();

               17: s
= this.SimpleTest(calculation, 1879212556, 1879212556);

               18: Assert.AreEqual<string>("x1
== x2", s);

               19: }

               20:  

               21: [TestMethod]

               22: [PexGeneratedBy(typeof(CalculationTest))]

               23:
              public
              void SimpleTest03()

               24: {

               25:
              string s;

               26: Calculation
calculation = new Calculation();

               27: s
= this.SimpleTest(calculation, 256, 254);

               28: Assert.AreEqual<string>("x1
> x2", s);

               29: }

Diese Unit-Tests können wir nun starten und sehen, dass diese wie erwartet alle erfolgreich sind.

Damit haben wir einen Test automatisiert erstellt, der sicherstellen kann, dass diese Methode ihr Verhalten nach Außen für die aktuell definierten Test-Cases nicht verändert. Damit können ungewollte Änderungen an der Methode erkannt und beseitigt werden. Ob die Methode allerdings ihre Aufgabe korrekt erledigt, kann PEX natürlich nicht testen. Haben wir die Funktionsweise einer Methode allerdings einmal validiert, kann PEX nun sehr einfach dieses Verhalten prüfen. Und natürlich eignet es sich auch sehr gut um mögliche Test-Cases zu definieren. Es müssen in diesem Fall dann nur noch die einzelnen Ergebnisse je Test validiert werden.

Ändern wir die Methode ab, so dass sich ihr Verhalten ändert, dann alarmiert uns der entsprechende Test.

Soweit sogut - Und was geht sonst noch?

Wenn wir nun ein gewünschte Änderung der Funktionalität implementieren, wie kann PEX dann damit umgehen? Zunächst würden wir die vorhandenen Tests durchführen, damit wir sicher sind, dass die aktuelle Funktionalität noch korrekt läuft. Dann erweitern wir unsere Methode:

               1:
              public
              string SimpleTest(int x1, int x2)

               2: {

               3:
              if (x1
> x2 * 2)

               4:
              return
              "x1
> x2 * 2";

               5:
              if (x1
> x2)

               6:
              return
              "x1
> x2";

               7:
              if (x1
< x2)

               8:
              return
              "x1
< x2"; 

               9:
              else
            

               10:
              return
              "x1
== x2";

               11: }

Schön - darf's noch ein bisschen mehr sein?

Dieses einfache Sample war ja schon sehr beeindruckend. Die Frage, die sich aber natürlich direkt stellt, ist wie weit geht denn das? Wir wollen nun den Schwierigkeitsgrad für PEX schrittweise steigern. Integer-Werte sind ja noch relativ einfach zu handhaben, aber wie sieht's denn beispielsweise mit Strings aus? Hierzu zunächst wieder eine Methode, die wir testen wollen:

               1:
              public
              class StringOperations

               2: {

               3:
              public
              string CheckString(string Input)

               4: {

               5:
              if (Input.StartsWith("abc")
&& Input.Length > 10)

               6:
              return Input
+ " Starts with 'abc' and length > 10"; 

               7:
              if (Input.StartsWith("abc"))

               8:
              return Input
+ " Starts with 'abc'";

               9:
              if (Input.StartsWith("ABC"))

               10:
              return Input
+ " Starts with 'ABC'";

               11:
              return
              "Unknown
pattern";

               12: }

               13: }

Stubs erzeugen und Exploration starten. Ob PEX wohl solche Operationen wie "StartsWith" und "Length" versteht?

Es findet tatsächlich alle erforderlichen Input-Parameter und sogar noch mehr! PEX stell fest, dass unsere Methode beim Übergeben einer NULL-Referenz eine Exception wirft. Und damit nicht genug, PEX kann uns auch einen Vorschlag machen, wie wir unseren Code verbessern können. Dazu im "Pex Exploration Results" - Fenster unter Views "Show suggestions window" aufrufen.

Durch einen Doppelklick auf den Eintrag am unteren Rand des Bereichs öffnet sich ein Fenster, das die vorgeschlagene Änderung direkt in unseren Code einfügen kann.

               1:
              public
              string CheckString(string Input)

               2: {

               3:
              //
<pex>
            

               4:
              if (Input
== (string)null)

               5:
              throw
              new ArgumentNullException("Input");

               6:
              //
</pex>
            

               7:
              if (Input.StartsWith("abc")
&& Input.Length > 10)

               8:
              return Input
+ " Starts with 'abc' and length > 10"; 

               9:
              if (Input.StartsWith("abc"))

               10:
              return Input
+ " Starts with 'abc'";

               11:
              if (Input.StartsWith("ABC"))

               12:
              return Input
+ " Starts with 'ABC'";

               13:
              return
              "Unknown
pattern";

               14: }

Die Zeilen 3-6 wurden von PEX erzeugt. Natürlich können wir das entsprechende Verhalten im Code direkt ändern und an unsere Vorstellungen anpassen. Vielleicht ist es aber gar keine schlechte Idee, in diesem Fall eine Exception zu werden. Dies ist das Standard-Verhalten von PEX an dieser Stelle. Wird die erwartete Exception nicht mehr geworfen oder eine andere Exception tritt auf, wird dies durch einen fehlgeschlagenen Test angezeigt.

Der nächste bitte!

So nun wollen wir noch einen Schritt weitergehen und sehen, wie PEX mit Listen umgehen kann. Dazu habe ich folgende Testmethode erstellt (über den Sinn einer solchen Methode wollen wir jetzt nicht nachdenken)

               1:
              int result
= 0;

               2:
              if (list.Count
> 10)

               3: {

               4:
              foreach (int i in list)

               5: result
+= i;

               6: }

               7:
              else
            

               8: {

               9:
              foreach (int i in list)

               10: result
*= i;

               11: }

               12:
              return result;

Die Methode bekommt eine Liste von Integer-Werten übergeben. Wenn es mehr als 10 Elemente sind, werden diese addiert, sonst werden die Werte miteinander Multipliziert. Mal sehen, wie PEX mit Listen umgeht.

PEX erkennt noch, dass unsere Methode mit Null-References nicht korrekt umgeht, aber dann verließen sie ihn.  Aber freundlicherweise bekommen wir noch einen Hinweis "2 Object Creations". klickt man darauf, dann bekommt man schon mehr Informationen.

Aha, PEX kann also eine List<int> nicht erzeugen. Also was tun? Klickt man den unteren der beiden Einträge an, bietet PEX etwas weiter rechts die Möglichkeit eine Factory zu definieren. Eine Factory ist ein Extensibility-Point mit dem PEX beigebracht werden kann mit solchen Objekten umzugehen. Ein Beispiel für eine solche Factory kann so aussehen:

               1:
              namespace System.Collections.Generic

               2: {

               3: [PexFactoryClass]

               4:
              public
              partial
              class ListFactory

               5: {

               6: [PexFactoryMethod(typeof(List<int>))]

               7:
              public
              static List<int>
Create(int i)

               8: {

               9:
              if (i
> 100)

               10: i
= 100;

               11: List<int>
l = new List<int>();

               12:
              for (int j
= 0; j < i; j++)

               13: {

               14: l.Add(j
* 10);

               15: }

               16:
              return l;

               17: }

               18: }

               19: }

Hier teilt man PEX nun mit, welche Elemente es damit erzeugen kann (Zeile 6). Anschließend implementiert man eine Create-Methode die beliebige Parameter übernehmen kann. In Abhängigkeit dieser Parameter wird nun eine Instanz des gewünschten Objektes erzeugt. In unserem Beispiel übernehmen wir nur einen Parameter der die Länge der Liste angibt. In den Zeilen 9/10 begrenzen wir die Länge der Lsite auf 100 Elemente. Die Liste selbst befüllen wir mit einer Reihe von Zahlen. Hier ist es sicher keine gute Idee, z.B. Zufallszahlen zu verwenden, da diese ja bei jedem Testdurchlauf andere Werte liefern und deshalb der Assert nicht erfolgreich ausgeführt werden kann.

Mit hilfe dieser Factory kannPEX nun unsere Testcases definieren. Dazu ermittelt es einfach geeignete Parameter für die Create-Methode in unserer Factory statt das Objekt selbst zu erzeugen.

Die erzeugten Tests sehen dann so aus:

               1: [TestMethod]

               2: [PexGeneratedBy(typeof(ListCalculationTest))]

               3:
              public
              void SumList03()

               4: {

               5: List<int>
list;

               6:
              int i;

               7: list
= ListFactory.Create(2);

               8: ListCalculation
listCalculation = new ListCalculation();

               9: i
= this.SumList(listCalculation, list);

               10: Assert.AreEqual<int>(0,
i);

               11: }

               12:  

               13: [TestMethod]

               14: [PexGeneratedBy(typeof(ListCalculationTest))]

               15:
              public
              void SumList04()

               16: {

               17: List<int>
list;

               18:
              int i;

               19: list
= ListFactory.Create(536870912);

               20: ListCalculation
listCalculation = new ListCalculation();

               21: i
= this.SumList(listCalculation, list);

               22: Assert.AreEqual<int>(49500,
i);

               23: }

Nun folgt noch die Kür

Nach den Erfahrungen mit der Liste bereits etwas skeptischer geworden, wollen wir's jetzt aber doch wissen. Wie sieht's mit eigenen Objekten aus? Wie weit kommt PEX damit? Auch hier gibt es wieder eine einfache Methode die wir testen wollen:

               1:
              public
              class ComplexDataCalculation

               2: {

               3:
              public
              string DoComplexDataCalculation(cData
d)

               4: {

               5:
              if (!d.IsValid)

               6:
              return
              "NotValid";

               7:  

               8:
              if (d.DataValues.x1
> d.DataValues.x2)

               9:
              return
              "x1
> x2";

               10:
              if (d.DataValues.x1
< d.DataValues.x2)

               11:
              return
              "x1
< x2"; 

               12:
              else
            

               13:
              return
              "x1
== x2";

               14:  

               15: }

               16: }

               17:  

               18:
              public
              class cData

               19: {

               20:
              public cDataValues
DataValues { get; set; }

               21:
              public
              string ObsoleteParameter
{ get; set; }

               22:
              public
              bool IsValid
{ get; set; }

               23: }

               24:  

               25:
              public
              class cDataValues

               26: {

               27:
              public
              int x1
{ get; set; }

               28:
              public
              int x2
{ get; set; }

               29: }

Die Methode bekommt einen komplexen Datentyp übergeben. Und was macht PEX???

PEX erkennt nicht nur, dass wir zwei Null-Exceptions abfangen sollten, sondern kann auch unser Datenobjekt so initialisieren, dass wir wieder eine 100% Codeabdeckung bekommen. Die Unit-Tests sehen ungefähr so aus:

               1: [TestMethod]

               2: [PexGeneratedBy(typeof(ComplexDataCalculationTest))]

               3:
              public
              void DoComplexDataCalculation04()

               4: {

               5: cDataValues
cDataValues;

               6: cData
cData;

               7:
              string s;

               8: cDataValues
= new cDataValues();

               9: cDataValues.x1
= 3;

               10: cDataValues.x2
= 4;

               11: cData
= new cData();

               12: cData.DataValues
= cDataValues;

               13: cData.ObsoleteParameter
= "";

               14: cData.IsValid
= true;

               15: ComplexDataCalculation
complexDataCalculation = new ComplexDataCalculation();

               16: s
= this.DoComplexDataCalculation(complexDataCalculation,
cData);

               17: Assert.AreEqual<string>("x1
< x2", s);

               18: }

Das ist schon extrem beeindruckend, wie PEX tatsächlich eine entsprechende Instanz unseres Datenobjektes erzeugt und initialisiert und das so, dass wir alle Testcases abdecken. Wirklich beeindruckend.

Was haltet ihr davon? Würde mich über Feedback freuen.

Wer eine Visual Studio 2008 Standard Edition oder höher sein Eigen nennt, kann sich jetzt kostenlos einen Icon-Editor herunterladen.

Axialis Software - IconWorkshop™ Lite Download

Die Workitems aus dem Team Foundation Server können direkt nach Excel geladen, dort bearbeitet und wieder auf den TFS gepublished werden. Das hierzu erforderliche Add-In wird bei der Installation des Team Explorers automatisch mitinstalliert und funktioniert sehr gut. Ein wenig nervig ist allerdings, wenn man zu einem Workitem weitere Informationen sehen oder eintragen möchte und die entsprechende Spalte nicht angezeigt wird. Dann muss man die Spalte erst zur Anzeige auswählen und die Liste aktualisieren. Darüber hinaus wird die Darstellung in Excel schnell unübersichtlich, wenn man viele Felder anzeigen lässt.

Wäre es nicht schön, wenn man auch in Excel den gewohnten Detail-Dialog zu einem Workitem hätte? Genau diese Funktion bietet das kostenfreie Tool Ekobit TeamCompanion for Excel. Das Workitem kann editiert und gespeichert werden. Die selbe Funktion gibt es übrigens auch für MS Project.

TeamCompanion for Excel

TeamCompanion for Project

Für manuelle Tests muss man einen definierten Ausgangszustand schaffen um diese sinnvoll durchführen zu können. Dieser Ausgangszustand bezieht sich meist auf eine Datenbank. Um diesen Vorgang nun zu vereinfachen haben wir ein kleines Tool erstellt. Damit können Snapshots von Datenbanken erstellt und wiederhergestellt werden.

Das Tool erstellt dazu einfach ein Backup der Datenbank und kann dieses Backup auch wiederherstellen. Das ist sicher nicht extrem elegant, aber sehr einfach und praktikabel. Damit das Tool funktioniert, muss man zunächst ein parr Einstellungen in der config vornehmen:

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

               2:
              <
              configuration
              >
            

               3:
              <
              configSections
              >
            

               4:
              <
              sectionGroup
              name
              ="applicationSettings"
              type
              ="System.Configuration.ApplicationSettingsGroup,
System, Version=2.0.0.0, Culture=neutral, 


PublicKeyToken=b77a5c561934e089"
              >
            

               5:
              <
              section
              name
              ="SQLSnapshotTool.Properties.Settings"
              type
              ="System.Configuration.ClientSettingsSection,
System, Version=2.0.0.0, 


Culture=neutral, PublicKeyToken=b77a5c561934e089"
              requirePermission
              ="false"
              />
            

               6:
              </
              sectionGroup
              >
            

               7:
              </
              configSections
              >
            

               8:
              <
              applicationSettings
              >
            

               9:
              <
              SQLSnapshotTool.Properties.Settings
              >
            

               10:
              <
              setting
              name
              ="Password"
              serializeAs
              ="String"
              >
            

               11:
              <
              value
              />
            

               12:
              </
              setting
              >
            

               13:
              <
              setting
              name
              ="IntegratedSecurity"
              serializeAs
              ="String"
              >
            

               14:
              <
              value
              >True</value>

               15:
              </
              setting
              >
            

               16:
              <
              setting
              name
              ="Database"
              serializeAs
              ="String"
              >
            

               17:
              <
              value
              >Zeiterfassung</value>

               18:
              </
              setting
              >
            

               19:
              <
              setting
              name
              ="User"
              serializeAs
              ="String"
              >
            

               20:
              <
              value
              />
            

               21:
              </
              setting
              >
            

               22:
              <
              setting
              name
              ="LocalBackupPath"
              serializeAs
              ="String"
              >
            

               23:
              <
              value
              >C:\Temp\DBSnapshots</value>

               24:
              </
              setting
              >
            

               25:
              <
              setting
              name
              ="Server"
              serializeAs
              ="String"
              >
            

               26:
              <
              value
              >MyServer</value>

               27:
              </
              setting
              >
            

               28:
              <
              setting
              name
              ="UNCBackupPath"
              serializeAs
              ="String"
              >
            

               29:
              <
              value
              >\\MyServer\DBSnapshots</value>

               30:
              </
              setting
              >
            

               31:
              </
              SQLSnapshotTool.Properties.Settings
              >
            

               32:
              </
              applicationSettings
              >
            

               33:
              </
              configuration
              >
            

Die wichtigsten Einstellungen hier kurz beschrieben:

Zeile 11 : Das Kennwort für den Datenbankzugriff (kann leer sein, wenn integrated Security verwendet wird)
Zeile 14 : Angabe ob integrated Security verwendt werden soll.
Zeile 17 : Name der Datenbank
Zeile 20 : Name des Users (kann leer sein, wenn integrated Security verwendet wird)
Zeile 23 : Der lokale Pfad auf dem DB-Server in den die Snapshots geschrieben werden sollen
Zeile 26 : Der Name des DB-Servers
Zeile 29 : Der UNC-Pfad über den auf das Sbnapshot-Verzeichnis auf dem DB-Server vom Client aus zugegriffen werden kann.

Die Bedienung ist denkbar einfach. Man gibt einfach den Namen des gewünschten Snapshots an und klickt auf "Create Snapshot". Damit wird eine Backup-Datei in das Snapshot-Verzeichnis auf dem Server geschrieben. In der Liste sieht man alle BAK-Dateien aus dem Verzeichnis und kann eine auswählen um diese dann wiederherzustellen. Das ganze ist so einfach, dass sogar Anwender damit klarkommen.

Eine Einschränkung gibt es, das Tool läuft nur mit dem SQL-Server.

Wenn jemand das Tool nützlich findet, würde ich mich über ein kurzes Feedback freuen.

Die PowerCommands for Visual Studio 2008 sind jetzt in der Version 1.1 veröffentlicht worden und bieten in dieser neuen Version einige neue Funktionen. Bei den PowertCommends for Visual Studio 2008 handelt es sich um eine kostenlose Sammlung von nützlichen Erweiterungen für die Visual Studio IDE. Einen Überblick über die Funktionen bietet dieses Dokument. Da hat es viele Sachen dabei, die sicher schon jeder beim Arbeiten mit Visual Studio 2008 vermisst hat.

PowerCommands for Visual Studio 2008 - Home

Bin gerade auf das Jing-Projekt gestoßen. Damit lassen sich ganz einfach Screenshoots und Screencasts erstellen. Auf Wunsch kann man die Ergebnisse bei Screencast.com hochladen (ein kostenloser Account wird bei der Installation mit eingerichtet) oder in Flickr bzw. auf einem eigenen FTP-Server oder einem Fileshre ablegen.

Werde das mal testen, ob sich damit meine Blog-Beiträge etwas aufwerten lassen.

Download Jing-Projet

Jeder vermisst so die eine oder andere Funktion im Visual Studio. Ein paar kleine nützlichen Erweiterung kann man sich kostenlos mit den Power Commands für Visual Studio 2008 herunterladen. Wer wollte nicht schon immer solche netten Sachen machen wie...

.. alle Projekte in einer Solution einklappen

... Referenzen in ein anderes Projekt zu kopieren

.. und vieles mehr.

Download und Source Code gibt es hier

Wer zuerst mal lesen will, welche Funktionen es gibt, hier klicken

Wir nutzen in unserem Entwicklungsprozess seit einiger Zeit den Team Foundation Server. Für das Requirement Management setzen wir Workitems ein. In der aktuellen Version des Team Foundation Servers fehlte uns dabei bisher allerdings die Möglichkeit, Workitems hierarchisch zu organisieren. Glücklicherweise verfügt der Team Foundation Server über ein leistungsfähiges API (siehe auch meinen MSDN-Webcast zu diesem Thema). Auf Basis dieser API haben wir ein Tool, den artiso Workitem Manager, entwickelt, mit dem wir nun Workitems so strukturieren können, wie wir das in unseren Projekten brauchen. Neben der hierarchischen Struktur können auch Iterationen in Baumstrukturen abgebildet werden.

Ebenfalls Bestandteil des artiso Workitem Manger ist ein Word-AddIn mit der Spezifikationsdokumente auf Funktionsebene verwaltet werden können. Damit lassen sich verschiedene Probleme mit Spezifikationsdokumente als monolithische Worddokumente lösen.

Den artiso Workitem Manager kann als Beta-Version kostenlos heruntergeladen werden. Die frei verfügbare Version ist auf 50 Workitems begrenzt.

Weitere Informationen finden sich hier.

Mit diesem kostenlosen Add-In lassen sich Feiertage in MS-Project und Outlook im Kalender eintragen und auch wieder entfernen.

SetHolidays - Import von Feiertagen in Outlook und Microsoft Project

Das Problem kennt vermutlich fast jeder Notebook-Besitzer der an seinem Arbeitsplatz noch einen zusätzlichen PC hat. Wenn man am Arbeitsplatz sitrzt steht das Notebook entweder nutzlos in der Ecke oder man kommt mit den Mäusen und Tastaturen immer durcheinander. Wäre es nicht schön, das Notebook am Arbeitsplatz zu integrieren. Unter XP hatte ich hier eine geniale Lösung - Maxivista. Damit konnte man sogar eine Zweischirmlösung aufbauen indem das Notebook einfach den Desktop des Arbeitsplatzrechners erweiterte. Absolut klasse, nur funktioniert der Host unter Vista nicht (zumindest nur mit den WDDM-Treibern, was für mich allerdings keine Alternative ist).

Nun habe ich Synergy entdeckt. Dieses Opensource-Tool bitet die Möglichkeit, einen Rechner mit der Maus / Taststur eines zweiten Rechners fernzusteuern. Es unterschiedet sich zu Remote Desktop o. ä., indem es nicht den Bildschirm des PCs auf den Zweit-PC überträgt. Es lässt sich in meinem Szenario damit wunderbar nutzen. Ich habe auf meinem Desktop-PC Visual Studio laufen und kann dann einfach mit der Maus links zum Bildschirmrand rausfahren und schon bin ich auf meinem Notebook und kann damit mit der gleichen Tastatur / Maus z.B. Suchen im Internet, Downloads, E-Mail oder andere Funktionen aufrufen ohne dass mein Desktop-PC damit belastet wird. Das Ganze läuft auch problemlos unter Vista und ist zumindest mal ein brauchbarer Ersatz für MaxiVista.

Wer mal etwas mehr mit WCF programmiert hat, wird feststellen, dass es recht müßig ist, für jeden Service einen Host zu implementieren. Deshalb habe ich zusammen mit meinem Kollegen Tobi einen WCF Service-Managerr entwickelt. Dieser Servicemanager wird auf dem Application-Server als Windows-Dienst ausgeführt und ist in der Lage Services die in DLLs bereitgestellt werden dynamisch zu laden und auszuführen. Zur Steuerung dient ein Client der natürlich per WCF mit dem Service-Manager kommuniziert. Damit kann auch eine größere Zahl von Services auf einem Application-Server effizient verwaltet werden.

Der Service-Manager kann inkl. einer kleinen Doku kostenlos heruntergeladen und verwendet werden. Über ein Feedback würde ich mich freuen.

Bei der Neuinstallation eines Entwicklungsrechners dauert es immer ewig, bis man sich die ganzen nützlichen Helferlein zusammengesucht hat, die man im Laufe der Zeit zu schätzen gelernt hat. Deshalb habe ich mir gedacht, ich schreibe mir mal eine Liste, die ich dann immer wieder ergänzen kann. Und vielleicht ist für den einen oder anderen da auch noch was interessantes dabei. Also so könnte ein Entwicklungsrechner aussehen:

Betriebsystem / Standardanwendungen:

• Windows Vista Ultimate
• Office 2007
• SQL-Server 2005 Express
• SQL-Server 2005 Management Studio

Entwicklungsumgebung:

• Visual Studio 2005 Team Edition for Software Developers
• Visual Studio Team Explorer
• Microsoft Team Foundation Server Power Tools mit zusätzlichen Tools zum TFS
  http://msdn2.microsoft.com/en-us/vstudio/aa718351.aspx
• GostDoc um XML-Kommentare zu erstellen (Free)
  http://www.roland-weigelt.de/ghostdoc/
• Infragistics Netadvantage Suite eine sehr gute GUI Bibliothek, aktuelle Hotfixes unbedingt installieren
  http://www.infragistics.com/dotnet/netadvantage.aspx#Overview
• Internet Explorer Developer Toolbar zum untersuchen von Web-Seiten im IE (Free)
  http://www.microsoft.com/downloads/details.aspx?familyid=E59C3964-672D-4511-BB3E-2D5E1DB91038&displaylang=en
• Lutz Roeders Reflector for .Net um Assemblies zu im Quellcode anzuzeigen (Free)
  http://www.aisto.com/roeder/dotnet/
• Regionerate, ein Helfer, der Fields, Properties und Methoden in Regions gruppiert (Beta)
  http://www.rauchy.net/regionerate/
  

Tools

• Acronis True Image 10 Home um Images der lokalen Platte auf ein USB-Device zu sichern
  http://www.acronis.de/homecomputing/products/trueimage/
• Acrobat Reader 8.1.0
  http://www.adobe.com/products/acrobat/readstep2.html
• AusLogics Disk Defrag zum Festplatten defragmentieren (Free)
  http://www.auslogics.com/disk-defrag/index.php
• Avira AntiVir Workstation als Virenscanner
  http://www.avira.de/de/produkte/avira_antivir_workstation.html
• Axialis Icon Workshop um Icons zu erstellen und zu bearbeiten
  http://www.axialis.com/iconworkshop/
• Daemon Tools um ISO-Images direkt zu lesen
  http://www.daemon-tools.cc/dtcc/download.php?mode=ViewCategory&catid=5
• IEeee ist ein Plugin für den IE mit dem einfach und schnell Bug-Workitems im TFS generiert werden können (Free)
  http://www.codeplex.com/UKVSTS
• Maxivista erlaubt die Nutzung des Notebooks als Zweitschirm (Host läuft nicht unter Vista)
  http://www.maxivista.de
• Microsoft Shared View um Desktop über eine einfache Internetverbindung zu sharen (Beta)
  http://www.microsoft.com/downloads/details.aspx?familyid=95AF94BA-755E-4039-9038-63005EE9D33A&displaylang=en
• Notepad++ ein echt cooler Editor für praktisch alle Textformate (Free)
  http://notepad-plus.sourceforge.net/de/site.htm
• Office 2007 Save as PDF or XPS Add-In (Free mit gültigem Office 2007)
  http://www.microsoft.com/downloads/details.aspx?FamilyId=4D951911-3E7E-4AE6-B059-A2E79ED87041&displaylang=en
• Paint .Net, ein sehr gutes Grafik-Programm (Free)
  http://getpaint.net/index.html
• Paint .Net PhotoshopFilter, ein Plugin das das Öffnen und Speichern von Photoshop-Dateien mit Paint .Net ermöglicht (Free)
  http://frankblumenberg.de/doku/doku.php?id=paintnet:psdplugin
• RocketDock als Startleiste
  http://rocketdock.com/
• Skype zur Kommunikation über das Internet (Free)
  http://www.skype.de/intl/de/
• Synergy um mein Notebook mit der Tastatur / Maus meines Hauptrechners zu steuer (Free)
  http://synergy2.sourceforge.net/
• TPG Setholidays zum Eintragen von Feiertagen in Project und Outlook
  http://www.theprojectgroup.com/D/produkte/produkte_setholidays.html
• VMWare Workstation um Testumgebungen virtuell ablaufen zu lassen
  http://www.vmware.com/products/ws/
• Windows Live Toolbar mit sinnvollen Tools für den IE, z.B. Blog this (Free)
  http://toolbar.live.com/?mkt=de-at
• Windows Live Writer zum bloggen (Free)
  http://www.live-writer.de/project/WindowsLiveWriterDownload.aspx
• XML Notepad zum Anzeigen und Bearbeiten von XML-Dateien (Free)
  http://www.microsoft.com/downloads/details.aspx?FamilyID=72D6AA49-787D-4118-BA5F-4F30FE913628&displaylang=en
• ZoomIt zum Zoomen und Zeichnen auf dem Desktop - sehr praktisch für Präsentationen (Free)
  http://download.sysinternals.com/Files/ZoomIt.zip
  

Stand 05.10.2007
To be continued...

Habe gerade den ersten Praxis-Test mit Microsoft SharedView absolviert. Das hat auf Anhieb geklappt, echt klasse.

Das Tool erlaubt es, dass man eine Session einrichtet und die Teilnehmer der Session untereinander ihre Desktops oder auch nur einzelne Anwendungen freigeben können. Dabei können die anderen entweder nur zuschauen oder auch aktiv eingreifen. Das tolle dabei ist, dass für alle Teilnehmer eine einfache Internet-Verbindung genügt, auch für den Session-Initiator.

Ich wollte gerade einen externen Kollegen bei einer Fehlersuche unterstützen. Am Telefon war das aber kaum zu erklären. Wir haben einfach beide SharedView runtergeladen und installiert. Die Verbindung hat auf Anhieb geklappt, obwohl wir beide hinter einer Firewall sitzen. ich konnte mich auf seinen Desktop schalten und diesen bedienen. Das Ganze ist noch nicht sehr schnell, aber es handelt sich dabei ja noch um eine Beta-Version und hoffentlich wird das Release in Punkto Performance noch etwas zulegen. Das einzige, was am Anfang zu etwas Verwirrung geführt hat, war, dass der Kollege mir zwar die Kontrolle über seinen Desktop übertragen hat, die dann aber immer gleich wieder zurücksprang. Wir haben dann aber schnell rausgefunden, dass die Kontrolle wieder zurückgeht, wenn am Freigabe-Rechner die Maus bewegt wird. Wenn man's weiss, eigentlich gar nicht so schlecht.

Ich fand das Ding echt superklasse und wir konnten den Fehler recht schnell beheben. (Sicher schneller als per Telefon und auch schneller als wenn wir erst den remote desktop auf der Firewall hätten freischalten lassen müssen)

Microsoft SharedView Beta

Mit diesem kleinen Plugin kann man Code-Ausschnitte direkt aus VS mit dem Windows Live Writer bloggen. Das Plugin übernimmt dabei die komplette Formatierung. Die Farbcodierung von VS bleibt dabei erhalten. 

Link to BlogMyCode VS2005 plugin

Möchte man die Process Guidance des Team Foundation Server in Papierform verfügbar machen, kann folgendes Tool sehr hilfreich sein. Damit kann die Process Guidance als ein einzelnes HTML-Dokument konvertiert werden.

http://staff.southworks.net/blogs/mariano/archive/2006/01/28/206.aspx  

Mit Microsoft Sandcastle lassen sich die XML-Kommentare aus dem Sourcecode in eine Dokumentation konvertieren. Damit lassen sich ohne viel Aufwand Dokumentationen im Stile einer MSDN-Dokumentation erstellen, die sogar in die VS-Hilfe eingebunden werden können. Einen Einstieg bietet das folgende Tutorial von Jonas:

http://www.dotnet-ulm.de/Downloads/20061121/Sandcastle.zip

Mit dem Power Toys Pack Installer erhält man einen schnellen Überblick über die verfügbaren Power Toys und kann diese direkt installieren.

http://www.codeplex.com/PackInstaller

Sandcastle, das Dokmentations-Tool von Microsoft ist nun in der November CTP zum download verfügbar.

http://www.microsoft.com/downloads/details.aspx?FamilyID=e82ea71d-da89-42ee-a715-696e3a4873b2&DisplayLang=en

Microsoft hat ein Resource Refactoring Tool rausgebracht, mit dem einfach Strings aus der Anwendung in Resource-Files ausgelagert werden können.

Ein Beispiel mit Screenshots gibts in dem Blog-Beitrag von Alex-

http://blogs.dotnetgerman.com/alexonasp.net/PermaLink,guid,4293f21b-679c-4d12-b3c9-3c2a6d3f3833.aspx

Der Internet Explorer 7 ist jetzt in der finalen Version zum Download verfügbar. 

Link to Download details: Windows Internet Explorer for 7 Windows XP SP2

Mit der BusyBoxDotNet kann man einfach eine Wartemeldung unter ASP.Net erzeugen.

http://busyboxdotnet.qsh.eu/

Mit Sancastle können XML-Kommentare aus VS 2005 als Dokumentation ähnlich wie die MSDN-Dokumentation aufbereitet werden. Nun gibt es bei CodeProjekt nun auch eine grafische Oberfläche für Sandcastle.

http://www.codeproject.com/useritems/SandcastleBuilder.asp

Wenn man seine Klassen sauber mit XML-Kommentaren versieht, ist es ein leichtes, daraus auch eine schöne Dokumentation zu erstellen. Nur beim eingeben der XML-Kommentare taucht oft die Frage aus, wie sieht das Ergebnis aus? Dazu jedesmal die Dokumentation zu erstellen ist recht mühsam. Abhilfe schafft hier dieses kleine Tool, das in der IDE eine HTML-Vorschau ermöglicht.

http://www.kyrsoft.com/opentools/qdocviewer.html

Mit dem XML Notepad von Microsoft lassen sich XML-Dateien einfach anzeigen und bearbeiten. Selbst ein Vergleich von zwei XML-Dateien ist möglich.

http://www.microsoft.com/downloads/details.aspx?familyid=72d6aa49-787d-4118-ba5f-4f30fe913628&displaylang=en

Dieses Tool erstellt automatisch XML-Kommentare für einzelne Methoden, Eigenschaften etc. Wenn man sprechende Methoden- und Parameternamen verwendet, kann das Tool daraus automatisch eine Beschreibung generieren. Außerdem können neue Parameter zu den XML-Kommentaren hinzufügen.

http://www.roland-weigelt.de/ghostdoc/

Es gibt auch ein kleines Video, das die Funktionsweise des Tools zeigt.

http://channel9.msdn.com/Showpost.aspx?postid=121822

Der Task-Manager liefert oftmals nur unzureichende Informationen über die einzelnen Prozesse etc. Mit dem Tool Process Explorer kann man zu jedem Prozess umfangreiche Informationen abfragen. Das Tool kann auch den Task-Manager ersetzen.

Sehr praktisch ist, dass man das Tool nicht installieren muss, sondern die Exe separat gestartet werden kann.

http://www.sysinternals.com/Utilities/ProcessExplorer.html

22:02 - Im Internet nach einem Tutorial gesucht.
22:10 - Genau das Passende gefunden.
22:11 - Ausdruck starten, um zu Hause zu lesen
22:12 - Geflucht, weil der rechte Rand mal wieder abgeschnitten ist

Für sole Probleme hat jeder so seinen eigenes Patentrezept, im Querformat drucken, nach Word kopieren und von da drucken oder - dieses kleine Tool installieren. Damit kann im IE die Seite so angepasst werden, dass Sie auf jeden Fall auf die Seite passt. Das Tool bietet auch eine Vorschau. Echt genial!

ACHTUNG - Bei der deutschen Version des IE muss das Icon manuell in die Symbolleiste eingefügt werden:
Rechte Maustaste auf die Symbolleiste / Anpassen dann aus der linken Liste das Icon "Fit-width Print" in die rechte Liste übernehmen.

http://www.visiontech.ltd.uk/software/#IEPrint

Jeder Programmierer kennt das Problem. Am Entwicklungsrechner hat man einen schönen großen Monitor aber wie sieht die Anwendung bei einer anderen Auflösung, z.B. 1024 x 768 aus? Ein Fenster genau auf diese Größe zu bringen ist genau das, was Sizer tut. Man kann sich beliebige Größen defibnieren und dann einfach diese Größe für ein Fenster einstellen lassen.

http://www.brianapps.net/sizer.html

Mit diesem Tool lassen sich verschiedene Befehle auf Datenbanken ausführen. Damit lassen sich z.B. Daten einer Tabelle abfragen und nach CSV oder XML exportieren. Der besondere Charme des Tools ist, dass es nicht installiert werden muss, es kann einfach die EXE gestartet werden. Damit ist es gut geeignet als Datenbank-Viewer für unterwegs.

http://www.albahari.com/queryexpress.html

Der kostenlose Internet Explorer Developer Toolbar von Microsoft bietet eine Fülle von sehr nützlichen Funktionen für Web-Entwickler. Der Toolbar integriert sich im Internet-Explorer. Man kann sich z.B. Objekte wie Tabellen, Bilder, DIVs etc. durch eine Umrandung hervorheben lassen oder man kann die komplette DOM-Struktur dursuchen und die Eigenschaften der Elemente abfragen und sogar verändern. Die Änderungen werden sofort sichtbar. Darüber hinaus werden noch eine vielzahl nützlicher Helfer angeboten, z.B. um Cookies anzuzeigen und zu löschen etc. Ein Tool, das bei keinem Web-Entwickler fehlen sollte!

http://www.microsoft.com/downloads/details.aspx?FamilyID=E59C3964-672D-4511-BB3E-2D5E1DB91038&displaylang=en

Dieses Tool unterstützt beim Entwickeln mehrsprachiger Oberflächen. In einer Tabelle können die Textattribute für verschiedene Sprachen eingegeben werden.

http://www.jollans.com/multilang_dotnet/multilang_for_dotnet.htm

Xml2PDF ist eine Komponente, mit der verschiedene XML-Formate nach PDF konvertiert werden können, unter anderem auch WordML.

http://alt-soft.com/products_xml2pdf.jsp

http://sharptoolbox.com/

Mit MSBee kann MSBuild von VS2005 so konfiguriert werden, dass damit Anwendungen kompiliert werden können, die auf dem Framework 1.1 ablaufen. Dies kann vor allem zur Pflege von bestehenden Anwendungen sinnvoll sein. Neue Anwendungen zu erstellen ist jedoch recht mühsahm, weil VS 2005 automatisch partial Classes verwendet, die aber vom Framework SDK 1.1 nicht unterstützt werden.

http://www.codeplex.com/Wiki/View.aspx?ProjectName=MSBee

Unter http://www.red-gate.com/products/SQL_Prompt/index.htm kann man kostenlos ein kleines Tool herunterladen, das für alle SQL-Editoren wie z.B. den Query Analyzer, SQL Server 2005 Managementstudio etc. eine Intelli-Sense Unterstützung für Tabellen-, Aplaten und Funktionsnamen bietet.

Mit dem Team Foundation Server Administration Tool können im Team Foundation Server benutzer und Berechtigungen verwaltet werden.

http://www.codeplex.com/Wiki/View.aspx?ProjectName=TFSAdmin

Der VMWare-Server kann nun kostenlos heruntergeladen werden

http://www.vmware.com/download/server/

Jeder kennt das Problem. Man hat einen ellenlangen SQL-String und spätestens nach der dritten Klammer hat man den Überblick verloren, wenn allles in einer Zeile steht. Hier hilft ein kleines Tool weiter, das SQL-Strings, auch komplexe, übersichtlich formatiert. Das Tool gibt es als kostenlose Online-Version und als kostenpflichtige Offline-Version oder auch als API.

http://www.sqlinform.com/