MSBuild

Calls Visual Studio msbuild command to build a sln project:

from conans import ConanFile, MSBuild

class ExampleConan(ConanFile):
    ...

    def build(self):
        msbuild = MSBuild(self)
        msbuild.build("MyProject.sln")

Internally the MSBuild build helper uses:

VisualStudioBuildEnvironment to adjust the LIB and CL environment variables with all the information from the requirements: include directories, library names, flags etc.

tools.msvc_build_command to call msbuild.

You can adjust all the information from the requirements accessing to the build_env that it is a VisualStudioBuildEnvironment object:

 from conans import ConanFile, MSBuild

 class ExampleConan(ConanFile):
     ...

     def build(self):
         msbuild = MSBuild(self)
         msbuild.build_env.include_paths.append("mycustom/directory/to/headers")
         msbuild.build_env.lib_paths.append("mycustom/directory/to/libs")
         msbuild.build_env.link_flags = []

         msbuild.build("MyProject.sln")

Constructor

class MSBuild(object):

    def __init__(self, conanfile)

Parameters:

conanfile (Required): ConanFile object. Usually self in a conanfile.py.

Methods

build()

def build(self, project_file, targets=None, upgrade_project=True, build_type=None, arch=None,
          parallel=True, force_vcvars=False, toolset=None, platforms=None, use_env=True,
          vcvars_ver=None, winsdk_version=None)

Builds Visual Studio project with the given parameters. It will call tools.msvc_build_command().

Parameters:

project_file (Required): Path to the sln file.
targets (Optional, Defaulted to None): List of targets to build.
upgrade_project (Optional, Defaulted to True): Will call devenv to upgrade the solution to your current Visual Studio.
build_type (Optional, Defaulted to None): Optional. Defaulted to None, will use the settings.build_type
arch (Optional, Defaulted to None): Optional. Defaulted to None, will use settings.arch
force_vcvars (Optional, Defaulted to False): Will ignore if the environment is already set for a different Visual Studio version.
parallel (Optional, Defaulted to True): Will use the configured number of cores in the conan.conf file (cpu_count):
- In the solution: Building the solution with the projects in parallel. (/m: parameter)
- CL compiler: Building the sources in parallel. (/MP: compiler flag)
toolset (Optional, Defaulted to None): Specify a toolset. Will append a /p:PlatformToolset option.
platforms (Optional, Defaulted to None): Dictionary with the mapping of archs/platforms from Conan naming to another one. It is useful for Visual Studio solutions that have a different naming in architectures. Example: platforms={"x86":"Win32"} (Visual solution uses “Win32” instead of “x86”). This dictionary will update the default one:
```
msvc_arch = {'x86': 'x86',
             'x86_64': 'x64',
             'armv7': 'ARM',
             'armv8': 'ARM64'}
```
use_env (Optional, Defaulted to True: Applies the argument /p:UseEnv=true to the msbuild() call.
vcvars_ver (Optional, Defaulted to None): Specifies the Visual Studio compiler toolset to use.
winsdk_version (Optional, Defaulted to None): Specifies the version of the Windows SDK to use.
properties (Optional, Defaulted to None): Dictionary with new properties, for each element in the dict {name: value} it will append a /p:name="value" option.

get_command()

Returns a string command calling msbuild

def get_command(self, project_file, props_file_path=None, targets=None, upgrade_project=True, build_type=None,
                arch=None, parallel=True, toolset=None, platforms=None, use_env=False):

Parameters:

project_file (Optional, defaulted to None): Path to a properties file to include in the project.
Same other parameters than build()

VisualStudioBuildEnvironment

Prepares the needed environment variables to invoke the Visual Studio compiler. Use it together with vcvars_command tool

from conans import ConanFile, VisualStudioBuildEnvironment

class ExampleConan(ConanFile):

    ...

    def build(self):
        if self.settings.compiler == "Visual Studio":
           env_build = VisualStudioBuildEnvironment(self)
           with tools.environment_append(env_build.vars):
               vcvars = tools.vcvars_command(self.settings)
               self.run('%s && cl /c /EHsc hello.cpp' % vcvars)
               self.run('%s && lib hello.obj -OUT:hello.lib' % vcvars

Set environment variables:

NAME	DESCRIPTION
LIB	Library paths separated with “;”
CL	“/I” flags with include directories, Runtime (/MT, /MD…), Definitions (/DXXX), and any other C and CXX flags.

Attributes

PROPERTY	DESCRIPTION
.include_paths	List with directories of include paths
.lib_paths	List with directories of libraries
.defines	List with definitions (from requirements cpp_info.defines)
.runtime	List with directories (from settings.compiler.runtime)
.flags	List with flag (from requirements cpp_info.cflags
.cxx_flags	List with cxx flags (from requirements cpp_info.cppflags
.link_flags	List with linker flags (from requirements cpp_info.sharedlinkflags and cpp_info.exelinkflags
.std	If the setting cppstd is set, the property will contain the corresponding flag of the language standard
.parallel	Default False, when True, the flag /MP will be adjusted in order to compiler the sources in parallel (using cpu_count)

You can adjust the automatically filled values modifying the attributes above:

   def build(self):
      if self.settings.compiler == "Visual Studio":
         env_build = VisualStudioBuildEnvironment(self)
         env_build.include_paths.append("mycustom/directory/to/headers")
         env_build.lib_paths.append("mycustom/directory/to/libs")
         env_build.link_flags = []
         with tools.environment_append(env_build.vars):
             vcvars = tools.vcvars_command(self.settings)
             self.run('%s && cl /c /EHsc hello.cpp' % vcvars)
             self.run('%s && lib hello.obj -OUT:hello.lib' % vcvars