Now for something completely different. Recently I had the desire to build a Visual Studio 2010 solution file for a number of project files under a directory. There were many projects, and each one linked to a solution file – but I wanted a “master” solution file.. one to rule them all(?)
Generally, I hate manual repetitious tasks, and laboriously adding all the projects to a new, blank, solution file seemed tedious and not fun one bit. Then I decided that I’d write a program which would iterate all the projects and create a solution file for me. Sounds simple enough, right?
Well, it took me on a journey into Visual Studio automation. There are many facets of working with VS, as I found out, and backwards compatibility reigns supreme. What I’m going to introduce you to is pretty much just for Visual Studio 2010, but in the right hands a design could come which supports versions dating back to Visual Studio 2005.
- Visual Studio 2010 (obviously)
- Visual Studio 2010 Service Pack 1
- In order to follow along, you may need to download the source of the MPF for Projects – Visual Studio 2010 project from codeplex for future parts to this article series.
- There is also a chance you might require the Visual Studio 2010 SP1 SDK, although I haven’t had a need for it just yet.
- These can’t hurt either: Visual Studio 2010 Productivity Power Tools (February 2011) if you don’t have it already (the screenshots reflect this being installed)
Once you’ve got your system all nicely configured, we’re ready to begin.
To begin with, I created a Class Library. My intention was to create a large amount of nice, reusable automation for integration into Team Build, utilities and so forth. You never know when this is going to be very, very handy.
To start our journey, I decided that my requirement was going to be very simple (for Part 1): create a blank solution file using Visual Studio 2010. Easy enough, right? Well, as you’d expect, the devil is in the details. This took me quite a bit of time to get right, but in the end the outcome was most pleasing.
So open up Visual Studio, create a project type you’d prefer and then ready the project, as so:
- Add a reference
- Pick the COM tab
- Scroll and select “Microsoft Development Environment 10.0”
- This will add several COM interop assemblies to your project (and also include the previous versions)
- Click on the .Net tab and select “Microsoft.VisualBasic” (even if you aren’t coding in Visual Basic)
Now it is time to go code us up a simple solution. I’m going to be working on a far more robust library, but in the meantime this will introduce you to the extremely powerful DTE and DTE2 objects.
We have to (sadly) instantiate a COM object wrapper, which will actually load devenv in a non-interactive mode, from which we can then cherry pick functionality we’d like to use. For this demo, we’re just going to create a Visual Studio 2010 compatible solution file.
Consider the following very simple class:
public static class SolutionHelper
public static void CreateSolution(string path, string solutionName)
DTE2 dte2 = (DTE2)Microsoft.VisualBasic.Interaction.CreateObject("VisualStudio.DTE.10.0", "");
Solution4 solutionObject = (Solution4)dte2.Solution;
You will notice that we create a COM object instance using the VisualBasic namespace. When the code actually creates the object, under the hood, the machine will see an instance of Visual Studio created (but no GUI):
Once it is loaded, we can get access to the VS Solution functionality. From here, it is a simple matter of supplying the path and solution name (omit the .sln extension) and, assuming all goes to plan, you will have the following output:
Obviously this is just the tip of the iceberg.
We have so much powerful functionality to exploit, so we won’t stop at this. Since we’ve achieved our objective for Part 1, we’ll wrap up here, but check back for Part 2 where we’ll populate the solution file with existing (or new) projects!
In the next part, we’ll also discuss ways of supporting the older versions (Visual Studio 2008 and 2005) as well as providing a more verbose sample.