Philip wrote a simple app to list the work items associated with the changesets for a given path, and it’s in some ways an enhanced update of Naren’s post.

Given an URL to a collection and a server path (e.g., $/myproject/coolthing), it will list the work items that are associated with the most recent 25 checkins.  This sample shows how to use the linking service to convert the work item artifact URIs that are stored with the changesets to get the core work item fields (ID, assigned to, state, type, and title).

It will produce output like the following.

Id: 352694 Title: Improve performance of queuing servicing jobs on Azure.

You will need to reference the following DLLs to build this, all of which are found on the .NET tab of the Add Reference dialog in Visual Studio 2010.

• Microsoft.TeamFoundation.Client.dll
• Microsoft.TeamFoundation.Common.dll
• Microsoft.TeamFoundation.VersionControl.Client.dll

using System;
using System.Collections.Generic;
using System.Diagnostics;
using Microsoft.TeamFoundation;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.VersionControl.Client;

namespace ListWorkItems
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length < 2)
            {
                Console.WriteLine("Usage: listworkitems <URL for TFS> <server path>");
                Environment.Exit(1);
            }

            TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(new Uri(args[0]));
            VersionControlServer vcs = tpc.GetService<VersionControlServer>();

            // Get the changeset artifact URIs for each changeset in the history query
            List<String> changesetArtifactUris = new List<String>();

            foreach (Object obj in vcs.QueryHistory(args[1],                       // path we care about ($/project/whatever)
                                                    VersionSpec.Latest,            // version of that path
                                                    0,                             // deletion ID (0 = not deleted)
                                                    RecursionType.Full,            // entire tree - full recursion
                                                    null,                          // include changesets from all users
                                                    new ChangesetVersionSpec(1),   // start at the beginning of time
                                                    VersionSpec.Latest,            // end at latest
                                                    25,                            // only return this many
                                                    false,                         // we don't want the files changed
                                                    true))                         // do history on the path
            {
                Changeset c = obj as Changeset;
                changesetArtifactUris.Add(c.ArtifactUri.AbsoluteUri);
            }

            // We'll use the linking service to get information about the associated work items
            ILinking linkingService = tpc.GetService<ILinking>();
            LinkFilter linkFilter = new LinkFilter();
            linkFilter.FilterType = FilterType.ToolType;
            linkFilter.FilterValues = new String[1] { ToolNames.WorkItemTracking };  // we only want work itms

            // Convert the artifact URIs for the work items into strongly-typed objects holding the properties rather than name/value pairs
            Artifact[] artifacts = linkingService.GetReferencingArtifacts(changesetArtifactUris.ToArray(), new LinkFilter[1] { linkFilter });
            AssociatedWorkItemInfo[] workItemInfos = AssociatedWorkItemInfo.FromArtifacts(artifacts);

            // Here we'll just print the IDs and titles of the work items
            foreach (AssociatedWorkItemInfo workItemInfo in workItemInfos)
            {
                Console.WriteLine("Id: " + workItemInfo.Id + " Title: " + workItemInfo.Title);
            }
        }
    }

    internal class AssociatedWorkItemInfo
    {
        private AssociatedWorkItemInfo()
        {
        }

        public int Id
        {
            get
            {
                return m_id;
            }
        }

        public String Title
        {
            get
            {
                return m_title;
            }
        }

        public String AssignedTo
        {
            get
            {
                return m_assignedTo;
            }
        }

        public String WorkItemType
        {
            get
            {
                return m_type;
            }
        }

        public String State
        {
            get
            {
                return m_state;
            }
        }

        internal static AssociatedWorkItemInfo[] FromArtifacts(IEnumerable<Artifact> artifacts)
        {
            if (null == artifacts)
            {
                return new AssociatedWorkItemInfo[0];
            }

            List<AssociatedWorkItemInfo> toReturn = new List<AssociatedWorkItemInfo>();

            foreach (Artifact artifact in artifacts)
            {
                if (artifact == null)
                {
                    continue;
                }

                AssociatedWorkItemInfo awii = new AssociatedWorkItemInfo();

                // Convert the name/value pairs into strongly-typed objects containing the work item info
                foreach (ExtendedAttribute ea in artifact.ExtendedAttributes)
                {
                    if (String.Equals(ea.Name, "System.Id", StringComparison.OrdinalIgnoreCase))
                    {
                        int workItemId;

                        if (Int32.TryParse(ea.Value, out workItemId))
                        {
                            awii.m_id = workItemId;
                        }
                    }
                    else if (String.Equals(ea.Name, "System.Title", StringComparison.OrdinalIgnoreCase))
                    {
                        awii.m_title = ea.Value;
                    }
                    else if (String.Equals(ea.Name, "System.AssignedTo", StringComparison.OrdinalIgnoreCase))
                    {
                        awii.m_assignedTo = ea.Value;
                    }
                    else if (String.Equals(ea.Name, "System.State", StringComparison.OrdinalIgnoreCase))
                    {
                        awii.m_state = ea.Value;
                    }
                    else if (String.Equals(ea.Name, "System.WorkItemType", StringComparison.OrdinalIgnoreCase))
                    {
                        awii.m_type = ea.Value;
                    }
                }

                Debug.Assert(0 != awii.m_id, "Unable to decode artifact into AssociatedWorkItemInfo object.");

                if (0 != awii.m_id)
                {
                    toReturn.Add(awii);
                }
            }

            return toReturn.ToArray();
        }

        private int m_id;
        private String m_title;
        private String m_assignedTo;
        private String m_type;
        private String m_state;
    }
}

Philip, a dev on version control, recently helped with a question on how to get the TFS objects we use in our UI.  I thought I’d post since others may find it useful.

We recently had a request from a customer for a VS add-in that would be able to access the same TfsTeamProjectCollection and VersionControlServer objects that our own UI integration (such as the Team Explorer and Pending Changes toolwindow) are using. In this particular case the customer wanted to hook the BeforeCheckinPendingChange event from the VersionControlServer object and take a specific action when that occurred. But the framework shown in this piece of sample code is generic -- you can use it to get the very same VersionControlServer or WorkItemStore object that our integration is using to connect to TFS.

The trick here is to hook the ProjectContextChanged event on the TeamFoundationServerExt extensibility object. While that extensibility point won't give you the TfsTeamProjectCollection object directly, we can ask the TfsTeamProjectCollectionFactory's static GetTeamProjectCollection method to retrieve it from a runtime cache. The cache is keyed by URI -- which (handily) is provided by TeamFoundationServerExt. By the time the ProjectContextChanged event fires, the ActiveProjectContext.DomainUri property has already been updated.

All the services in the TFS client object model are owned by the TfsTeamProjectCollection. Once we have it, we can call GetService to request the VersionControlServer object. There's only one per TfsTeamProjectCollection; the same holds true for WorkItemStore, IBuildServer, or any of the other client object model services you may be familiar with.

Happy extending!

using System;
using System.Diagnostics;
using System.Windows.Forms;
using Extensibility;
using EnvDTE;
using EnvDTE80;
using Microsoft.TeamFoundation.Common;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.VersionControl.Common;
using Microsoft.TeamFoundation.VersionControl.Client;
using Microsoft.VisualStudio.TeamFoundation;
using Microsoft.VisualStudio.TeamFoundation.VersionControl;

namespace MyAddin1
{
    /// <summary>The object for implementing an Add-in.</summary>
    /// <seealso class='IDTExtensibility2' />
    public class Connect : IDTExtensibility2
    {
        /// <summary>Implements the constructor for the Add-in object. Place your initialization code within this method.</summary>
        public Connect()
        {
        }

        /// <summary>Implements the OnConnection method of the IDTExtensibility2 interface. Receives notification that the Add-in is being loaded.</summary>
        /// <param term='application'>Root object of the host application.</param>
        /// <param term='connectMode'>Describes how the Add-in is being loaded.</param>
        /// <param term='addInInst'>Object representing this Add-in.</param>
        /// <seealso class='IDTExtensibility2' />
        public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref Array custom)
        {
            _applicationObject = (DTE2)application;
            _addInInstance = (AddIn)addInInst;

            try
            {
                m_tfsExt = _applicationObject.GetObject("Microsoft.VisualStudio.TeamFoundation.TeamFoundationServerExt") as TeamFoundationServerExt;

                if (null != m_tfsExt)
                {
                    m_tfsExt.ProjectContextChanged += new EventHandler(m_tfsExt_ProjectContextChanged);

                    if (null != m_tfsExt.ActiveProjectContext)
                    {
                        // Run the event handler without the event actually having fired, so we pick up the initial state.
                        m_tfsExt_ProjectContextChanged(null, EventArgs.Empty);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        /// <summary>Implements the OnDisconnection method of the IDTExtensibility2 interface. Receives notification that the Add-in is being unloaded.</summary>
        /// <param term='disconnectMode'>Describes how the Add-in is being unloaded.</param>
        /// <param term='custom'>Array of parameters that are host application specific.</param>
        /// <seealso class='IDTExtensibility2' />
        public void OnDisconnection(ext_DisconnectMode disconnectMode, ref Array custom)
        {
            // Unhook the ProjectContextChanged event handler.
            if (null != m_tfsExt)
            {
                m_tfsExt.ProjectContextChanged -= new EventHandler(m_tfsExt_ProjectContextChanged);
                m_tfsExt = null;
            }
        }

        /// <summary>Implements the OnAddInsUpdate method of the IDTExtensibility2 interface. Receives notification when the collection of Add-ins has changed.</summary>
        /// <param term='custom'>Array of parameters that are host application specific.</param>
        /// <seealso class='IDTExtensibility2' />       
        public void OnAddInsUpdate(ref Array custom)
        {
        }

        /// <summary>Implements the OnStartupComplete method of the IDTExtensibility2 interface. Receives notification that the host application has completed loading.</summary>
        /// <param term='custom'>Array of parameters that are host application specific.</param>
        /// <seealso class='IDTExtensibility2' />
        public void OnStartupComplete(ref Array custom)
        {
        }

        /// <summary>Implements the OnBeginShutdown method of the IDTExtensibility2 interface. Receives notification that the host application is being unloaded.</summary>
        /// <param term='custom'>Array of parameters that are host application specific.</param>
        /// <seealso class='IDTExtensibility2' />
        public void OnBeginShutdown(ref Array custom)
        {
        }

        /// <summary>
        /// Raised by the TFS Visual Studio integration package when the active project context changes.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void m_tfsExt_ProjectContextChanged(Object sender, EventArgs e)
        {
            try
            {
                if (null != m_tfsExt.ActiveProjectContext &&
                    !String.IsNullOrEmpty(m_tfsExt.ActiveProjectContext.DomainUri))
                {
                    SwitchToTfs(TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(m_tfsExt.ActiveProjectContext.DomainUri)));
                }
                else
                {
                    SwitchToTfs(null);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void SwitchToTfs(TfsTeamProjectCollection tfs)
        {
            if (Object.ReferenceEquals(m_tfs, tfs))
            {
                // No work to do; could be a team project switch only
                return;
            }

            if (null != m_tfs)
            {
                m_tfs.GetService<VersionControlServer>().BeforeCheckinPendingChange -= new ProcessingChangeEventHandler(VersionControlServer_BeforeCheckinPendingChange);
                m_tfs = null;
            }

            if (null != tfs)
            {
                m_tfs = tfs;
                m_tfs.GetService<VersionControlServer>().BeforeCheckinPendingChange += new ProcessingChangeEventHandler(VersionControlServer_BeforeCheckinPendingChange);               
            }
        }

        private void VersionControlServer_BeforeCheckinPendingChange(Object sender, ProcessingChangeEventArgs e)
        {
            if (null != e.PendingChange &&
                !String.IsNullOrEmpty(e.PendingChange.ServerItem))
            {
                MessageBox.Show("About to check in: " + e.PendingChange.ServerItem);
            }
        }
       
        private DTE2 _applicationObject;
        private AddIn _addInInstance;

        private TeamFoundationServerExt m_tfsExt;
        private TfsTeamProjectCollection m_tfs;
    }
}

Nick Kirchem, who works on the TFS web access team, recently answered a question on how email subscriptions on checkin alerts.  The question was, how do I subscribe to checkin alerts not under a particular folder?

Here’s how to do it.

bissubscribe /eventType CheckinEvent /address someone@domain.com /deliveryType EmailHtml /server http://myserver:8080/tfs/DefaultCollection "'Artifacts/Artifact[@ArtifactType=\"VersionedItem\"][not(starts-with(translate(@ServerItem, \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\", \"abcdefghijklmnopqrstuvwxyz\"), \"$/devdiv/feature/build/qa\"))]' <> null"

Let’s break it down.

• /eventType – Here we want CheckinEvent.  There are others.  Rather than list them, I’d recommend the Alerts Explorer that is part of the Team Foundation Server Power Tools.  You can use it to discover more, as each different type has different things you can filter on.
• /address – The email address to use.
• /deliveryType – We want HTML-formatted email.
• /server – Here I’ve used the URL to the default collection on a TFS 2010 server.  You’ll need to edit it to match the server and collection you need to use.
• expression – The expression is somewhat hard to read.
• The path we want to filter out is listed last, which $/devdiv/feature/build/qa in this case.  You must use lowercase for your path.
• The translate XPath function is used to normalize the casing of the server path to be all lower case.  This is important because XPath is case sensitive.
• The starts-with XPath function tests to see if the path is one we are interested in (in this case to filter out).
• The not XPath function inverts the test to see if it is not under the path we want to filter out.
• The quotation marks are escaped so that they can be inside quotation marks on the Windows command prompt.

I recommend using the Alerts Explorer power tool rather than doing this by hand.  However, in this case, the Alerts Explorer does not support this.

Nick has also written a feature for TFS 11 to allow you to edit alerts inside the product through the web interface.  An early version of it is in the TFS 11 CTP release that came out in concert with the Windows’ //build conference.  Here’s a screen shot of it.  Note that you can only see it in the UI if you enable email in the TFS Administration Console.  Since then he’s made it easier to use and made it so that you can administer other user alerts, if you are an administrator.

Related post: Adding a path filter to a CheckinEvent subscription using bissubscribe

The question came up as to how to delete a team project in the Team Foundation Service Preview.  When I first tried it, it didn’t work.  Then I realized it’s the one case where you have to explicitly specify the collection name.  It’s surprising because in hosted TFS each account has only one collection.  You cannot create multiple collections currently as you can with on-premise TFS (this will change at some point in the future).  Incidentally, you cannot delete a collection right now either.

You must have installed the Visual Studio 11 Developer Preview (or newer build of VS/TE 11) to do this.  Even with the patch to support hosting, the 2010 version of tfsdeleteproject.exe will not work.

If you leave off the collection, here’s the error you will see when I try to delete the team project called Testing.

C:\project>tfsdeleteproject /collection:https://buckh-test2.tfspreview.com Testing
Team Foundation services are not available from server https://buckh-test2.tfspreview.com/.
Technical information (for administrator):
  HTTP code 404: Not Found

With DefaultCollection added to your hosting account’s URL, you will get the standard experience with tfsdeleteproject and successfully delete the team project.

C:\project>tfsdeleteproject /collection:https://buckh-test2.tfspreview.com/DefaultCollection Testing

Warning: Deleting a team project is an irrecoverable operation. All version control, work item tracking and Team Foundation build data will be destroyed from the system. The only way to recover this data is by restoring a stored backup of the databases. Are you sure you want to delete the team project and all of its data (Y/N)?y

Deleting from Build ...
Done
Deleting from Version Control ...
Done
Deleting from Work Item Tracking ...
Done
Deleting from TestManagement ...
Done
Deleting from LabManagement ...
Done
Deleting from ProjectServer ...
Done
Warning. Did not find Report Server service.
Warning. Did not find SharePoint site service.
Deleting from Team Foundation Core ...
Done

This is the error you will get when using tfsdeleteproject 2010, even with the patch for hosting access.

C:\Program Files\Microsoft Visual Studio 10.0\VC>tfsdeleteproject /collection:https://buckh-test2.tfspreview.com/DefaultCollection Testing2

Warning: Deleting a team project is an irrecoverable operation. All version control, work item tracking and Team Foundation build data will be destroyed from the system. The only way to recover this data is by restoring a stored backup of the databases. Are you sure you want to delete the team project and all of its data (Y/N)?y

TF200040: You cannot delete a team project with your version of Team Explorer. Contact your system administrator to determine how to upgrade your Team Explorer client to the version compatible with Team Foundation Server.

Today the .NET team is releasing a cumulative update patch.  This has all of the QFEs up until a couple of months ago rolled into one patch.  Included as part of that is a patch for WPF that improves the performance of the Windows Workflow Designer as well as a hang that a number of folks have hit.  I had a few customers try it out, and they were happy with the improvements.  I recommend this update to you if you work with the WF Designer (e.g., editing the workflow for Team Build definitions).  There are still perf issues even with this fix, and the WF Designer team has made some very good perf improvements for the next release.

You can find a complete list of the issues fixed at KB 2468871 under More Information.  There are also six features related to ASP.NET and Silverlight listed after the issues.

Here is the download page: http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=3556.

Enjoy!

P.S.  This is completely unrelated to the TFS cumulative update that Brian has written about here.  I recommend both.

The fine folks who write documentation for our product are woefully outnumbered.  Every month they release updates to the docs, adding new topics and enhancing existing ones.  You can find the latest set of updates described on their blog.

• Team Foundation Server, Microsoft Office SharePoint Server, SQL Server
• Building the Application
• Team Explorer Everywhere
• Team Foundation Server and Project Server Integration Feature Pack

Have you ever tried to debug an issue in old binaries and you don’t remember which version of the source they correspond to?  Have you debugged without symbols because no one saved them?  Here’s how to make your life easier.

One of the great features in Team Foundation Server 2010 Build is the ability to have your builds automatically indexed with source server and the symbols stored in symbol server.  Ed Blankenship has posted a great write up on how to configure and use this feature from the build to debugging in Visual Studio.

Source Server and Symbol Server Support in TFS 2010

As Jim Lamb announced in June 2009, TFS 2010 introduces support for Source Server and Symbol Server as part of the default automated build process template. This is a really key feature addition but I have found that many developers ask about why it would be so important and why it would help them. Ultimately, we are starting to have more and more tools that need access to the symbol file information and the original source code that was used for compilation. For example, some of the tools that come to mind are:

• Visual Studio Debugging including the Remote Debugger
• IntelliTrace
• Visual Studio Profiler
• WinDBG

By setting up Source Server and Symbol Server support during your build process, you’ll be able to work with assemblies & executables that come from the build servers and still use tools that need information from them.

more…

[UPDATE 4/12/2011]  Ewald Hofman pointed out that I missed Cameron’s excellent debugging series posts.  In Cameron’s second post, he points out how to work around an issue with using minidumps with VS 2010 SP1.

• Debugging Series: Symbol Server
• Debugging Series: Symbols Server and Your Symbols

Check it out!

Brian Keller has release a new OData service for TFS.  He does a great job explaining it, and he also includes a video demo.

OData Service for Team Foundation Server 2010

What the heck is an OData Service for Team Foundation Server 2010?
I’m glad you asked. The purpose of this project is to help developers work with data from Team Foundation Server on multiple types of devices (such as smartphones and tablets) and operating systems. OData provides a great solution for this goal, since the existing Team Foundation Server 2010 object model only works for applications developed on the Windows platform. The Team Foundation Server 2010 application tier also exposes a number of web services, but these are not supported interfaces and interaction with these web services directly may have unintended side effects. OData, on the other hand, is accessible from any device and application stack which supports HTTP requests. As such, this OData service interacts with the client object model in the SDK (it does not manipulate any web services directly).

What is OData?
OData exposes a way to work with data over the web. If you’re new to OData, I suggest spending a few minutes at http://www.odata.org/ reading about this evolving standard. It uses interfaces similar to REST, so that you can programmatically consume and manipulate data from any device or application stack which supports HTTP requests. DPE has been working with several organizations (such as PayPal, Facebook, and Netflix) and product groups to enable OData where it makes sense to do so. Team Foundation Server was an obvious choice since it not only allows developers to extend TFS in new and interesting ways, but it also allows us to further showcase support for this evolving standard with the developer community at large.

more…

Enjoy!

In the year since the release of TFS 2010, we’ve seen a run of great new books coming, all by authors who really know their subject matter extremely well.  At the beginning of the year, Sayed Ibrahim Hashimi and William Bartholomew published Using MSBuild and Team Foundation Build, the book on MSBuild and TFS Build.

Then Mickey Gousset, Brian Keller, Ajoy Krishnamoorthy, and Martin Woodward brought us Professional Application Lifecycle Management.  My copy of that book came in handy when I wrote a post on using the code metrics power tool with TFS Build.  It covers the full range of the VS ALM 2010 product.

Now Professional Team Foundation Server 2010 written by Ed Blankenship, Martin Woodward, Grant Holliday, and Brian Keller is now out.  I got my copy the other day and highly recommend it.  Martin wrote a great blog post on the book, and in it he describes the differences between Professional ALM and Professional TFS.

People have asked us what’s the difference between the ALM book and the Pro TFS book.  The ALM book was deliberately written as an overview to the huge amount of functionality available in the entire Visual Studio Application Lifecycle Management suite.  Though there are a couple of chapters, the Team Build one in particular, that get pretty technical – the Pro ALM book tries to keep things approachable by everyone.

The Pro TFS 2010 book is a deep dive on TFS.  We tried to make it so that you can pick up the book having never used TFS before any by the end of it not only know how to use TFS but how to administer a complex TFS instance and even use it to study for the TFS Administration exam.  I’ve learnt something from every single chapter in the Pro TFS book, but I would also hope that someone new to TFS could pick up the book and learn just enough to get going then come back for more over time.

They’ve included information on every major area of TFS and have included some coverage of the test features that integrate with TFS.  One of the things that makes the book great is that it includes some great information on features of the product you may not even know about.  For example, did you know you can use Active Directory to automatically configure version control proxies for your distributed teams (check out chapter 24)?  Want to understand your server’s health and diagnose performance issues (see chapter 21)?

Jeff Levinson’s Software Testing with Visual Studio 2010 covers the testing features of VS ALM 2010, which was a huge area of focus for us in the 2010 release.  In it he covers creating test cases, reporting, and lab management, which is a powerful and complex new feature in 2010.

In May we’ll get Professional Scrum with TFS 2010, so stay tuned for more.

Andrew Hall wrote a great post on the Code Analysis Team Blog about how to use the code analysis checkin policy with gated checkin in Team Foundation 2010 Build to reject checkins that have code analysis warnings or errors.  He shows you how to configure the rule set and set up the gated build definition to enforce the code analysis rules you’ve chosen.

Preventing check-ins to TFS that contain code analysis warnings

Recently we have received several questions regarding Visual Studio Code Analysis integration with Team Foundation Server’s check-in policy and build server, so I thought it would be helpful to clarify the behavior and expose some relatively hidden functionality.

more…

Enjoy!

In the past, we’ve turned on compression for the SOAP responses for the TFS web services.  In TFS 2010, you must do it manually.  In the future, I hope we have it turned on by default.  It’s particularly good for teams that aren’t at the same location as the TFS server.  For users on a high-speed corporate network, it’s not likely to matter.

Grant wrote a post on how to turn it on: TFS2010: How to enable compression for SOAP traffic.

Custom checkin policies and custom work item controls are great ways to take advantage of the extensibility of TFS.  You can use checkin policies to enforce certain standards on checkins (even in your builds).  Custom work item controls allow you to add controls to your work item forms that present data in particular way, access other systems, etc.  However, there’s no mechanism in Team Explorer to download and install these.

Youhana has written a post on how to use a feature in the power tools that not many folks know about.  By creating a couple of version control folders in each team project, you can have folks use the Team Members node in Team Explorer to download and install them.  This means that your users don’t need to know where to put the files on disk or the registry entries to create to make them work.  There’s not an auto-update mechanism there right now, so users will need to do this again if you subsequently update the dlls.  To get to this feature, you need to have the Team Foundation Server Power Tools installed on each machine where you want to use this feature.

Distributing custom check-in policies & WIT controls using team members

The team members component of the TFS power tools (available here) has a feature to help TFS users distribute custom check-in policies and WIT controls. Basically, the administrator would add the dlls containing the policies and components to a special folder in version control and users then can install the components using the “personal settings” dialog in team members. These are the detailed steps:

more…

Enjoy!

Neno’s been blogging a lot this month, and many of his posts have helpful tools associated with them.  The post below caught my eye as particularly useful.  We’ll be using HTML fields more going forward, and he has a tool to help you move your existing work items to use an HTML field for the Description.

Enriching your Work Item Descriptions by Moving them to a HTML field

In the Visual Studio Scrum 1.0 process template (and most likely in future process templates), Microsoft is using HTML fields with rich formatting for the work item description fields.

In VS Scrum 1.0…

• Product Backlog Items and Tasks are usingMicrosoft.VSTS.Common.DescriptionHtml.
• Bugs are using Microsoft.VSTS.TCM.ReproSteps instead.

You can customize your current process template and add a new HTML description today.

more…

Enjoy!

Unfortunately, we introduced a regression into Visual Studio 2010 SP1 in the process of fixing a performance issue in the build details view that a number of customers had reported (viewing the log was really slow for larger builds). We made this change late in SP1. I apologize for the inconvenience. I want to make sure you know about that patch if you hit the problem.

The fix is available at http://connect.microsoft.com/VisualStudio/Downloads/DownloadDetails.aspx?DownloadID=34824.

KB2522890 - VS10 SP1 crashes on build details from TFS 2008 build explorer

Issue Description
Visual Studio 2010 SP1 crashes or shows the following error when attempting to view a build report on a TFS 2008 server:

"TF50316: The following name is not valid. Verify that the name does not exceed the maximum character limit, only contains valid characters, and is not a reserved name"

Additional Information about the issue resolved by this Hotfix can be found in its Knowledge Base article at http://support.microsoft.com/kb/2522890

Test attachment data generated by the new testing features in VS 2010 can add a large amount of data to your TFS server.  In fact, we discovered on our own “dogfood” server that test data was taking up more space than the version control data.  You can read more about it in Grant’s post here.

You can use the Test Attachment Cleaner for Visual Studio Ultimate 2010 & Test Professional 2010 to delete old test data to reduce the size.  Here’s the description from that page.

Overview:

In Visual Studio 2010, with the introduction of Visual Studio Test Professional 2010 & Visual Studio Premium/Ultimate 2010 SKUs, testers can author manual and automated Test cases, configure the different diagnostic data collectors (as part of Test Settings), associate the Test Settings with Test Plan/Suites and then execute these test cases as part of Test Runs. The execution of a Test Run (whether automated or manual) generates a bunch of diagnostic data, which may be captured either automatically by the system or manually by the tester. This diagnostic data is critical in eliminating the “no repro” bug scenarios between the testers and developers.

However, the downside of this rich diagnostic data captures is that the system/user generated diagnostic data, over a period of time, can grow at a rapid pace and start taking up database space. With Visual Studio 2010, the database administrator has little or no control over what data gets attached as part of Test Runs – i.e., there are no policy settings he can control to limit the size of the data capture OR no retention policy to determine how long to hold this data before initiating a cleanup. In such scenarios, the Admin has no mechanism to:

1. Determine which set of diagnostic captures is taking up how much space AND

2. Reclaim the space for runs which are no longer relevant from business perspective.

The “Test Attachment Cleaner” powertool fills this void by serving both the above points.

[UPDATE 8/8/11]  The TFS 2010 power tools now provide rollback in the UI as described here.

Tonight Justin and I spoke to the Minnesota Visual Studio User Group.  It was completely unscripted, and we had a great time answering questions and telling a few stories (can you name the original code names for version control, work item tracking and load testing?).  Nearly everyone in the audience was using TFS, and many folks had already moved to TFS 2010.  We covered a lot of ground, touching on parts of VS and ALM – more than just TFS.  I got to thinking as folks were asking questions what might be the one TFS 2010 feature folks in the room probably didn’t know about.  I asked how many folks knew about rollback, and there were just a couple of hands.  I’m pretty sure they were thinking of the rollback command in the tfpt.exe power tool for 2008 and 2005.

We added a full-featured rollback command to tf.exe in Team Foundation Server 2010. You can only use it from the command line, so a lot of folks don’t know about it.  We had plans to add it to the UI (the rollback command was implemented very early in the 2010 development cycle), but higher priority work prevented us from getting to it.

The 2010 rollback command is implemented on the server, handles all of the change types, and it properly rolls back merge history so that it is as if the merge never happened if you roll back a merge (you can control that via a switch if you want a different behavior).

C:\Program Files\Microsoft Visual Studio 10.0\VC>tf rollback /?
TF - Team Foundation Version Control Tool, Version 10.0.30319.1
Copyright (c) Microsoft Corporation.  All rights reserved.

Rolls back the changes in a single or a range of changesets:
tf rollback /changeset:changesetfrom~changesetto [itemspec] [/recursive]
            [/lock:none|checkin|checkout] [/version:versionspec]
            [/keepmergehistory] [/noprompt] [/login:username,[password]]

tf rollback /toversion:versionspec itemspec [/recursive]
            [/lock:none|checkin|checkout] [/version:versionspec]
            [/keepmergehistory] [/noprompt] [/login:username,[password]]

Versionspec:
    Date/Time         D"any .Net Framework-supported format"
                      or any of the date formats of the local machine
    Changeset number  Cnnnnnn
    Label             Llabelname
    Latest version    T
    Workspace         Wworkspacename;workspaceowner

So, the next time someone checks in something accidentally (or worse!), you can roll it back easily!  We’ve done this internally a few times.  :-)

Enjoy!

[Update 3/16/11]  There is a KB article with TFS 2010 SP1 installation troubleshooting should you hit problems: http://support.microsoft.com/kb/2516423.

Problem

A customer ran into this issue, and I want to post it to help anyone else who hits it.  The symptom is that you install Service Pack 1 for Team Foundation Server 2010, and it fails.

At first, we looked at the KB log file, which is an HTML file named something like KB2182621_20110314_153652021.htm (after the KB number, it’s the date and time – one log will be generated per failed attempt).  That file doesn’t contain the error unfortunately, but towards the end you will find a reference to a file with a name like {some path}\KB2182621_20110314_153652021-Microsoft Team Foundation Server 2010 - ENU-MSP0.txt, as highlighted in the log snippet below.  In that log file you will find the real error (search for the word error until you find something that looks like the stack pasted at the end of this post).

Wait for Item (VS10-KB2182621.msp) to be available
VS10-KB2182621.msp is now available to install
Creating new Performer for Patches item

     Entering Function: BaseMspInstallerT >::PerformAction...

     Action: Performing Install on MSP: c:\7b04dc4d154aa5031a470fad\VS10-KB2182621.msp targetting Product: Microsoft Team Foundation Server 2010 - ENU...

        Successfully called MsiEnableLog with log file set to C:\Users\xxx\AppData\Local\Temp\KB2182621_20110314_153652021-Microsoft Team Foundation Server 2010 - ENU-MSP0.txt
        Log File C:\Users\xxx\AppData\Local\Temp\KB2182621_20110314_153652021-Microsoft Team Foundation Server 2010 - ENU-MSP0.txt does not yet exist but may do at Watson upload time
        about to call MsiInstallProduct with PATCH="c:\7b04dc4d154aa5031a470fad\VS10-KB2182621.msp" on product {BD8885BD-CFE2-3E43-99BC-33EC4E109EF5}(C:\WINDOWS\Installer\90c8f.msi) to install patches.
        Patch (c:\7b04dc4d154aa5031a470fad\VS10-KB2182621.msp) Install failed on product (Microsoft Team Foundation Server 2010 - ENU). Msi Log: 
        MSI returned 0x643

Entering Function: MspInstallerT >::Rollback...

exiting function/method

Here we found the following lines.  Bryan and Mahmoud found that the 0x80005000 error occurs when trying to access IIS through ADSI and IIS6 compat mode is not installed.  This was indeed the problem!

CAQuietExec: Exception Message: Unknown error (0x80005000) (type COMException)

CAQuietExec: Exception Stack Trace: at System.DirectoryServices.DirectoryEntry.Bind(Boolean throwIfFail)

Solution

Make sure IIS 6 Management Compatibility is turned on (Start –> Control Panel –> Programs –> Turn Windows Features On or Off)

Make sure the IIS Admin Service is running (Start –> Run… services.msc)

Here is the full error from the log to help anyone search for parts of it through a search engine.

CAQuietExec:   Invoking operation Stop on application pool: Microsoft Team Foundation Server Application Pool
CAQuietExec:   Exception while invoking operation Stop on application pool Microsoft Team Foundation Server Application Pool
CAQuietExec:  
CAQuietExec:  Exception Message: Unknown error (0x80005000) (type COMException)
CAQuietExec: 
CAQuietExec:  Exception Stack Trace:    at System.DirectoryServices.DirectoryEntry.Bind(Boolean throwIfFail)
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.Bind()
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.get_NativeObject()
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.Invoke(String methodName, Object args)
CAQuietExec:     at Microsoft.TeamFoundation.Admin.ApplicationPoolHelper.InvokeOperationOnApplicationPool(String appPoolName, String operation)
CAQuietExec: 
CAQuietExec:  Failed executing the command quiesce: Microsoft.TeamFoundation.Admin.ConfigurationException: An error occurred while invoking operation Stop on application pool Microsoft Team Foundation Server Application Pool. Please see the log file for additional details. ---> System.Runtime.InteropServices.COMException: Unknown error (0x80005000)
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.Bind(Boolean throwIfFail)
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.Bind()
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.get_NativeObject()
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.Invoke(String methodName, Object args)
CAQuietExec:     at Microsoft.TeamFoundation.Admin.ApplicationPoolHelper.InvokeOperationOnApplicationPool(String appPoolName, String operation)
CAQuietExec:     --- End of inner exception stack trace ---
CAQuietExec:     at Microsoft.TeamFoundation.Admin.ApplicationPoolHelper.InvokeOperationOnApplicationPool(String appPoolName, String operation)
CAQuietExec:     at Microsoft.TeamFoundation.Admin.ApplicationPoolHelper.StopApplicationPool(ApplicationPoolType type, Boolean waitForWorkerProcessTermination)
CAQuietExec:     at Microsoft.TeamFoundation.ServiceControl.TfsServiceControl.QuiesceApplicationTier()
CAQuietExec:     at Microsoft.TeamFoundation.ServiceControl.TfsServiceControl.Quiesce(IEnumerable`1 featureList)
CAQuietExec:     at Microsoft.TeamFoundation.ServiceControl.TfsServiceControl.Main(String args)
CAQuietExec:  > Inner Exception:
CAQuietExec:  System.Runtime.InteropServices.COMException (0x80005000): Unknown error (0x80005000)
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.Bind(Boolean throwIfFail)
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.Bind()
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.get_NativeObject()
CAQuietExec:     at System.DirectoryServices.DirectoryEntry.Invoke(String methodName, Object args)
CAQuietExec:     at Microsoft.TeamFoundation.Admin.ApplicationPoolHelper.InvokeOperationOnApplicationPool(String appPoolName, String operation)

If you are responsible for work with your team’s build system, you will definitely want to buy a copy of Inside the Microsoft Build Engine: Using MSBuild and Team Foundation Build (Second Edition).  Both of the authors now work for Microsoft.  William Bartholomew is part of the central engineering team and has been building the infrastructure to allow Team Foundation Build to be used as the build system for all of the developer division.  You can follow that progress and find more info on team build on his blog.  Sayed Ibrahim Hashimi works on the web platform team, and he writes a lot about building web projects on his blog.

This second edition contains extensive coverage of build in Team Foundation Server 2010, which introduced Windows Workflow Foundation (WF) as the new build process orchestration mechanism.  WF provides a fantastic platform for your build process needs, and this book helps you get over the learning curve and become productive faster.

I highly recommend it, and the reviews on Amazon are further testimony to how valuable this book is.

Vishal Joshi, lead program manager for web platform tools, has a great blog covering using various project types with Team Foundation Build.  Here’s a selection of his posts on using team build, which I highly recommend if you are working with web projects.

• Team Build + Web Deployment + Web Deploy + VS 2010 = Goodness

• Web Packaging: Creating web packages using MSBuild

• Web Deployment Painkillers: VS 2010 & MS Deploy

• Web Application Project Vs Web Site

Question: Can a TFS 2010 Team Project Collection (TPC) on SQL Server 2008 Enterprise be down converted to SQL Server Standard 2008 edition?

Answer: This is covered in the 2010 Upgrade guide post.

The script is: exec prc_EnablePrefixCompression @online = 0, @disable = 1

(answer provided by Ed Holloway)

Cameron Skinner has announced a new command line tool for generating code metrics.  We’ve long gotten requests to be able to generate code metrics from the build.  Prior to this tool, code metrics could only be generated from within the Visual Studio IDE.

I installed it this morning.  The readme link on the download page tells you where it is installed, which is %programfiles%\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop.

I wanted to do the simplest possible thing (i.e., quick and dirty!) I could to give it a try this morning as part of a 2010 TFS build.  I grabbed the copy of Professional Application Lifecycle Management I happened to have sitting here on my desk at home (thanks, Martin) and turned to page 504 to follow the ZIP archive example to get me started.  You can get the entire build chapter for free (same with the manual testing chapter).

1. Open up the default build process template in the WF designer (e.g., open the build definition, click Show Details on the Process tab, click on the hyperlink, and double click the file)
2. Scroll to the bottom of the workflow.
3. Drag an InvokeProcess activity into the build process.  Drop it in as the last activity in the Try, Compile, Test sequence (drop it after the symbol activity, just before the catch block).
4. Right click on the InvokeProcess activity and show parameters
5. Set the following properties, fixing up the paths for your machine and the hard-coded assembly name (like I said, I went for the quick and dirty just to see it work).
   1. Arguments: String.Format("/f:""{0}"" /o:""{1}""", System.IO.Path.Combine(BinariesDirectory, "ConsoleApplication1.exe"), System.IO.Path.Combine(BinariesDirectory, "out.xml"))
   2. DisplayName: Code Metrics
   3. FileName: "D:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\metrics.exe"
6. Drop a WriteBuildMessage into the bock for the standard output and a WriteBuildError for the error output.
7. Set the following for WriteBuildMessage
   1. Importance: Microsoft.TeamFoundation.Build.Client.BuildMessageImportance.High
   2. Message: stdOutput
8. Set the following for the WriteBuildError
   1. Message: errOutput

Then I checked in my build template changes and ran a build.  The drop folder now contains a file called out.xml with the code metric data in it.

You can find documentation on all of the activities here on MSDN.

Enjoy!

[UPDATE 1/30/10]  Martin sent me the links to the build and testing chapters, which I’ve added above.

The folks who produce our documentation continue to experiment and find ways to improve our documentation.  The most recent change involves consolidating docs.  I’d encourage you to take a look and give them feedback.

Significant Changes Made to Streamline the Content for Work Item Type Schema Reference

A move has been afoot to eliminate topics that no one is reading anyway. By consolidating content into a smaller topic set, we believe that you will more easily access the information that supports you in accomplishing your tasks. In the area of defining and customizing the definitions of work item types, this initiative has represented a significant rework to the content that was previously published under the Work Item Type Schema Reference topic node.

We have made the following changes to this content area:

• Consolidated content so that you can access the syntax structure and attribute definitions of all elements that support  specific functional tasks - such as the definition of fields, workflow, and work item forms.

• Kept and updated specific XML element reference topics that warrant keeping, such as the FIELD (Definition) and Control elements.

• Renamed and enhanced topics to include attribute definitions and examples.

• Eliminated all remaining reference topics whose content had been consolidated, this included many of the element definition and all of the schema definition topics.

continued…

Do you want to be a developer on the TFS team, solve challenging problems, and break new ground in ALM?  Then join the TFS development team in Redmond, WA.

You’ll notice that we mention cloud computing with Azure below.  If you saw the PDC keynote demos this year, you saw some early work on getting TFS running on Azure.  If you missed it, go to the 2:09:50 mark of the “PDC10 keynotes with Steve Ballmer and Bob Muglia” recording on the PDC10 site to see Brian Harry demo TFS on Azure (Brian also wrote a blog post about TFS on Azure).  We’re working on great new features with some very exciting technology.

Software Development Engineer (Redmond, WA)

Did you know that 30% of all software projects are cancelled, nearly half come in over budget, 60% are considered failures by the organizations that initiated them, and nine out of ten come in late? Join us to help change the industry!

Visual Studio Team Foundation Server is the industry leader in application lifecycle management (ALM) tools – helping software teams build better software faster. TFS provides project management, version control, build, and ALM analytics. We are building our services in the cloud using Windows and SQL Azure platforms and making TFS available 24x7 over the internet.

We have an opening for a talented and highly motivated software developer with a passion for algorithms and client/server software. You will design and implement key features for TFS. The position will require you to have or gain extensive knowledge of one or more of these technologies: WPF, ASP.NET, Visual Studio Industry Partner (VSIP) API, Web Services, WinForms, C#, and the .NET Framework. We’re looking for a candidate who seeks big challenges as part of a strong team and can mix great collaboration skills with an ability to work independently and deliver well thought out solutions to tough problems.

If you enjoy solving tough problems and being part of a great team that’s making software development better, join TFS!

Key Responsibilities:

• Design and implement highly scalable, high performance work item tracking features.
• Deliver state-of-the-art solutions for work breakdown and management with focus on delivering exceptional user experience.
• Participate in prioritization activities by identifying technical issues early and throughout the end-to-end software development lifecycle

The ideal candidate would have the following qualifications:

• 2 - 4 years of commercial software development experience
• Exceptional problem solving skills
• Strong coding and debugging skills
• Excellent UI design skills
• Good understanding of efficient data structures and algorithms
• A proven track record of shipping quality software
• Capable of working independently and within a team
• Passion for engineering excellence, learning and advancement
• Sound understanding of multi-tiered system architecture
• Experience with Scrum or other agile methodologies is a big plus

We also have openings for program managers and testers.

• Senior Program Manager, North Carolina
• Software Development Engineer in Test, North Carolina

See updated post.

Please take a moment to provide feedback to the documentation team on the changes they’ve made recently.  They want to know what you think.  Thanks!

We need your input on how well our improvements to the MSDN Library content work for you. Allen Clark has reorganized the topic: "Extending Visual Studio Application Lifecycle Management" and would like to know if these updates make the topic more useful for you:

"I've been working on streamlining some content in an effort to make it easier for you to get the information that you need. The first place I did this was in the Team Foundation SDK, in Extending Team Foundation and Extending Work Item Tracking. I'm looking at doing the same thing for Extending Visual Studio Application Lifecycle Management. Here's the topic in its streamlined form. I'd like to hear back from anyone who uses the APIs for VSALM and Team Foundation to learn whether this works well for you, compared to the previous version. Any other feedback on this topic is also welcome, of course. For example, I think that it's clear that this topic could use a more thorough discussion of the API set for ALM as a whole."

To learn more, please click here.