• Windows allows a maximum of 15 icon overlays in the system even Windows 7 (http://blogs.msdn.com/b/oldnewthing/archive/2009/12/09/9934348.aspx for more information on that and why)
• So basically the shell respects the first 15 icon overlays in the system (sorted in alphabetical order)
• To find the icon overlays in the system you can go to “HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\explorer \ShellIconOverlayIdentifiers” on your machine and figure out how many overlays are installed
• If you have dropbox, groove or tortoise SVN installed the number of overlays intalled in the system will exceed 15. But windows will only respect the fist 15 in alphabetical order. We name our overlays “TfsOverlayAdd”, “TfsOverlayEdit” etc. and Tortoise SVN name their overlays “1TortoiseNormal”, “2TortoiseModified” etc. So alphabetically they come as top as possible in the list. And we usually end up being bumped down the list and thus a subset or all of overlays might not work if Tortoise SVN or drop box are installed.

To fix the problem using a hacky solution you can (Note: This is really a hacky solution and the product was not designed for this):

1. Open the registry
2. Go to : HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\explorer \ShellIconOverlayIdentifiers
3. Rename our icon overlays to “1TfsOverlayAdd” , “2TfsOverlayEdit” etc. to bump us up the list
4. Restart the machine or kill explorer.exe and restart it

1- Create two folders one for the check-in policies and one for the custom controls called $/[ProjectName]/TeamProjectConfig/CheckinPolicies & $/[ProjectName]/TeamProjectConfig/CustomControls respectively.

2- Add the dlls containing the check-in policies and custom controls under each folder correctly.

3- To install the components on any client, right click on the team members node in team explorer and execute “Personal Setttings” which will bring up the personal settings dialog. From this dialog check the install check box (you can optionally choose to verify if the dlls are signed or not) and then click download. This will download the dlls to your local computer, validate them and then install the correct keys in the registry to enable the check-in policies and custom controls.

Hope this feature comes in handy for distributing these components.

Wish you a Happy New Year :)

   1: using System;

   2: using Microsoft.TeamFoundation.Client;

   3: using Microsoft.TeamFoundation.VersionControl.Client;

   4:  

   5: namespace DisplayAllBranches

   6: {

   7:     class Program

   8:     {

   9:         static void Main(string[] args)

  10:         {

  11:             string serverName = @"http://[SERVERNAME]:8080/tfs";

  12:  

  13:             //1.Construct the server object

  14:             TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri(serverName));

  15:             VersionControlServer vcs = tfs.GetService<VersionControlServer>();

  16:  

  17:             //2.Query all root branches

  18:             BranchObject[] bos = vcs.QueryRootBranchObjects(RecursionType.OneLevel);

  19:  

  20:             //3.Display all the root branches

  21:             Array.ForEach(bos, (bo) => DisplayAllBranches(bo, vcs));

  22:             Console.ReadKey();

  23:         }

  24:  

  25:         private static void DisplayAllBranches(BranchObject bo, VersionControlServer vcs)

  26:         {

  27:             //0.Prepare display indentation

  28:             for (int tabcounter = 0; tabcounter < recursionlevel; tabcounter++)

  29:                 Console.Write("\t");

  30:  

  31:             //1.Display the current branch

  32:             Console.WriteLine(string.Format("{0}", bo.Properties.RootItem.Item));

  33:  

  34:             //2.Query all child branches (one level deep)

  35:             BranchObject[] childBos = vcs.QueryBranchObjects(bo.Properties.RootItem, RecursionType.OneLevel);

  36:  

  37:             //3.Display all children recursively

  38:             recursionlevel++;

  39:             foreach (BranchObject child in childBos)

  40:             {

  41:                 if (child.Properties.RootItem.Item == bo.Properties.RootItem.Item)

  42:                     continue;

  43:  

  44:                 DisplayAllBranches(child, vcs);

  45:             }

  46:             recursionlevel--;

  47:         }

  48:  

  49:         private static int recursionlevel = 0;

  50:     }

  51: }

The result of this code will be something like this:

for a hierarchy like this:

I am a soccer fan, I also watch tennis & basketball but only soccer gets to me. A couple of weeks ago Netherlands and Spain played in the world cup final. Originally, I did not know which team I really wanted to win, I always loved Netherlands (I loved Marc Overmars for those who remember they 1998 world cup my heart was broken when Netherlands lost against Croatia in the 3rd place match) and I always looked up to Spain as the best soccer team to not win the world cup and not ever be in a final. As the game progressed I found myself rooting for Spain, the Spanish team won my soccer heart. Looking at how they were able to defeat Netherland as a team inspired me to look at what lessons I can learn from them as software developer.

So what can I learn from the Spanish team's journey in this world cup ?

1. Ball Possession --> Consistency in User Experience : The first trait and the main reason for Spain's victory in my opinion is their high ball possession percentage. Not only in the final game but in all the games they played in the world cup the averaged 68%. The Spanish team is CONSISTENT with regards to their ball possession. If the Spanish team was a piece of software, their users will love them because of their consistency in experience.  When designing software that interacts with users I need to be consistent in the experience my software provides. I should not have a different UI design/experience for different features, one that exposes options through menus, other that uses tool bars etc. Inconsistency hurts the software's (1) Trust ability - you have higher probability that your users will lose trust in your software (2) Learnability - users will have a hard time learning your software cause they need to learn using every feature in a different manner (plus other things but I will stick with these 2 for now).
2. Number of Goals --> Features : Spain might be the nation to win the world cup with the least number of goals ever. If goals were to soccer like features are to software, the Spanish team would be the piece of software with the least number of features that customer love and prefer over other feature loaded software. When developing software I need to find the right balance of the number of features to have and the quality of those features and how they interact together. In my opinion It is better to have a smaller set of elegant, complete, easy to use features that the customers fall in love with than have an application fully loaded with hundreds of features that just do not go together or that are not well thought of.
3. Substitutions --> React to customer needs : Watching how the coach used his substitutions (I am talking about Navas and Fabregas here not Tores) to change the game made me think, as a software engineer I need to be the coach of my software. I need to understand what is not working well in my software for the customer and substitute those features. I need to understand how my customer uses my software and make the right moves to win the customers over. I need to find out what are the features that I can add that will change the game and make my software better.

There is a lot that we can learn from soccer in life … looking forward to World Cup 2014 lessons :)

You can get this list programmatically by accessing the Identity Management Service. This is a sample code that will do so :

   1: using System;

   2: using Microsoft.TeamFoundation.Client;

   3: using Microsoft.TeamFoundation.Framework.Client;

   4: using Microsoft.TeamFoundation.Framework.Common;

   5:  

   6: namespace DisplayTeamMembers

   7: {

   8:     class Program

   9:     {

  10:         static void Main(string[] args)

  11:         {

  12:             string serverName = @"http://SERVERNAME:8080/DefaultCollection";

  13:             string groupName = @"[ProjectName]\Contributors";

  14:  

  15:             TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri(serverName));

  16:             

  17:             //1.Get the Idenitity Management Service

  18:             IIdentityManagementService ims = tfs.GetService<IIdentityManagementService>();

  19:  

  20:             //2.Read the group represnting the root node

  21:             TeamFoundationIdentity rootIdentity = ims.ReadIdentity(IdentitySearchFactor.AccountName,

  22:                 groupName, MembershipQuery.Direct, ReadIdentityOptions.None);

  23:  

  24:             //3.Recursively parse the members of the group

  25:             DisplayGroupTree(ims, rootIdentity, 0);

  26:  

  27:             //4.Exit

  28:             Console.WriteLine("Press any key to exit...");

  29:             Console.ReadKey();

  30:         }

  31:  

  32:         private static void DisplayGroupTree(IIdentityManagementService ims, TeamFoundationIdentity node, 

  33:             int level)

  34:         {

  35:             DisplayNode(node, level);

  36:  

  37:             if (!node.IsContainer)

  38:                 return;

  39:  

  40:             TeamFoundationIdentity[] nodeMembers = ims.ReadIdentities(node.Members, MembershipQuery.Direct, 

  41:                 ReadIdentityOptions.None);

  42:  

  43:             int newLevel = level + 1;

  44:             foreach (TeamFoundationIdentity member in nodeMembers)

  45:                 DisplayGroupTree(ims, member, newLevel);

  46:         }

  47:  

  48:         private static void DisplayNode(TeamFoundationIdentity node, int level)

  49:         {

  50:             for (int tabCount = 0; tabCount < level; tabCount++) Console.Write("\t");

  51:  

  52:             Console.WriteLine(node.DisplayName);

  53:         }

  54:     }

  55: }

Last week Brian Harry announced the availability of the TFS 2010 Power tools in one of his blog posts. I had the pleasure to work on the Team Members power tool enhancements for this release which are:

• Customized Instant Messaging settings – Now Team Members can work even if Active Directory doesn’t have email addresses or, as is the case for many at Microsoft, your IM address is different than your email address.  We added a tab to allow users to customize their Instant Messaging username and address. This enables greater flexibility for integrating with your preferred IM profiles and tools.
• The ability to launch communicator by double clicking on the identity
• More async operations (save settings)
• Improved error handling (now in the output window).

In this blog post, I will explain how did we utilize the TFS Properties Service (a new service that shipped in TFS 2010) to enrich the Team Members power tool and make the “Customized Instant Messaging Settings” feature possible. I will start with a quick overview of the feature in TFS 2010 Power tools compared to TFS 2008 Power tools. I will then give a quick over view of how this feature works under the hood in TFS 2010 and how was this feature enriched using TFS Properties Service.

This is how the team members node look like in team explorer. The team members node basically lists the users you have in the contributor group by default (this can be changed and customized). If you have Office Communicator or MSN Messenger installed on the machine, team members will automatically integrate with your IM to enable you to send IM message from inside VS (by double clicking on the node in 2010 or right click –> send instant message in 2008).

In TFS 2008 team members power tool pulled out the IM user name of each node (user) from the information stored in TFS that are synced from Active Directory email addresses. This imposed a limitation on the tool and made it only usable in an environment where your IM address is the same as the email address stored in Active Directory. The IM features of the tool were not enabled other wise. This blocked users that have different IM and Email address.

In TFS 2010 team members power tool we wanted to give the user the ability to publish a custom IM address so that his/her peers can automatically communicate with him via the IM address of preference. To make this possible we needed a centralized repository to store the custom IM address of the user. The centralized repository needed to be accessible by all users. TFS 2010 shipped a new service called the “PropertyService” that can be used by VS or any other third party tools to write generic, queryable data that will be stored in the server DB. The property service allows you to store a key value list of data per artifact (I will show a more detailed example below).

In the 2010 release of the power tool, the user can customize his/her IM address from the personal settings dialog shown above. We used the Property Service to store the custom IM address specified by the user on the server. This custom IM address is stored in the TFS DB using the Property Service and is retrieved by other users when needed. The Property Service enabled us to store custom data out of the box without the need to do any modifications to the server.

TFS Property Service

The Property Service basically provide the capability to store and retrieve a name/value list for each artifact. An artifact can be anything you want to associate data with and is identified by an artifact spec. An artifact spec is composed of three main identifiers (1) Artifact kind (2) Artifact Id or Moniker (3) Version number. TFS 2010 ships with the following artifact kinds out of the box:

Framework : (1) Generic (Can be accessed by methods in Microsoft.TeamFoundation.Framework.Client.IPropertyService)

Version Control : (1) Changeset (2) Versioned Item (3) Pending Change (4) Annotation (Can be accessed by methods in Microsoft.TeamFoundation.VersionControl.Client)

There is a couple of things that you need to decide before making use of the Property Service in any third party tool you are designing:

1- Which artifact kind to use ? For the team members power tool we used the generic artifact kind since the data we are storing were is not related to any of the version control kinds.

2- What is the best moniker ? The moniker is a string value that acts as the identifier of your artifact. First, you need to make sure that the name you chose is unique and will not conflict with a name that can be chosen by someone else later. Second, you need to design your moniker in such a way that you will be able to retrieve all of your custom data in a single server call using wild cards e.g. ToolName_ArtifactName. This will enable you to retrieve all the properties your tool stored on the server by querying “ToolName_*” using a single server call instead of calling the server for every artifact you stored e.g. Artifact1 , Artifact2 etc.

3- Where are you going to store your properties on the instance level or collection level ? The Property Service exists on the instance level and on the collection level, you need to decide where you want to store your data. For team members the data was not related to a specific collection so we stored it on the instance level so that our power tool can access it no matter which collection you are connected to.

Setting TFS Properties

The code snippet below shows how to set a single property on the instance level.

   1: string serverName = @"http://server:8080/tfs/DefaultCollection";

   2:  

   3: TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri(serverName));

   4:  

   5: // You also need to decide whether you want to store the properties 

   6: // on the Instance level e.g. tfs.ConfigurationServer.GetService<IPropertyService>();

   7: // or on the collection level. 

   8: IPropertyService ps = tfs.GetService<IPropertyService>();

   9:  

  10: // Need to check whether the property service is supported or not 

  11: // because it is not available on older servers

  12:  

  13: ArtifactSpec artifactSpec = new ArtifactSpec(ArtifactKinds.Generic, "TeamMembers_User_General_User1Id", 0);

  14:  

  15: ps.SetProperty(artifactSpec, "TeamMemberPowerToolProperties.InstantMessagingId", "CustomIm@hotmail.com");

Getting TFS Properties

This code snippet shows how to retrieve all properties that match a specific pattern from the server using a single server call.

   1: string serverName = @"http://server:8080/tfs/DefaultCollection";

   2:  

   3: TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(new Uri(serverName));

   4:  

   5: // You also need to decide whether you want to store the properties 

   6: // on the Instance level e.g. tfs.ConfigurationServer.GetService<IPropertyService>();

   7: // or on the collection level. 

   8: IPropertyService ps = tfs.GetService<IPropertyService>();

   9:  

  10: // Need to check whether the property service is supported or not 

  11: // because it is not available on older servers

  12:  

  13: ArtifactSpec artifactSpec = new ArtifactSpec(ArtifactKinds.Generic, "TeamMembers_User_General_*", 0);

  14:  

  15: ArtifactPropertyValue[] values = ps.GetProperties(artifactSpec, null);

I hope this blog post was a good introduction to the Property Service and how can it be utilized to enrich your tools.

Q: When I do a “Get” TFS does not get the files I requested?

A: I heard this complaint from a couple of TFS users. The user scenario here is

1. The user synced his workspace to local disk
2. The user then deletes some files from the local disk
3. When the user executed get again from VS or using “tf get”
4. VS prompts the user with a message saying “All files are up to date.”

The reason that this is happening is that TFS server keeps track of the version for every file you last downloaded and will not do an subsequent downloads unless a newer version of the file exists on the server.

To mitigate this problem you need to execute “Get Specific Version” and check the force flag and that will force the server to sync your files again.

Q: Does Microsoft use TFS internally?

A: Yes. Microsoft uses TFS internally in some divisions. My team dogfoods (uses) TFS as our source control / bug tracking / build system. Brian Harry usually blogs out our internal TFS offerings. Here is his latest post about that.

Q: Can I force my developers to only check-in when their changes build?

A: Yes, a new feature called “Gated Check-in” was developed in TFS 2010 to address this issue. In this feature basiclly when the developer clicks “Check-in” he/she is prompt to start a build to submit the changes. If the build completes successfully, the changes are checked in. For a demo of this feature you can read, Jim Lamb’s our Team Build’s PM post about gated check-in here.

Q: Can I undo my changes when I am working offline?

A: No. For TFS 2005/2008/2010 the user has to be connected to be able to undo a change. This request aligns with an enhancement that is planned for later releases around the experience of working offline. For TFS 2010, we did a lot of enhancements in the Offline Experience when working with bound solutions and projects. However, you still need to be connected to be able to undo your changes.