Recommendations for setting up a Visual Studio Solution for TFS

This document assumes a namespace convention for your projects and solutions of CustomerName.ProjectName.LayerOrAppName. The solution will be called CustomerName.ProjectName and each project then gets its own suffix explaining what it's used for. In this article I'll use CustomerName.ProjectName literally, but obviously you would substitute that for a real client and project name.

Setting up the Solution in Visual Studio

1. Start Visual Studio (I am using 2010 but this applies to older and newer versions as well) and choose File | New Project.
2. In the Other Project Types category click Visual Studio Solutions and then click Blank Solution. As the name of the Solution, enter ClientName.ProjectName and as the Location choose C:\Projects:
   
   

   
   Figure 1 (click to enlarge)

3. Click OK.
4. Close Visual Studio and open the Project folder in Windows Explorer (at C:\Projects\ClientName.ProjectName). Create a new folder called Main and then drag all of the ClientName.ProjectName.* files from C:\Projects\ClientName.ProjectName into this new main folder. Your structure now looks like this:
   
   

   
   Figure 2 (click to enlarge)

   This Main folder is used later for Branching in TFS. (This all feels a bit clumsy but I see no other way to create the solution with this name and store it in a folder called SolutionName/Main. Fortunately, this is a one-time operation.)

5. Open the Solution in Visual Studio by double-clicking the .sln file in the Main folder.
6. Right-click the Solution in the Solution Explorer and choose Add | New Project.
7. In the tree on the left, choose a project type such as an ASP.NET MVC 3 Application.
8. As the name of the project, enter ClientName.ProjectName.Web.
9. As the location for the project enter C:\Projects\ClientName.ProjectName\Main\Applications:
   
   

   
   Figure 3 (click to enlarge)

10. Click OK and finalize the project configuration.
11. On disk, your solution now has the following structure:
    
    

    
    Figure 4 (click to enlarge)

12. Right-click the Solution again and now add a Class Library project named ClientName.ProjectName.Lib. As the Location for the project, choose C:\Projects\ClientName.ProjectName\Main\Applications again:
    
    

    
    Figure 5 (click to enlarge)

13. Add a reference to the Lib project from the Web project and perform any other necessary project setup and initialization. Add other projects as needed, storing each of them in the C:\Projects\ClientName.ProjectName\Main\Applications.
    
14. [Optional] Right-click the Solution again and add a test project. Call it ClientName.ProjectName.Tests.UnitTests and store it in the folder: C:\Projects\ClientName.ProjectName\Main\Tests:
    
    

    
    Figure 6 (click to enlarge)

15. [Optional] Create more test projects such as ClientName.ProjectName.Tests.Integration and store each of them in the folder C:\Projects\ClientName.ProjectName\Main\Tests.
    
16. [Optional] In your test projects, add references to your various application projects (such as the Web and Lib projects).
    
17. [Optional]: Create a new Solution Folder called Tests (right-click the Solution and choose Add | New Solution Folder) and then drag your test projects into this folder. This keeps all your test projects nicely packed together. Your Solution Explorer should now look like this:
    
    

    
    Figure 7

    while on disk your Solution should look like this:
    
    

    
    Figure 8 (click to enlarge)

18. Finalize the configuration of your projects and do a full rebuild to ensure everything is set up correctly. Resolve any compilation errors you may have.
    

With this setup, all your projects are located in sub folders of the Main folder that contains the Solution File. This in turn makes it easy to manage the solution from a TFS point of view because all references between the various projects and assemblies can be resolved relative to the main solution.

If you ever have the need to add new projects, just follow the exact same steps: add applications under the Applications folder and tests under the Tests folder. When another developer then gets a latest version of the solution from source control, the new projects are downloaded automatically as well. Obviously, in order for all this to work, you need to add the solution to Team Foundation Server Source Control first, which is the topic of the next section.

TFS Initial Setup

1. Right-click the Solution in the Solution Explorer and click Add Solution to Source Control.
2. Choose a Team Project and click Connect.
3. Choose the appropriate TFS Project
4. As the name for the solution folder, enter ClientName.ProjectName/Main The /Main part is not a typo. In fact, it's very important, as it’ll create an additional folder in TFS which you can set up as main branch later.
   
   

   
   Figure 9

5. Click OK.
6. Your Source Control Explorer should now look like this:
   
   

   
   Figure 10 (click to enlarge)

7. Right-click the Solution Explorer and choose Check In.
8. As a comment, enter something like Initial Commit and click Check In.
9. Open the Source Control Explorer, locate the Main folder for this Solution, right-click it and choose Add Items to Folder. Double-click the Packages folder and then press Ctrl+A to select all files and folders. Click Next and then on the Excluded Items tab make sure no files or folders are selected (select those that are and click Include Item(s)). Normally, you want to exclude files such as assemblies as they can be considered recreatable. However, the Packages folder contains third party libraries (by default, this folder is created by the Nuget Package Manager, but I now use Packages for my own third-party assemblies as well) that you do want included in TFS to ensure everyone gets the necessary files when getting a latest version of that folder from TFS. Click Finish to add the files. Then right-click the Packages folder and click Check In Pending Changes to add the files to TFS.
10. Still in the Source Control Explorer, locate the Main folder for this Solution, right-click it and choose Branching and Merging | Convert to Branch.
11. Enter a description such as Main Branch and click Convert.
12. That’s it. From now on, other developers can get a local copy of this Solution simply by opening the .sln file from the Main folder. If they need a copy of the Packages folder as well, they can simply right-click it in the Source Control Explorer and choose Get Latest Version.

TFS Branching

After some time, development on the Main branch can be ready for a release. In order to let developers continue work on the Main branch while you prepare the release, you should branch the application. For example, you can branch of “Beta 1” and release that.

Note: in this model I assume the Main branch is where continuous development takes place, while releases are branched off this main branch. If you use a different branching model this section does not apply directly, but the principles remain the same.

In order to create the branch, follow these steps:

1. Open the Source Control Explorer, locate the Main branch, right-click it and choose Branching and Merging | Branch. As the Target Branch Name enter something like $/Projects/ClientName.ProjectName/Beta1:
   
   

   
   Figure 11

2. Click Branch

You now have two separate branches of the same application. Long-term development goes on in the Main branch while you can make changes to Beta 1 necessary for the release. In addition, bugs you find in Beta 1 can be fixed there and propagated to the Main branch or vice versa.
If you want to work on the Beta 1 version, double-click its .sln file in the Solution Explorer. Then enter C:\Projects\ClientName.ProjectName\Beta1 as the path for the application so your two branches end up side-by-side on your disk. In addition, you may need to get a local copy of the Packages folder in order to get all of the third-party assemblies and other files.

Hope you find these instructions useful. And if you have improvements or alternatives: post them below using the comments feature!