Click here to Skip to main content
13,633,585 members
Click here to Skip to main content
Add your own
alternative version


31 bookmarked
Posted 20 Dec 2007
Licenced CPOL

Lexware Assembly Reference Tool for Visual Studio 2005 / 2008

, 16 Aug 2010
Rate this:
Please Sign up or sign in to vote.
Visual Studio 2005 / 2008 both lack a good way to define assembly references per solution configuration (‘Debug’ or ‘Release’). This tool fills this gap.

Sample Image - maximum width is 600 pixels


Visual Studio 2005 / 2008 both lack a good way to define assembly references per solution configuration (‘Debug’ or ‘Release’).


There are some ways to define assembly references which change if the solution configuration changes, but they are not sufficient for larger projects. The following features of Visual Studio 2005 / 2008 are fine for small projects:

  • Set a Project reference from one project to another. The projects must be all in one solution. This is not always possible in projects where a lot of developers are working on multiple projects lying in different solutions.
  • Set a reference to an assembly lying in the output path of the project. Visual Studio 2005 searches for assembly references first in the output path of the project. A way to define assembly references per solution configuration is to put all assemblies in a common output directory (MSDN Article). This is inflexible.

The Lexware Assembly Reference Tool fills this gap, by providing a new tool window in Visual Studio 2005 / 2008, which allows you to change ‘hard-coded’ assembly reference paths to flexible reference paths which change depending on the solution configuration. The tool detects ‘Debug’ or ‘Release’ in the assembly reference path and marks the assembly in red to show you the potential problem you have, when you build the project in another configuration. You only need to press a button and all these paths will be converted to paths which depend on the configuration of the project.


Additionally, the tool provides the following features:

  • Change the ‘Copy Local’ property
  • Manipulate the ‘Special Version’ property
  • Edit the assembly reference path (‘HintPath’)
  • Convert a project reference into an assembly references
  • Delete an assembly reference

Context menue

After installing and starting the Add-In, you can open the assembly reference tool via the Visual Studio 2005 / 2008 tools menu.


How It Works

The General Idea Behind It

The tool allows flexible assembly reference paths by replacing “\Debug\” or “\Release\” in the reference path against “\$Configuration\”, which is a placeholder for the solution configuration in Visual Studio 2005 / 2008. Visual Basic and CSharp projects are able to replace the placeholder back to “\Debug\” or “\Release\” when trying to resolve an assembly path.

Since the Visual Studio 2005 / 2008 object model doesn't allow any change to a reference path, the tool changes the path in the underlying project file. It manipulates the tag<hintpath />, the path to the assembly, which is referenced.</hintpath />

Hnit path

When the tool saves the project file, Visual Studio notices that change and asks you to reload the project.

For some features, the tool holds a reference to the internal Visual Studio representation of an assembly reference (VSLangProj80.Reference3), which allows a manipulation of properties like ‘CopyLocal’, ‘SpecificVersion’ or deleting a reference. Changes to these properties are directly reflected by the original property window of the assembly reference in Visual Studio.

The Tool Solution Itself

The solution contains a C# and a setup project. The setup project was created with the Setup Project template. The C# project is originally created with a Visual Studio Add-In project template of Visual Studio 2005.

New project

Visual Studio automatically creates a ‘Tool’ menu item for the add-in, if you choose so in the project wizard. If you select ‘I would like my Add-In to load, …’ Visual Studio loads your Add-In directly when it starts.


In the new project, Visual Studio creates two files with the extension ‘AddIn’. One is lying in the project folder (e.g. ‘Lexware.Tools.AssemblyReferences.AddIn’) and this is used when the Add-In is deployed. The other one (e.g. ‘Lexware.Tools.AssemblyReferences - for Testing.AddIn’) is placed in the Visual Studio Add-In folder. This is the one which is used while debugging the Add-In. The Visual Studio Add-In folder is contained in your documents folder. For Windows Vista, it should be found here: C:\Users\’Your User Name’\Documents\Visual Studio 2005\Addins. An Add-In file contains a full description of the Add-In. It provides a friendly name, the load behavior and other information, necessary for Visual Studio to display the Add-In in the ‘Add-in Manager’.

Addin Manager Menue

Addin Manager

The Add-In

The Add-In project contains the file ‘connect.cs’, which contains the code connecting to Visual Studio. The class ‘Connect’ is called, when the Add-In starts. In fact, it is defined in the ‘FullClassName’ tag of the ‘.Addin’ file described below.


The Class Connect

The class Connect implements the Visual Studio interface IDTExtensibility2, which defines the method OnConnection. This method is called when Visual Studio loads the Add-In into its memory. This is the place where you can add menu items and in this case, create a tool window.

public void OnConnection(object application, ext_ConnectMode connectMode,
    object addInInst, ref Array custom)
    _applicationObject = (DTE2)application;
    _addInInstance = (AddIn)addInInst;


    if(connectMode == ext_ConnectMode.ext_cm_UISetup)
        object[] contextGUIDS = new object[] {};
        Commands2 commands = (Commands2)_applicationObject.Commands;
        string toolsMenuName;

            //If you would like to move the command to a different menu, change the
            //word "Tools" to the English version of the menu. This code will take
            // the culture, append on the name of the menu then add the command to
            // that menu. You can find a list of all the top-level menus in the file
            //  CommandBar.resx.
            ResourceManager resourceManager = new ResourceManager(
            CultureInfo cultureInfo = new CultureInfo(_applicationObject.LocaleID);
            string resourceName = String.Concat(cultureInfo.TwoLetterISOLanguageName,
            toolsMenuName = resourceManager.GetString(resourceName);
            //We tried to find a localized version of the word Tools, but one was
            // not found.
            //  Default to the en-US word, which may work for the current culture.
            toolsMenuName = LocalResources.ToolbarName;

        //Place the command on the tools menu.
        //Find the MenuBar command bar, which is the top-level command bar holding
        //all the main menu items:
        Microsoft.VisualStudio.CommandBars.CommandBar menuBarCommandBar = (

        //Find the Tools command bar on the MenuBar command bar:
        CommandBarControl toolsControl = menuBarCommandBar.Controls[toolsMenuName];
        CommandBarPopup toolsPopup = (CommandBarPopup)toolsControl;

        //This try/catch block can be duplicated if you wish to add multiple commands
        // to be handled by your Add-in,
        //  just make sure you also update the QueryStatus/Exec method to include
        //  the new command names.
            //Add a command to the Commands collection:
            Command command = commands.AddNamedCommand2(_addInInstance,
                "AssemblyReferences", "Assembly Reference Tool",
		"Checks and fixes assembly references. 
		Uses placeholder for debug and release directory.",
                 true, 0, ref contextGUIDS,
                 (int)vsCommandStatus.vsCommandStatusSupported +

            //Add a control for the command to the tools menu:
            if((command != null) && (toolsPopup != null))
                command.AddControl(toolsPopup.CommandBar, 1);
            //If we are here, then the exception is probably because a
            // command with that name
            // already exists. If so there is no need to recreate the command and 
            // we can safely ignore the exception.

When the user clicks your menu item, the method Exec in the same class will be called. You can filter the commandName, to know whether the called menu item was yours.

public void Exec(string commandName, vsCommandExecOption executeOption,
    ref object varIn, ref object varOut, ref bool handled)
    handled = false;
    if(executeOption == vsCommandExecOption.vsCommandExecOptionDoDefault)
        if(commandName == "Lexware.Tools.AssemblyReferences.Connect.AssemblyReferences")
            // Open Toolwindow

            handled = true;

The tool window, which contains all the important code in this Add-In, is a UserControl. To create it, you can call CreateToolWindow2. This method creates a new Visual Studio tool window and hosts a user control in it.

private void CreateToolWindow()
    if(_toolWindow != null)
        //This guid must be unique for each different tool window,
        // but you may use the same guid for the same tool window.
        //This guid can be used for indexing the windows collection,
        // for example: applicationObject.Windows.Item(guidstr)
        Windows2 windows2 = (Windows2)_applicationObject.Windows;
        Assembly asm = Assembly.GetExecutingAssembly();

        object customControl = null;
        string className = "Lexware.Tools.AssemblyReferences.ToolWindowControl";
        string caption = "Assembly References";
        _toolWindow = windows2.CreateToolWindow2(_addInInstance, asm.Location, className, 
                                                 caption, _toolWindowGuid,
                                                 ref customControl);

        //Set the picture displayed when the window is tab docked (this causes
        //problems in Visual Studio 2008)

        //When using the hosting control, you must set visible to true before calling
        // HostUserControl, otherwise the UserControl cannot be hosted properly.
        _toolWindow.Visible = true;

        if (customControl != null)
            _toolWindowControl = (ToolWindowControl)customControl;
            _toolWindowControl.ApplicationObject = _applicationObject;
            _toolWindowControl.ParentToolWindow = _toolWindow;

The ToolWindow

The tool window registers some events of the Visual Studio solution, document and the command object, so that changes in the solution will be noticed by the Add-In.

private void RegisterEvents()
    if (_solutionEvents != null)
    _solutionEvents = _applicationObject.Events.SolutionEvents;

    // register new events
    _solutionEvents.Opened += new _dispSolutionEvents_OpenedEventHandler(
    _solutionEvents.ProjectAdded += new _dispSolutionEvents_ProjectAddedEventHandler(
    _solutionEvents.ProjectRemoved += new _dispSolutionEvents_ProjectRemovedEventHandler(
    _solutionEvents.ProjectRenamed += new _dispSolutionEvents_ProjectRenamedEventHandler(
    _solutionEvents.AfterClosing += new _dispSolutionEvents_AfterClosingEventHandler(
    _documentEvents.DocumentSaved += new _dispDocumentEvents_DocumentSavedEventHandler(

    _commandEvents.AfterExecute += new _dispCommandEvents_AfterExecuteEventHandler( 

private void _commandEvents_AfterExecute(string Guid, int ID, object CustomIn,
    object CustomOut)
    //Command name: File.SaveSelectedItems
    //Command GUID/ID: {5EFC7975-14BC-11CF-9B2B-00AA00573819}, 331

    //Command name: File.SaveAll
    //Command GUID/ID: {5EFC7975-14BC-11CF-9B2B-00AA00573819}, 224

    //Command name: File.SaveSelectedItemsAs
    //Command GUID/ID: {5EFC7975-14BC-11CF-9B2B-00AA00573819}, 226

    //Command name: Build.SolutionConfigurations
    //Command GUID/ID: {5EFC7975-14BC-11CF-9B2B-00AA00573819}, 684

    //Command name: Project.Addreference
    //Command GUID/ID: {1496A755-94DE-11D0-8C3F-00C04FC2AAE2}, 1113
    if (((Guid == "{5EFC7975-14BC-11CF-9B2B-00AA00573819}") && (ID == 331)) ||
        ((Guid == "{5EFC7975-14BC-11CF-9B2B-00AA00573819}") && (ID == 224)) ||
        ((Guid == "{5EFC7975-14BC-11CF-9B2B-00AA00573819}") && (ID == 226)))
    else if ((Guid == "{1496A755-94DE-11D0-8C3F-00C04FC2AAE2}") && (ID == 1113))

When the solution changes, the Add-In iterates the projects contained in the solution and reads in the references of each project. It adds each reference to the list view and puts an instance of the class AssemblyReferenceInformation at the tag of the ListViewItem. This instance contains information about the project file (.csproj or .vbproj) and the assembly reference (VSLangProj80.Reference3), which will be used when manipulating the reference.

private void ReadAllReferences()

    if ((_applicationObject != null) && (_applicationObject.Solution != null))
        // Walk through the projects of the solution and search for assembly references
        foreach (Project currentProject in _applicationObject.Solution.Projects)

private void ReadProjectReferences(Project currentProject)
        if (currentProject != null)
            VSProject2 visualStudioProject = currentProject.Object as VSProject2;

            // The current project can be a 'real' project, but it can also be a
            // folder (see else if)
            if (visualStudioProject != null)
                string projectFullName = currentProject.FullName;

                if (!string.IsNullOrEmpty(projectFullName))
                    FileInfo projectFileInfo = new FileInfo(projectFullName);

                    // If it is a csproj or a vbproj, add it the list view
                    if (projectFileInfo.Exists &&
                        ((projectFileInfo.Extension == _csProjectFileExtension) || 
                            (projectFileInfo.Extension == _vbProjectFileExtension)))
                        // Add a group for this project
                        ListViewGroup projectGroup = GetProjectGroup(currentProject);

                        AddAssemblyHintsToListView(currentProject, projectFullName,
                            projectGroup, visualStudioProject);
            else if ((currentProject.ProjectItems != null) && (
                currentProject.ProjectItems.Count > 0))
                // Project Item Type       GUID
                // Physical File         {6BB5F8EE-4483-11D3-8BCF-00C04F8EC28C}
                // Physical Folder       {6BB5F8EF-4483-11D3-8BCF-00C04F8EC28C}
                // Virtual Folder        {6BB5F8F0-4483-11D3-8BCF-00C04F8EC28C}
                // Subproject            {EA6618E8-6E24-4528-94BE-6889FE16485C}

                // The projects contains a sub folder -> search for projects in
                // these folders
                foreach (ProjectItem currentProjectItem in currentProject.ProjectItems)
                    if (currentProjectItem.SubProject != null)
        // Enable fixit button, if there is something to fix
        toolStripButtonFixIt.Enabled = (_needsToBeSaved.Count > 0);
    catch (Exception ex)

When the user hits the 'FixIt' button, the tool changes the underlying project file. It saves all projects which need to be saved, due to an incorrect assembly path.

Convert to configuration based assembly paths

private void SaveDirtyProjects()
        foreach (KeyValuePair<string> project in _needsToBeSaved)
            XmlDocumentHolder documentHolder = project.Value;

    catch (Exception ex)

private void SaveProject(XmlDocumentHolder documentHolder)
    string projectName = documentHolder.Project.FullName;

    if (!documentHolder.Project.Saved)
        MessageBox.Show("Please save all projects before you fix the problems.");

    // Check out the project
    if ((_sourceControl != null) && (_sourceControl.IsItemUnderSCC(projectName)) &&

    using (XmlTextWriter writer = new XmlTextWriter(documentHolder.ProjectFileName,
        writer.Formatting = Formatting.Indented;

Visual Studio notices that the tool changed the project file and asks you to reload the project.

Reload the project

The Setup Project

The setup project deploys the Add-In to the AddIns folders of Visual Studio 2005 and Visual Studio 2008.

It automatically detects newer and older version, older versions will be removed before installing a new version. To create a new setup version for the Add-In, only change the version of the setup. Visual Studio will generate a new ProductCode for you, but it will not touch the UpgradeCode. With the combination of codes, Windows Installer is able to detect and update older or newer versions of the Add-In.


Requirements to Build the Solution

To build the solution, you need Visual Studio 2008. The Add-In is tested on Visual Studio 2005 and 2008 Team Developer and Team Suite.


We ported the source code of the Add-In to Visual Studio 2010. Visual Studio 2010 introduces the concept of extensions. For extensions, the deployment is much easier than for Visual Studio 2005 / 2008, so that the MSI setup is not needed anymore. The rest of the code remains at least the same. The new code is hosted at, the extension for Visual Studio 2010 can be downloaded from the Visual Studio Code Gallery.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Thomas Dörr
Software Developer (Senior) Haufe-Lexware GmbH & Co. KG
Germany Germany
Thomas has been programming in C, C++, VB and C# since many years. He works as a Distinguished Software Architect for Haufe-Lexware GmbH & Co. KG in Freiburg, Germany.

You may also be interested in...


Comments and Discussions

QuestionIs it possible to add reference at once? Pin
Brijesh Gandhi16-May-13 20:34
memberBrijesh Gandhi16-May-13 20:34 
AnswerRe: Is it possible to add reference at once? Pin
Thomas Dörr20-May-13 20:52
memberThomas Dörr20-May-13 20:52 
QuestionWith a different sort, couldn't this solve the "different versions of assembly" issue? Pin
James White23-Feb-12 2:25
memberJames White23-Feb-12 2:25 
AnswerRe: With a different sort, couldn't this solve the "different versions of assembly" issue? Pin
Thomas Dörr25-Feb-12 7:03
memberThomas Dörr25-Feb-12 7:03 
QuestionHow to make it work for UNC paths? Pin
Seikilos29-Sep-10 3:23
memberSeikilos29-Sep-10 3:23 
AnswerRe: How to make it work for UNC paths? Pin
Thomas Dörr5-Oct-10 3:25
memberThomas Dörr5-Oct-10 3:25 
GeneralMy vote of 5 Pin
Erich Deckert17-Aug-10 22:23
memberErich Deckert17-Aug-10 22:23 
GeneralBrilliant :) Pin
Ant210016-Aug-10 11:37
memberAnt210016-Aug-10 11:37 
GeneralVS 2010 & Host Source Code Pin
Mark.Whitfeld5-Aug-10 0:00
memberMark.Whitfeld5-Aug-10 0:00 
GeneralRe: VS 2010 & Host Source Code Pin
Thomas Dörr5-Aug-10 3:00
memberThomas Dörr5-Aug-10 3:00 
GeneralRe: VS 2010 & Host Source Code Pin
Mark.Whitfeld5-Aug-10 3:02
memberMark.Whitfeld5-Aug-10 3:02 
GeneralRe: VS 2010 & Host Source Code Pin
Thomas Dörr5-Aug-10 10:32
memberThomas Dörr5-Aug-10 10:32 
GeneralAdd a New Assembly Reference Pin
Shane Jimmerson5-Feb-10 12:48
memberShane Jimmerson5-Feb-10 12:48 
GeneralRe: Add a New Assembly Reference Pin
Thomas Dörr13-Feb-10 23:13
memberThomas Dörr13-Feb-10 23:13 
GeneralVisual Studio 2010 Beta Pin
ShiverCube21-Jan-10 17:42
memberShiverCube21-Jan-10 17:42 
GeneralRe: Visual Studio 2010 Beta Pin
Thomas Dörr21-Jan-10 20:33
memberThomas Dörr21-Jan-10 20:33 
General2005 I filed a suggestion for something similar Pin
Uwe Keim3-Oct-08 20:29
sitebuilderUwe Keim3-Oct-08 20:29 
GeneralRe: 2005 I filed a suggestion for something similar Pin
Thomas Dörr4-Oct-08 3:22
memberThomas Dörr4-Oct-08 3:22 
GeneralRe: 2005 I filed a suggestion for something similar Pin
swedish bricks26-Jan-09 6:24
memberswedish bricks26-Jan-09 6:24 
GeneralRe: 2005 I filed a suggestion for something similar Pin
Thomas Dörr26-Jan-09 19:14
memberThomas Dörr26-Jan-09 19:14 
GeneralGreat idea and excellent article! Pin
Daniel Vaughan22-Dec-07 13:21
memberDaniel Vaughan22-Dec-07 13:21 
GeneralRe: Great idea and excellent article! Pin
Thomas Dörr29-Dec-07 23:58
memberThomas Dörr29-Dec-07 23:58 
QuestionNice idea Pin
al01175721-Dec-07 5:22
memberal01175721-Dec-07 5:22 
GeneralRe: Nice idea Pin
Thomas Dörr22-Dec-07 9:16
memberThomas Dörr22-Dec-07 9:16 
GeneralRe: Nice idea Pin
al01175724-Dec-07 8:06
memberal01175724-Dec-07 8:06 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Cookies | Terms of Use | Mobile
Web01-2016 | 2.8.180712.1 | Last Updated 16 Aug 2010
Article Copyright 2007 by Thomas Dörr
Everything else Copyright © CodeProject, 1999-2018
Layout: fixed | fluid