run a custom msbuild target from VisualStudio

Question

Suppose I add a custom target to a csproj file. Is there a way to run that target from visual studio? I don't want it make it a prebuild or postbuild step, I just want to be able to run this target (and its dependencies) from visual studio.

Answer 1

You don't have to code with the Exec, although that is one way to do it. The easier way is to do the following:

Change the DefaultTargets="Build" attribute to a custom Target you create, say "All" like so:

DefaultTargets="All"

Then in your custom "All" target, you can use the DependsOnTargets attribute, like the following:

"<Target Name="All" DependsOnTargets="ZipOutputFiles;Build">
  </Target>"

This will then build, and out put zip files in your custom "All" target.

Answer 2

If you are running the build inside of Visual Studio there will be a build variable of VisualStudioDir during the build.

To execute only is a VS build session do this:

<Target Name="Test" BeforeTargets="Build" Condition="'$(VisualStudioDir)' != ''>
</Target>

To execute only in a build outside of VS do this:

<Target Name="Test" BeforeTargets="Build" Condition="'$(VisualStudioDir)' == ''>
</Target>

You will need to include your custom targets file in one of two ways.

1. Set the environment variable CustomBeforeMicrosoftCommonTargets

2. Edit you project file to include your custom targets file by adding an import

   <Imports Project="CustomBuildTasks.Targets"><Imports/>
   

Answer 3

There is a simple way (though not all that satisfying) using a custom external tool.

Assuming your project file has the following modification:

  <Target Name="CalledFromIde">
    <Error Text="Called from the IDE!" />
  </Target>

Go to Tools | External Tools and add one like this:

  Title:      Called from IDE
  Command:    C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe
  Arguments:  $(ProjectDir)$(ProjectFileName) /t:CalledFromIde
  Initial directory:  $(ProjectDir)
  Use Output window:  checked

Running this produces output as:

  Build FAILED.

  "F:\Code\CsProject\CsProject.csproj" (CalledFromIde target) (1) ->
  (CalledFromIde target) -> 
    F:\Code\CsProject\CsProject.csproj(57,5): error : Called from the IDE!

What you are doing is calling out to MSBuild as an external tool and having it run the target directly. You have to supply the full path to MSBuild because the IDE doesn't maintain the same properties that the build environment it creates has available.

You can hook this up to a shortcut by figuring out which command # it is in the set Tools.ExternalCommand#.

If you're looking for a solution with more sophistication, it is a bit more involved. Here it is in a nutshell (for VS2010):

1) Create a VS Addin (File | New | Project | Other Project Types | Extensibility | Visual Studio Add-in). I'm not sure if you have to have the VS SDK installed to get this, it is available in the extension manager.

Select the following options in the wizard: - Microsoft Visual Studio 2010 - Yes, create a 'Tools' menu item - Load when the Application starts - My Add-in will never put up modal UI, and can be used with command line builds.

2) Add references to Microsoft.Build and Microsoft.Build.Framework

3) Find the implementation of Exec in the Connect.cs file

4) Replace it with this code:

public void Exec(
    string commandName,
    vsCommandExecOption executeOption,
    ref object varIn,
    ref object varOut,
    ref bool handled)
{
    handled = false;
    if (executeOption != vsCommandExecOption.vsCommandExecOptionDoDefault)
        return;
    if (commandName != "BuildAddin.Connect.BuildAddin")
        return;

    var doc = _applicationObject.ActiveDocument;
    var projectItem = doc.ProjectItem;
    var project = projectItem.ContainingProject;
    var evalProject =
        Microsoft.Build.Evaluation.ProjectCollection
        .GlobalProjectCollection.LoadProject(project.FullName);
    var execProject = evalProject.CreateProjectInstance();

    bool success = execProject.Build("CalledFromIde", null);

    var window = _applicationObject.Windows.Item(Constants.vsWindowKindOutput);
    var output = (OutputWindow)window.Object;
    OutputWindowPane pane = output.OutputWindowPanes.Add("BuildAddin");
    pane.OutputString(success ? "built /t:CalledFromIde" : "build failed");

    handled = true;
    return;
}

5) A better custom target while debugging, since the previous one errors:

  <Target Name="CalledFromIde">
    <WriteLinesToFile File="CalledFromIde.txt" Lines="Called from the IDE!" />
  </Target>

6) The code above has no error checking for brevity, you'll want to be much cleaner since it will be running in the IDE. The addin will place a menu item on your Tools menu. As written above, it simply looks for the project containing the currently active editor document, which would need some better plumbing for whatever you are cooking up.

This technique gets the build engine instance from within the IDE and has it execute a build on a separate instance of the project.

Answer 4

Some time ago I had the same problem and decided to write VS add-in. Try it:

https://github.com/Serg046/MsBuildTaskExplorer

https://marketplace.visualstudio.com/items?itemName=saaseev.MsBuildTaskExplorer