Chemin vers MSBuild

187

Comment puis-je obtenir par programme le chemin d'accès à MSBuild à partir d'une machine sur laquelle mon .exe est exécuté?

Je peux obtenir la version .NET à partir de l'environnement, mais existe-t-il un moyen d'obtenir le dossier approprié pour une version .NET?

.net  msbuild 
— dagda1
source

Réponses:

141

Fouillant dans le registre, on dirait

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\2.0
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\3.5
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0

peut-être ce que vous recherchez; lancez regedit.exe et jetez un œil.

Requête via la ligne de commande (par Nikolay Botev )

reg.exe query "HKLM\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0" /v MSBuildToolsPath

Requête via PowerShell (par MovGP0 )

dir HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\
— Brian
source
5
J'ai installé Visual Studio 2017 RC et démarré l'invite de commande du développeur, la version MSBuild est 15. +, mais cette version ne s'affiche pas dans le registre. Comment puis-je accéder au même MSBuild que l'invite Dev Cmd utilise?
— SuperJMN
6
MSBuild 15 se trouve dans `C: \ Program Files (x86) \ Microsoft Visual Studio \ 2017 \ Enterprise \ MSBuild \ 15.0 \ Bin \ amd64`
— nZeus
2
Seulement si vous avez installé VS2017 là-bas, je n'ai pas trouvé de point d'entrée unique dans le registre pour MsBuildToolsPath pour l'ensemble d'outils 15.0
— Paciv
8
docs.microsoft.com/en-us/visualstudio/msbuild/… "MSBuild est maintenant installé dans un dossier sous chaque version de Visual Studio. Par exemple, C: \ Program Files (x86) \ Microsoft Visual Studio \ 2017 \ Enterprise \ MSBuild "et" Les valeurs de ToolsVersion ne sont plus définies dans le registre "
— Hulvej
2
@ORMapper Microsoft propose un projet sur GitHub pour déterminer les chemins des instances de Visual Studio 2017 / msbuild 15.x. C'est un exécutable unique qui peut être utilisé par vos logiciels / scripts de construction.
— Roi Danton
140

Vous pouvez également imprimer le chemin de MSBuild.exe sur la ligne de commande:

reg.exe query "HKLM\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0" /v MSBuildToolsPath
— Nikolay Botev
source
1
Veuillez noter que si vous souhaitez créer une application Windows Phone, cela nécessite le msbuild 32 bits. L'interrogation du registre ne donne que le msbuild 64 bits sur une machine 64 bits.
— Victor Ionescu
2
@VictorIonescu: Vous pouvez utiliser /reg:32ou /reg:64sur les deux bitnessess de cmd(ou tout autre processus que vous exécutez) pour obtenir explicitement ce chemin.
— Simon Buchan
cela vous donnera le chemin vers un ancien emplacement (4.0) - celui que vous voulez probablement est en fait ailleurs voir stackoverflow.com/questions/32007871
— ...
Dans mon cas, c'était sousComputer\HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\MSBuild\ToolsVersions\4.0\MSBuildToolsPath
— Sen Jacob
32

Si vous souhaitez utiliser MSBuild pour .Net 4, vous pouvez utiliser la commande PowerShell suivante pour obtenir le chemin de l'exécutable. Si vous voulez la version 2.0 ou 3.5, changez simplement la variable $ dotNetVersion.

Pour exécuter l'exécutable, vous devrez ajouter la variable $ msbuild avec &. Cela exécutera la variable.

# valid versions are [2.0, 3.5, 4.0]
$dotNetVersion = "4.0"
$regKey = "HKLM:\software\Microsoft\MSBuild\ToolsVersions\$dotNetVersion"
$regProperty = "MSBuildToolsPath"

$msbuildExe = join-path -path (Get-ItemProperty $regKey).$regProperty -childpath "msbuild.exe"

&$msbuildExe
— AllenSanborn
source
2
fonctionne également pour $dotNetVersion12.0 (vs 2013) et 14.0 (vs 2015) (si installé bien sûr)
— Julian
4
Ne fonctionne pas pour VS 2017, qui n'ajoute pas de valeur sous la HKLM:\software\Microsoft\MSBuild\ToolsVersionsclé. Au lieu de cela, vous devez obtenir le répertoire d'installation de VS2017 HKLM:\SOFTWARE\WOW6432Node\Microsoft\VisualStud‌​io\SxS\VS7\15.0, puis l'ajouter MSBuild\15.0\Bin\MSBuild.exepour obtenir l'emplacement MSBuild EXE.
— Ian Kemp
30

Pour les scripts shell cmd dans Windows 7, j'utilise le fragment suivant dans mon fichier de commandes pour trouver MSBuild.exe dans le .NET Framework version 4. Je suppose que la version 4 est présente, mais je ne suppose pas la sous-version. Ce n'est pas totalement à usage général, mais pour les scripts rapides, cela peut être utile:

set msbuild.exe=
for /D %%D in (%SYSTEMROOT%\Microsoft.NET\Framework\v4*) do set msbuild.exe=%%D\MSBuild.exe

Pour mes utilisations, je quitte le fichier de commandes avec une erreur si cela n'a pas fonctionné:

if not defined msbuild.exe echo error: can't find MSBuild.exe & goto :eof
if not exist "%msbuild.exe%" echo error: %msbuild.exe%: not found & goto :eof
— yo-yo
source
@yoyo À quoi ça sert set bb.build.msbuild.exe=? Est-ce nécessaire ou simplement un artefact de votre configuration?
— Elisée
@ Elisée Oups, désolé, c'est une faute de frappe. Dans mon environnement, j'appelle la variable bb.build.msbuild.exe, j'ai négligé de corriger cette instance lorsque j'ai collé dans la réponse. Corrigé maintenant, merci de l'avoir signalé.
— yoyo
26

Vous pouvez utiliser cette commande PowerShell très d'essai pour obtenir le à MSBuildToolsPathpartir du registre.

PowerShell (à partir du registre)

Resolve-Path HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\* | 
Get-ItemProperty -Name MSBuildToolsPath

Production

MSBuildToolsPath : C:\Program Files (x86)\MSBuild\12.0\bin\amd64\
PSPath           : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\12.0
PSParentPath     : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions
PSChildName      : 12.0
PSDrive          : HKLM
PSProvider       : Microsoft.PowerShell.Core\Registry

MSBuildToolsPath : C:\Program Files (x86)\MSBuild\14.0\bin\amd64\
PSPath           : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\14.0
PSParentPath     : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions
PSChildName      : 14.0
PSDrive          : HKLM
PSProvider       : Microsoft.PowerShell.Core\Registry

MSBuildToolsPath : C:\Windows\Microsoft.NET\Framework64\v2.0.50727\
PSPath           : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\2.0
PSParentPath     : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions
PSChildName      : 2.0
PSDrive          : HKLM
PSProvider       : Microsoft.PowerShell.Core\Registry

MSBuildToolsPath : C:\Windows\Microsoft.NET\Framework64\v3.5\
PSPath           : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\3.5
PSParentPath     : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions
PSChildName      : 3.5
PSDrive          : HKLM
PSProvider       : Microsoft.PowerShell.Core\Registry

MSBuildToolsPath : C:\Windows\Microsoft.NET\Framework64\v4.0.30319\
PSPath           : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0
PSParentPath     : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions
PSChildName      : 4.0
PSDrive          : HKLM
PSProvider       : Microsoft.PowerShell.Core\Registry

ou depuis le système de fichiers

PowerShell (à partir du système de fichiers)

Resolve-Path "C:\Program Files (x86)\MSBuild\*\Bin\amd64\MSBuild.exe"
Resolve-Path "C:\Program Files (x86)\MSBuild\*\Bin\MSBuild.exe"

Production

Path
----
C:\Program Files (x86)\MSBuild\12.0\Bin\amd64\MSBuild.exe
C:\Program Files (x86)\MSBuild\14.0\Bin\amd64\MSBuild.exe
C:\Program Files (x86)\MSBuild\12.0\Bin\MSBuild.exe
C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe
— dhcgn
source
1
La meilleure réponse sur ce sujet.
— Teoman shipahi
23

Instructions pour trouver MSBuild :

  • PowerShell: &"${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe" -latest -prerelease -products * -requires Microsoft.Component.MSBuild -find MSBuild\**\Bin\MSBuild.exe
  • CMD: "%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -prerelease -products * -requires Microsoft.Component.MSBuild -find MSBuild\**\Bin\MSBuild.exe

Instructions pour trouver VSTest :

  • PowerShell: &"${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe" -latest -prerelease -products * -requires Microsoft.VisualStudio.PackageGroup.TestTools.Core -find Common7\IDE\CommonExtensions\Microsoft\TestWindow\vstest.console.exe
  • CMD: "%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -prerelease -products * -requires Microsoft.VisualStudio.PackageGroup.TestTools.Core -find Common7\IDE\CommonExtensions\Microsoft\TestWindow\vstest.console.exe

(Notez que les instructions ci-dessus sont légèrement modifiées par rapport aux instructions officielles de Microsoft. En particulier, j'ai inclus l' -prereleaseindicateur permettant de récupérer les installations d'aperçu et RC et -products *de détecter les installations de Visual Studio Build Tools.)

Cela n'a pris que deux ans mais finalement en 2019, Microsoft a écouté et nous a donné un moyen de trouver ces exécutables vitaux ! Si vous avez installé Visual Studio 2017 et / ou 2019, l' vswhereutilitaire peut être interrogé pour l'emplacement de MSBuild et al. Puisqu'il vswhere est toujours situé à %ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe , il n'y a plus d'amorçage ni de codage en dur du chemin.

La magie est le -findparamètre, ajouté dans la version 2.6.2 . Vous pouvez déterminer la version que vous avez installée en exécutant vswhereou en vérifiant ses propriétés de fichier. Si vous avez une version plus ancienne, vous pouvez simplement télécharger la dernière et écraser l'existant %ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe.

vswhere.exeest un exécutable autonome, vous pouvez donc le télécharger et l'exécuter depuis n'importe quel endroit où vous avez une connexion Internet. Cela signifie que vos scripts de construction peuvent vérifier si l'environnement sur lequel ils s'exécutent est correctement configuré, pour ne nommer qu'une option.

— Ian Kemp
source
Il y a déjà 3 réponses qui mentionnent vswhere, y compris votre commentaire à cet effet sous l'une d'elles. L'ajout de cette réponse ne fait qu'empirer la soupe de réponse.
— jpaugh
4
4 maintenant. J'ai trouvé cette réponse utile, alors que je n'ai pas trouvé les autres réponses vswhere utiles.
— cowlinator
Il convient de noter que le simple fait que VSWHERE indique que c'est le msbuild.exe à utiliser, cela ne signifie pas que si vous tapez msbuildsur la ligne de commande (en particulier la ligne de commande Visual Studio si vous l'utilisez), c'est celle qui sera utilisée. Pour voir ce qui sera utilisé si vous tapez msbuildsur la ligne de commande, procédez comme suit: where msbuild. Si ce n'est pas la même chose que VSWHERE dit que le dernier et le meilleur est, alors vous devez soit faire un chemin complet vers le que msbuild.exevous voulez utiliser, soit apporter des ajustements à vos variables PATH en conséquence.
— Jinlye du
La question suivante est donc de savoir comment trouver le chemin vers vswhere ....
— BJury
@BJury Microsoft garantit qu'il sera toujours dans "C: \ Program Files (x86) \ Microsoft Visual Studio \ Installer \ vswhere.exe". C'est votre point de départ. Alternativement, comme indiqué dans les 2 derniers paragraphes, vous pouvez le télécharger vswhere.exeet l'utiliser directement.
— Ian Kemp il y a
17

@AllenSanborn a une excellente version PowerShell, mais certaines personnes ont l'obligation d'utiliser uniquement des scripts batch pour les builds.

Ceci est une version appliquée de ce que @ bono8106 a répondu.

msbuildpath.bat

@echo off

reg.exe query "HKLM\SOFTWARE\Microsoft\MSBuild\ToolsVersions\14.0" /v MSBuildToolsPath > nul 2>&1
if ERRORLEVEL 1 goto MissingMSBuildRegistry

for /f "skip=2 tokens=2,*" %%A in ('reg.exe query "HKLM\SOFTWARE\Microsoft\MSBuild\ToolsVersions\14.0" /v MSBuildToolsPath') do SET "MSBUILDDIR=%%B"

IF NOT EXIST "%MSBUILDDIR%" goto MissingMSBuildToolsPath
IF NOT EXIST "%MSBUILDDIR%msbuild.exe" goto MissingMSBuildExe

exit /b 0

goto:eof
::ERRORS
::---------------------
:MissingMSBuildRegistry
echo Cannot obtain path to MSBuild tools from registry
goto:eof
:MissingMSBuildToolsPath
echo The MSBuild tools path from the registry '%MSBUILDDIR%' does not exist
goto:eof
:MissingMSBuildExe
echo The MSBuild executable could not be found at '%MSBUILDDIR%'
goto:eof

build.bat

@echo off
call msbuildpath.bat
"%MSBUILDDIR%msbuild.exe" foo.csproj /p:Configuration=Release

Pour Visual Studio 2017 / MSBuild 15, Aziz Atif (le gars qui a écrit Elmah ) a écrit un script batch

build.cmd Release Foo.csproj

https://github.com/linqpadless/LinqPadless/blob/master/build.cmd

@echo off
setlocal
if "%PROCESSOR_ARCHITECTURE%"=="x86" set PROGRAMS=%ProgramFiles%
if defined ProgramFiles(x86) set PROGRAMS=%ProgramFiles(x86)%
for %%e in (Community Professional Enterprise) do (
    if exist "%PROGRAMS%\Microsoft Visual Studio\2017\%%e\MSBuild\15.0\Bin\MSBuild.exe" (
        set "MSBUILD=%PROGRAMS%\Microsoft Visual Studio\2017\%%e\MSBuild\15.0\Bin\MSBuild.exe"
    )
)
if exist "%MSBUILD%" goto :restore
set MSBUILD=
for %%i in (MSBuild.exe) do set MSBUILD=%%~dpnx$PATH:i
if not defined MSBUILD goto :nomsbuild
set MSBUILD_VERSION_MAJOR=
set MSBUILD_VERSION_MINOR=
for /f "delims=. tokens=1,2,3,4" %%m in ('msbuild /version /nologo') do (
    set MSBUILD_VERSION_MAJOR=%%m
    set MSBUILD_VERSION_MINOR=%%n
)
if not defined MSBUILD_VERSION_MAJOR goto :nomsbuild
if not defined MSBUILD_VERSION_MINOR goto :nomsbuild
if %MSBUILD_VERSION_MAJOR% lss 15    goto :nomsbuild
if %MSBUILD_VERSION_MINOR% lss 1     goto :nomsbuild
:restore
for %%i in (NuGet.exe) do set nuget=%%~dpnx$PATH:i
if "%nuget%"=="" (
    echo WARNING! NuGet executable not found in PATH so build may fail!
    echo For more on NuGet, see https://github.com/nuget/home
)
pushd "%~dp0"
nuget restore ^
 && call :build Debug   %* ^
 && call :build Release %*
popd
goto :EOF

:build
setlocal
"%MSBUILD%" /p:Configuration=%1 /v:m %2 %3 %4 %5 %6 %7 %8 %9
goto :EOF

:nomsbuild
echo Microsoft Build version 15.1 (or later) does not appear to be
echo installed on this machine, which is required to build the solution.
exit /b 1
— JJS
source
2
Remarque: Étant donné que VS2017 / msbuild 15.x n'utilise pas le registre pour ses chemins, vswhere est une alternative pour déterminer le chemin msbuild.
— Roi Danton
1
Aussi, AzizAtif est l'homme. Jetez un œil à cela pour les versions 15.1 - github.com/linqpadless/LinqPadless/blob/master/build.cmd
— JJS
2
De plus, vswhere peut être installé via Chocolatey: chocolatey.org/packages/vswhere
— cowlinator
6

Cela fonctionne pour Visual Studio 2015 et 2017:

function Get-MSBuild-Path {

    $vs14key = "HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\14.0"
    $vs15key = "HKLM:\SOFTWARE\wow6432node\Microsoft\VisualStudio\SxS\VS7"

    $msbuildPath = ""

    if (Test-Path $vs14key) {
        $key = Get-ItemProperty $vs14key
        $subkey = $key.MSBuildToolsPath
        if ($subkey) {
            $msbuildPath = Join-Path $subkey "msbuild.exe"
        }
    }

    if (Test-Path $vs15key) {
        $key = Get-ItemProperty $vs15key
        $subkey = $key."15.0"
        if ($subkey) {
            $msbuildPath = Join-Path $subkey "MSBuild\15.0\bin\amd64\msbuild.exe"
        }
    }

    return $msbuildPath

}
— Raman Zhylich
source
4
— Ian Kemp
3
Pour les outils de construction, utilisez vswhere -products *, comme spécifié dans github.com/Microsoft/vswhere/wiki/Find-MSBuild .
— TN.
Pour vswhere, vous devez connaître le chemin où il se trouve. Et bien sûr, vous devriez avoir power-shell disponible pour votre système de construction. Juste une question: pourquoi amd64? Y a-t-il quelque chose de spécifique pour la construction?
— Maxim
Vote positif car cette solution utilise essentiellement une clé de registre pour MSBuild 15 également, pas une bibliothèque ou un script tiers. Par curiosité, à quoi fait référence "SxS \ VS7"? Cela restera-t-il valable dans les versions VS?
— Lazlo
5

Les emplacements du registre 

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\2.0
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSBuild\ToolsVersions\3.5

donnez l'emplacement de l'exécutable.

Mais si vous avez besoin de l'emplacement où enregistrer les extensions de tâches, c'est sur 

%ProgramFiles%\MSBuild
— Paulo Santos
source
4
C'est assez vieux, je sais - mais de toute façon: sur les systèmes x64, le dossier MSBuild est situé dans ProgramFiles (x86)
— Sascha
4

Le moyen le plus simple pourrait être d'ouvrir PowerShell et d'entrer 

dir HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\
— MovGP0
source
4

Un one-liner basé sur la réponse de @ dh_cgn :

(Resolve-Path ([io.path]::combine(${env:ProgramFiles(x86)}, 'Microsoft Visual Studio', '*', '*', 'MSBuild', '*' , 'bin' , 'msbuild.exe'))).Path

Il sélectionne tous les chemins de chemins existants, par exemple. C:\Program Files (x86)\Microsoft Visual Studio\*\*\MSBuild\*\bin\msbuild.exe.

Les étoiles génériques sont:

  • l'année (2017)
  • l'édition Visual Studio (communauté, professionnel, entreprise)
  • la version des outils (15.0)

Sachez que cette commande sélectionne le premier chemin qui correspond à l'expression classée par alphabet. Pour le réduire, remplacez simplement les caractères génériques par des éléments spécifiques, par exemple. l'année ou la version des outils.

— SeriousM
source
3

Sous Windows 2003 et versions ultérieures, tapez cette commande dans cmd:

cmd> where MSBuild
Sample result: C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe

Si rien n'apparaît, cela signifie que .NET Framework n'est pas inclus dans le PATH système. Le MSBuild doit être dans le dossier d'installation .NET, avec les compilateurs .NET (vbc.exe, csc.exe)

— draganicimw
source
Cette réponse n'ajoute pas grand-chose par rapport aux autres réponses. C'est moins robuste que cette réponse
— jpaugh
3

À partir de MSBuild 2017 (v15), MSBuild est maintenant installé dans un dossier sous chaque version de Visual Studio

Voici quelques exemples où MSBuild.exe se trouve sur ma machine:

C:\windows\Microsoft.NET\Framework\v2.0.50727\MSBuild.exe  (v2.0.50727.8745  32-bit)
C:\windows\Microsoft.NET\Framework64\v2.0.50727\MSBuild.exe  (v2.0.50727.8745  64-bit)
C:\Windows\Microsoft.NET\Framework\v3.5\MSBuild.exe  (v3.5.30729.8763 32-bit)
C:\Windows\Microsoft.NET\Framework64\v3.5\MSBuild.exe  (v3.5.30729.8763 64-bit)
C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe  (v4.7.2053.0 32-bit)
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe  (v4.7.2053.0 64-bit)
C:\Program Files (x86)\MSBuild\12.0\Bin\MSBuild.exe  (v12.0.21005.1 32-bit)
C:\Program Files (x86)\MSBuild\12.0\Bin\amd64\MSBuild.exe (v12.0.21005.1 64-bit)
C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe  (v14.0.25420.1 32-bit)
C:\Program Files (x86)\MSBuild\14.0\Bin\amd64\MSBuild.exe  (v14.0.25420.1 64-bit)
C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\MSBuild\15.0\Bin\MSBuild.exe  (v15.1.1012+g251a9aec17 32-bit)
C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\MSBuild\15.0\Bin\amd64\MSBuild.exe (v15.1.1012+g251a9aec17 64-bit)
C:\Program Files (x86)\Microsoft Visual Studio\2017\{LicenceName}\MSBuild\Bin\MSBuild.exe (v15.1.1012.6693 32-bit)
C:\Program Files (x86)\Microsoft Visual Studio\2017\{LicenceName}\MSBuild\Bin\amd64\MSBuild.exe (v15.1.1012.6693 64-bit)
— cowlinator
source
Selon une réponse précédente , 2017 - t en magasin fait ces informations dans le Registre.
— jpaugh
2

Pour récupérer le chemin de msbuild 15 (Visual Studio 2017) avec un lot à partir du registre sans outils supplémentaires:

set regKey=HKLM\SOFTWARE\WOW6432Node\Microsoft\VisualStudio\SxS\VS7
set regValue=15.0
for /f "skip=2 tokens=3,*" %%A in ('reg.exe query %regKey% /v %regValue% 2^>nul') do (
    set vs17path=%%A %%B
)
set msbuild15path = %vs17path%\MSBuild\15.0\Bin\MSBuild.exe

Meilleurs outils disponibles:

— Roi Danton
source
1
tu as sauvé ma vie
— Hakan Fıstık
Il existe déjà une version PowerShell de cela. Vers 2017, y a-t-il une raison d'éviter d'apprendre Powershell?
— jpaugh
2
@jpaugh Tous les systèmes de build ne disposent pas de PowerShell.
— Roi Danton
1

Vous ne pensez pas qu'il y a beaucoup à ajouter ici, mais il est peut-être temps pour une manière unifiée de le faire dans toutes les versions. J'ai combiné l'approche de requête de registre (VS2015 et ci-dessous) avec l'utilisation de vswhere (VS2017 et plus) pour arriver à ceci:

function Find-MsBuild {
    Write-Host "Using VSWhere to find msbuild..."
    $path = & $vswhere -latest -requires Microsoft.Component.MSBuild -find MSBuild\**\Bin\MSBuild.exe | select-object -first 1

    if (!$path) {
        Write-Host "No results from VSWhere, using registry key query to find msbuild (note this will find pre-VS2017 versions)..."
        $path = Resolve-Path HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\* |
                    Get-ItemProperty -Name MSBuildToolsPath |
                    sort -Property @{ Expression={ [double]::Parse($_.PSChildName) }; Descending=$true } |
                    select -exp MSBuildToolsPath -First 1 |
                    Join-Path -ChildPath "msbuild.exe"
    }

    if (!$path) {
        throw "Unable to find path to msbuild.exe"
    }

    if (!(Test-Path $path)) {
        throw "Found path to msbuild as $path, but file does not exist there"
    }

    Write-Host "Using MSBuild at $path..."
    return $path
}
— Neil Barnwell
source
1

Il existe de nombreuses réponses correctes. Cependant, voici un One-Liner dans PowerShell que j'utilise pour déterminer le chemin MSBuild pour la version la plus récente :

Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\' | 
    Get-ItemProperty -Name MSBuildToolsPath | 
    Sort-Object PSChildName | 
    Select-Object -ExpandProperty MSBuildToolsPath -first 1
— Martin Brandl
source
+1 Vraiment utile! Mais dans ma réponse, j'utilise -last 1(au lieu de -first 1pour obtenir la dernière version) et concatène également le nom du fichier (pour obtenir correctement le chemin complet et pas seulement le dossier).
— Mariano Desanze
1

Cette méthode PowerShell obtient le chemin vers msBuild à partir de plusieurs sources. Essayer dans l'ordre:

  1. Première utilisation de vswhere (car Visual Studio semble avoir des versions plus à jour de msBuild), par exemple

    C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\MSBuild\15.0\Bin\MSBuild.exe

  2. Si non trouvé en essayant le registre (version du framework), par exemple

    C:\Windows\Microsoft.NET\Framework64\v4.0.30319\msbuild.exe

Code Powershell:

Function GetMsBuildPath {

    Function GetMsBuildPathFromVswhere {
        # Based on https://github.com/microsoft/vswhere/wiki/Find-MSBuild/62adac8eb22431fa91d94e03503d76d48a74939c
        $vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
        $path = & $vswhere -latest -prerelease -products * -requires Microsoft.Component.MSBuild -property installationPath
        if ($path) {
            $tool = join-path $path 'MSBuild\Current\Bin\MSBuild.exe'
            if (test-path $tool) {
                return $tool
            }
            $tool = join-path $path 'MSBuild\15.0\Bin\MSBuild.exe'
            if (test-path $tool) {
                return $tool
            }
        }
    }

    Function GetMsBuildPathFromRegistry {
        # Based on Martin Brandl's answer: https://stackoverflow.com/a/57214958/146513
        $msBuildDir = Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\' |
            Get-ItemProperty -Name MSBuildToolsPath |
            Sort-Object PSChildName |
            Select-Object -ExpandProperty MSBuildToolsPath -last 1
        $msBuildPath = join-path $msBuildDir 'msbuild.exe'
        if (test-path $msBuildPath) {
            return $msBuildPath
        }
    }

    $msBuildPath = GetMsBuildPathFromVswhere
    if (-Not $msBuildPath) {
        $msBuildPath = GetMsBuildPathFromRegistry
    }
    return $msBuildPath
}
— Mariano Desanze
source
0

Pour Visual Studio 2017 sans connaître l'édition exacte, vous pouvez l'utiliser dans un script batch:

FOR /F "tokens=* USEBACKQ" %%F IN (`where /r "%PROGRAMFILES(x86)%\Microsoft Visual 
Studio\2017" msbuild.exe ^| findstr /v /i "amd64"`) DO (SET msbuildpath=%%F)

La commande findstr consiste à ignorer certains exécutables msbuild (dans cet exemple, l'amd64).

— Ernstjan Freriks
source
0

ajoutez la branche vswhere pour https://github.com/linqpadless/LinqPadless/blob/master/build.cmd , fonctionne bien sur mon ordinateur, et la branche vswhere fonctionne sur l'ordinateur de mon compagnon. Peut-être que la branche vswhere devrait avancer comme première vérification.

@echo off
setlocal
if "%PROCESSOR_ARCHITECTURE%"=="x86" set PROGRAMS=%ProgramFiles%
if defined ProgramFiles(x86) set PROGRAMS=%ProgramFiles(x86)%
for %%e in (Community Professional Enterprise) do (
    if exist "%PROGRAMS%\Microsoft Visual Studio\2017\%%e\MSBuild\15.0\Bin\MSBuild.exe" (
        set "MSBUILD=%PROGRAMS%\Microsoft Visual Studio\2017\%%e\MSBuild\15.0\Bin\MSBuild.exe"
    )
)
if exist "%MSBUILD%" goto :build

for /f "usebackq tokens=1* delims=: " %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -requires Microsoft.Component.MSBuild`) do (
  if /i "%%i"=="installationPath" set InstallDir=%%j
)

if exist "%InstallDir%\MSBuild\15.0\Bin\MSBuild.exe" (
  set "MSBUILD=%InstallDir%\MSBuild\15.0\Bin\MSBuild.exe"
)
if exist "%MSBUILD%" goto :build
set MSBUILD=
for %%i in (MSBuild.exe) do set MSBUILD=%%~dpnx$PATH:i
if not defined MSBUILD goto :nomsbuild
set MSBUILD_VERSION_MAJOR=
set MSBUILD_VERSION_MINOR=
for /f "delims=. tokens=1,2,3,4" %%m in ('msbuild /version /nologo') do (
    set MSBUILD_VERSION_MAJOR=%%m
    set MSBUILD_VERSION_MINOR=%%n
)
echo %MSBUILD_VERSION_MAJOR% %MSBUILD_VERSION_MINOR%
if not defined MSBUILD_VERSION_MAJOR goto :nomsbuild
if not defined MSBUILD_VERSION_MINOR goto :nomsbuild
if %MSBUILD_VERSION_MAJOR% lss 15    goto :nomsbuild
if %MSBUILD_VERSION_MINOR% lss 1     goto :nomsbuild
:restore
for %%i in (NuGet.exe) do set nuget=%%~dpnx$PATH:i
if "%nuget%"=="" (
    echo WARNING! NuGet executable not found in PATH so build may fail!
    echo For more on NuGet, see https://github.com/nuget/home
)
pushd "%~dp0"
popd
goto :EOF

:build
setlocal
"%MSBUILD%" -restore -maxcpucount %1 /p:Configuration=%2 /v:m %3 %4 %5 %6 %7 %8 %9
goto :EOF

:nomsbuild
echo Microsoft Build version 15.1 (or later) does not appear to be
echo installed on this machine, which is required to build the solution.
exit /b 1
— Shamork.Fu
source
0

Obtenez la dernière version de MsBuild. Meilleur moyen, pour tous les types d'installation de msbuild, pour différentes architectures de processeur (Power Shell):

function Get-MsBuild-Path
{
    $msbuildPathes = $null
    $ptrSize = [System.IntPtr]::Size
    switch ($ptrSize) {
        4 {
            $msbuildPathes =
            @(Resolve-Path "${Env:ProgramFiles(x86)}\Microsoft Visual Studio\*\*\MSBuild\*\Bin\msbuild.exe" -ErrorAction SilentlyContinue) +
            @(Resolve-Path "${Env:ProgramFiles(x86)}\MSBuild\*\Bin\MSBuild.exe" -ErrorAction SilentlyContinue) +
            @(Resolve-Path "${Env:windir}\Microsoft.NET\Framework\*\MSBuild.exe" -ErrorAction SilentlyContinue)
        }
        8 {
            $msbuildPathes =
            @(Resolve-Path "${Env:ProgramFiles(x86)}\Microsoft Visual Studio\*\*\MSBuild\*\Bin\amd64\msbuild.exe" -ErrorAction SilentlyContinue) +
            @(Resolve-Path "${Env:ProgramFiles(x86)}\MSBuild\*\Bin\amd64\MSBuild.exe" -ErrorAction SilentlyContinue) +
            @(Resolve-Path "${Env:windir}\Microsoft.NET\Framework64\*\MSBuild.exe" -ErrorAction SilentlyContinue)
        }
        default {
            throw ($msgs.error_unknown_pointersize -f $ptrSize)
        }
    }

    $latestMSBuildPath = $null
    $latestVersion = $null
    foreach ($msbuildFile in $msbuildPathes)
    {
        $msbuildPath = $msbuildFile.Path
        $versionOutput = & $msbuildPath -version
        $fileVersion = (New-Object System.Version($versionOutput[$versionOutput.Length - 1]))
        if (!$latestVersion -or $latestVersion -lt $fileVersion)
        {
            $latestVersion = $fileVersion
            $latestMSBuildPath = $msbuildPath
        }
    }

    Write-Host "MSBuild version detected: $latestVersion" -Foreground Yellow
    Write-Host "MSBuild path: $latestMSBuildPath" -Foreground Yellow

    return $latestMSBuildPath;
}
— Stas BZ
source
-2

Si vous souhaitez compiler un projet Delphi, regardez "ERREUR MSB4040 Il n'y a pas de cible dans le projet" lors de l'utilisation de msbuild + Delphi2009

La bonne réponse est dite: "Il existe un fichier batch appelé rsvars.bat (recherchez-le dans le dossier RAD Studio). Appelez-le avant d'appeler MSBuild, et il configurera les variables d'environnement nécessaires. Assurez-vous que les dossiers sont corrects dans rsvars .bat si vous avez le compilateur dans un emplacement différent de celui par défaut. "

Cette batte mettra non seulement à jour la variable d'environnement PATH dans le dossier .NET approprié avec la version appropriée de MSBuild.exe, mais enregistrera également d'autres variables nécessaires.

— Nashev
source
Cette réponse n'est pas liée à Delphi et n'est pas plus robuste pour les utilisateurs de Delphi.
— Nashev
2
Désolé d'être laconique. Je voulais dire plus robuste que dans, fonctionne pour plus que simplement Delphi. Il y a peut-être un moyen plus simple de le faire dans Delphi, mais l'OP n'a pas posé de questions sur Delphi, et ce fil contient 18 réponses que peu de gens verront jamais. S'il est important pour vous que les autres voient cela, je vous recommande de créer une nouvelle question spécifique à Delphi et d'auto-réponse. Si nous arrivions à 6 réponses ou moins qui couvraient toutes les versions de MSBuild, je serais très heureux
— jpaugh
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.