Lexware Assembly Reference Tool for Visual Studio 2005 / 2008

http://www.codeproject.com/KB/macros/Lexware_AssemblyReference.aspx

 

 

• Download setup - 487.69 KB
• Download source - 74.2 KB

Introduction

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

Background

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

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 “\Relase\” 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 , the path to the assembly, which is referenced.

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 CSharp and a setup project. The setup project was created with the Setup Project template. The CSharp project is originally created with a Visual Studio Add-In project template of Visual Studio 2005.

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’.

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.

Collapse

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

    CreateToolWindow();

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

        try

        {
            //
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(
                "
Lexware.Tools.AssemblyReferences.CommandBar"
,
                Assembly.GetExecutingAssembly());
            CultureInfo cultureInfo = new
 CultureInfo(_applicationObject.LocaleID);
            string
 resourceName = String
.Concat(cultureInfo.TwoLetterISOLanguageName,
                LocalResources.ToolbarName);
            toolsMenuName = resourceManager.GetString(resourceName);
        }
        catch

        {
            //
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 = (
            (CommandBars)_applicationObject.CommandBars)["
MenuBar"
];

        //
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.

        try

        {
            //
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 +
                 (int
)vsCommandStatus.vsCommandStatusEnabled,
                 (int
)vsCommandStyle.vsCommandStyleText,
                 vsCommandControlType.vsCommandControlTypeButton);

            //
Add a control for the command to the tools menu:

            if
((command != null
) && (toolsPopup != null
))
            {
                command.AddControl(toolsPopup.CommandBar, 1
);
            }
        }
        catch
(ArgumentException)
        {
            //
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.

Collapse

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

            CreateToolWindow();

            handled = true
;
            return
;
        }
    }
}

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.

Collapse

private
 void
 CreateToolWindow()
{
    if
(_toolWindow != null
)
    {
        _toolWindow.Activate();
    }
    else

    {
        //
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)

        try

        {
            _toolWindow.SetTabPicture(LocalResources.LexwareBmp.GetHbitmap());
        }
        catch

        {
        }

        //
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.

Collapse

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

    //
 register new events

    _solutionEvents.Opened += new
 _dispSolutionEvents_OpenedEventHandler(
         _solutionEvents_Opened);
    _solutionEvents.ProjectAdded += new
 _dispSolutionEvents_ProjectAddedEventHandler(
         _solutionEvents_ProjectAdded);
    _solutionEvents.ProjectRemoved += new
 _dispSolutionEvents_ProjectRemovedEventHandler(
         _solutionEvents_ProjectRemoved);
    _solutionEvents.ProjectRenamed += new
 _dispSolutionEvents_ProjectRenamedEventHandler(
         _solutionEvents_ProjectRenamed);
    _solutionEvents.AfterClosing += new
 _dispSolutionEvents_AfterClosingEventHandler(
         _solutionEvents_AfterClosing);
    _documentEvents.DocumentSaved += new
 _dispDocumentEvents_DocumentSavedEventHandler(
         _documentEvents_DocumentSaved);

    _commandEvents.AfterExecute += new
 _dispCommandEvents_AfterExecuteEventHandler( 
         _commandEvents_AfterExecute);
}


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
)))
    {
        ReadAllReferences();
    } 
    else
 if
 ((Guid == "
{1496A755-94DE-11D0-8C3F-00C04FC2AAE2}"
) && (ID == 1113
))
    {
        ParentToolWindow.Activate();
    }
}

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.

Collapse

private
 void
 ReadAllReferences()
{
    ClearHintLists();

    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)
        {
            ReadProjectReferences(currentProject);
        }
    }
}

private
 void
 ReadProjectReferences(Project currentProject)
{
    try

    {
        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 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
)
                    {
                        ReadProjectReferences(currentProjectItem.SubProject);
                    }
                }
            }
        }
        //
 Enable fixit button, if there is something to fix

        toolStripButtonFixIt.Enabled = (_needsToBeSaved.Count > 0
);
    }
    catch
 (Exception ex)
    {
        ShowMessage(ex);
    }
}

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

Collapse

private
 void
 SaveDirtyProjects()
{
    try

    {
        foreach
 (KeyValuePair project in
 _needsToBeSaved)
        {
            XmlDocumentHolder documentHolder = project.Value;

            SaveProject(documentHolder);
        }
    }
    catch
 (Exception ex)
    {
        ShowMessage(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."
);
        return
;
    }

    //
 Check out the project

    if
 ((_sourceControl != null
) && (_sourceControl.IsItemUnderSCC(projectName)) &&
        (!_sourceControl.IsItemCheckedOut(projectName)))
    {
        _sourceControl.CheckOutItem(projectName);
    }

    using
 (XmlTextWriter writer = new
 XmlTextWriter(documentHolder.ProjectFileName,
        Encoding.UTF8))
    {
        writer.Formatting = Formatting.Indented;
        documentHolder.XmlDocument.Save(writer);
    }
}

Visual Studio notices that the tool changed the project file and asks you to 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.

History

no changes

<!-- Main Page Contents End -->

License

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


Member

Thomas has been programming in C, C++, VB and C# since many years. He works as a Senior Software Architect for Lexware GmbH & Co.KG in Freiburg, Germany.

Occupation:	Software Developer (Senior)
Company:	Lexware GmbH & Co.KG
Location:	Germany

 

Other popular Macros and Add-ins articles:

• Undocumented Visual C++
  Spelunking in the Badlands of MSDEV
• CodePlotter 1.6 - Add and edit diagrams in your code with this 'Visio-like' tool
  A Visual Studio addin for creating and editing ASCII diagrams in source files
• Versioning Controlled Build
  A Visual Studio add-in and command-line utility that automates versioning of .NET and VC++ projects
• Useful enhancements for Visual Studio .NET
  Several tools packed into one addin for Visual Studio .NET
• WTL Helper
  Add-in for Microsoft VC++.NET 2003 that helps to insert message handlers for WTL.