Percorso di MSBuild


186

Come posso ottenere a livello di codice il percorso di MSBuild da una macchina su cui è in esecuzione il mio .exe?

Posso ottenere la versione .NET dall'ambiente ma esiste un modo per ottenere la cartella corretta per una versione .NET?

Risposte:


141

Frugando nel registro, sembra

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

potrebbe essere quello che stai cercando; accendi regedit.exe e dai un'occhiata.

Interrogazione tramite riga di comando (per Nikolay Botev )

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

Richiesta tramite PowerShell (per MovGP0 )

dir HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\

5
Ho installato Visual Studio 2017 RC e ho avviato il prompt dei comandi per sviluppatori, la versione di MSBuild è 15. +, ma questa versione non viene visualizzata nel registro. Come posso accedere allo stesso MSBuild utilizzato dal prompt di Dev Cmd?
SuperJMN

6
MSBuild 15 si trova in `C: \ Programmi (x86) \ Microsoft Visual Studio \ 2017 \ Enterprise \ MSBuild \ 15.0 \ Bin \ amd64`
nZeus

2
Solo se hai installato VS2017 lì, non riuscivo a trovare un singolo punto di accesso nel registro per MsBuildToolsPath per il set di strumenti 15.0
Paciv

8
docs.microsoft.com/en-us/visualstudio/msbuild/… "MSBuild è ora installato in una cartella in ciascuna versione di Visual Studio. Ad esempio, C: \ Programmi (x86) \ Microsoft Visual Studio \ 2017 \ Enterprise \ MSBuild "e" I valori di ToolsVersion non sono più impostati nel registro "
Hulvej

2
@ORMapper Microsoft offre un progetto su GitHub per determinare i percorsi delle istanze di Visual Studio 2017 / msbuild 15.x. È un singolo eseguibile che può essere utilizzato dal tuo software / script di compilazione.
Roi Danton,

140

È inoltre possibile stampare il percorso di MSBuild.exe sulla riga di comando:

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

1
Si noti che se si desidera creare un'app per Windows Phone, è necessario il msbuild a 32 bit. L'interrogazione del registro fornisce solo il msbuild a 64 bit su una macchina a 64 bit.
Victor Ionescu,

2
@VictorIonescu: Puoi usare /reg:32o /reg:64su entrambe le testimoni di cmd(o qualunque processo tu stia eseguendo) per ottenere esplicitamente quel percorso.
Simon Buchan,

questo vi darà il percorso di un vecchio (4,0) posizione - quella che probabilmente si desidera è in realtà vedere altrove stackoverflow.com/questions/32007871/...
JonnyRaa

Nel mio caso era sottoComputer\HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\MSBuild\ToolsVersions\4.0\MSBuildToolsPath
Sen Jacob il

32

Se si desidera utilizzare MSBuild per .Net 4, è possibile utilizzare il seguente comando PowerShell per ottenere il percorso dell'eseguibile. Se vuoi la versione 2.0 o 3.5, modifica semplicemente la variabile $ dotNetVersion.

Per eseguire l'eseguibile dovrai anteporre la variabile $ msbuild con &. Questo eseguirà la variabile.

# 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

2
funziona anche per $dotNetVersion12.0 (vs 2013) e 14.0 (vs 2015) (se installato ovviamente)
Julian

4
Non funziona per VS 2017, che non aggiunge un valore sotto la HKLM:\software\Microsoft\MSBuild\ToolsVersionschiave. Invece è necessario ottenere la directory di installazione di VS2017 HKLM:\SOFTWARE\WOW6432Node\Microsoft\VisualStud‌​io\SxS\VS7\15.0, quindi aggiungere MSBuild\15.0\Bin\MSBuild.exeper ottenere il percorso EXE di MSBuild.
Ian Kemp,

30

Per lo scripting della shell cmd in Windows 7, utilizzo il frammento seguente nel mio file batch per trovare MSBuild.exe in .NET Framework versione 4. Presumo sia presente la versione 4, ma non suppongo la sub-versione. Questo non è del tutto generico, ma per gli script rapidi può essere utile:

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

Per i miei usi sto uscendo dal file batch con un errore se non ha funzionato:

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

@yoyo A cosa serve set bb.build.msbuild.exe=? È richiesto o solo un artefatto della tua configurazione?
Elisée,

@ Elisée Oops, scusa, è un errore di battitura per copia / incolla. Nel mio ambiente chiamo la variabile bb.build.msbuild.exe, ho trascurato di correggere quell'istanza quando ho incollato la risposta. Risolto ora, grazie per averlo sottolineato.
yoyo

26

È possibile utilizzare questo comando PowerShell di prova per ottenere il MSBuildToolsPathdal registro.

PowerShell (dal registro)

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

Produzione

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

o dal filesystem

PowerShell (dal file system)

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

Produzione

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

1
La migliore risposta su questo argomento.
Teoman Shipahi,

21

Istruzioni per la ricerca di 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

Istruzioni per trovare 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

(Si noti che le istruzioni sopra sono leggermente modificate da quelle ufficiali di Microsoft. In particolare, ho incluso il -prereleaseflag per consentire la raccolta delle installazioni di anteprima e RC e il -products *rilevamento delle installazioni di Visual Studio Build Tools.)


Ci sono voluti solo due anni, ma finalmente nel 2019 Microsoft ci ha ascoltato e ci ha fornito un modo per trovare questi eseguibili vitali ! Se hai installato Visual Studio 2017 e / o 2019, l' vswhereutilità può essere interrogata per l'ubicazione di MSBuild et al. Dal momento che vswhere si trova sempre in %ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe , non è più necessario avviare il bootstrap e non è più richiesto alcun hardcoding di percorso.

La magia è il -findparametro, aggiunto nella versione 2.6.2 . È possibile determinare la versione installata eseguendo vswhereo controllando le proprietà del file. Se hai una versione precedente, puoi semplicemente scaricare l'ultima e sovrascrivere quella esistente %ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe.

vswhere.exeè un eseguibile autonomo, quindi puoi scaricarlo ed eseguirlo da qualsiasi luogo tu abbia una connessione Internet. Ciò significa che i tuoi script di build possono verificare se l'ambiente in cui sono in esecuzione è configurato correttamente, per nominare un'opzione.


Ci sono già 3 risposte che menzionano vswhere, incluso il tuo commento in tal senso sotto una di esse. L'aggiunta di questa risposta non fa che peggiorare la risposta.
jpaugh

4
4 ora. Ho trovato utile questa risposta, mentre non ho trovato utili le altre risposte vswhere.
cowlinator,

Vale la pena notare che solo perché VSWHERE dice che è il msbuild.exe da usare, ciò non significa che se si digita msbuildalla riga di comando (in particolare la riga di comando di Visual Studio se si utilizza quello), quello è quello che verrà utilizzato. Per vedere ciò che viene utilizzato se si digita msbuildnella riga di comando, fare questo: where msbuild. Se questo non riporta lo stesso di VSWHERE, dice che l'ultimo e il più grande sono, allora devi fare un percorso completo per quello msbuild.exeche vuoi usare, o apportare modifiche alle variabili PATH per adattarle.
Jinlye,

Quindi la prossima domanda è: come trovi il percorso verso dove ...
BJury,

17

@AllenSanborn ha un'ottima versione di PowerShell, ma alcune persone hanno l'obbligo di utilizzare solo script batch per build.

Questa è una versione applicata della risposta di @ bono8106.

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

Per Visual Studio 2017 / MSBuild 15, Aziz Atif (il ragazzo che ha scritto Elmah ) ha scritto uno 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

2
Nota: poiché VS2017 / msbuild 15.x non utilizza il registro per i loro percorsi, vswhere è un'alternativa per determinare il percorso msbuild.
Roi Danton,

1
Inoltre, AzizAtif è l'uomo. Dai un'occhiata a questo per build 15.1 - github.com/linqpadless/LinqPadless/blob/master/build.cmd
JJS

2
Inoltre, vswhere può essere installato tramite Chocolatey: chocolatey.org/packages/vswhere
cowlinator

6

Funziona con Visual Studio 2015 e 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

}


3
Per Build Tools, utilizzare vswhere -products *, come specificato in github.com/Microsoft/vswhere/wiki/Find-MSBuild .
TN.

Per vswhere dovresti conoscere il percorso in cui si trova. E ovviamente dovresti avere power-shell disponibile per il tuo sistema di compilazione. Solo una domanda: perché amd64? Ha qualcosa di specifico per la costruzione?
Massimo

È stato valutato perché questa soluzione utilizza essenzialmente una chiave di registro anche per MSBuild 15, non una libreria o uno script di terze parti. Per curiosità, a cosa si riferisce "SxS \ VS7"? Rimarrà valido per tutte le versioni VS?
Lazlo,

5

Le posizioni del registro

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

indica la posizione dell'eseguibile.

Ma se hai bisogno della posizione in cui salvare le estensioni dell'attività, è attivo

%ProgramFiles%\MSBuild

4
È piuttosto vecchio, lo so - ma comunque: su x64-Systems, la cartella MSBuild si trova in ProgramFiles (x86)
Sascha,

4

il modo più semplice potrebbe essere quello di aprire PowerShell ed entrare

dir HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\

4

Un one-liner basato sulla risposta di @ dh_cgn :

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

Seleziona tutti i percorsi esistenti, ad es. C:\Program Files (x86)\Microsoft Visual Studio\*\*\MSBuild\*\bin\msbuild.exe.

Le stelle con caratteri jolly sono:

  • l'anno (2017)
  • l'edizione visual studio (community, professional, enterprise)
  • la versione degli strumenti (15.0)

Tenere presente che questo comando sta selezionando il primo percorso che corrisponde all'espressione ordinata in ordine alfabetico. Per restringerlo basta sostituire i caratteri jolly con elementi specifici, ad es. l'anno o la versione degli strumenti.


3

Su Windows 2003 e versioni successive, digitare questo comando in cmd:

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

Se non viene visualizzato nulla, significa che .NET framework non è incluso nel PERCORSO di sistema. MSBuild dovrebbe trovarsi nella cartella di installazione .NET, insieme ai compilatori .NET (vbc.exe, csc.exe)


Questa risposta non aggiunge molto rispetto ad altre risposte. È meno robusto di questa risposta
solo il

3

A partire da MSBuild 2017 (v15), MSBuild è ora installato in una cartella in ciascuna versione di Visual Studio

Ecco alcuni esempi di dove MSBuild.exe si trova sul mio computer:

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)

Secondo una risposta precedente 2017 fa in serbo infatti queste informazioni nel Registro di sistema.
jpaugh

2

Per recuperare il percorso di msbuild 15 (Visual Studio 2017) con batch dal registro senza strumenti aggiuntivi:

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

Migliori strumenti disponibili:


1
mi hai salvato la vita
Hakan Fıstık, il

Esiste già una versione di PowerShell per questo. Intorno al 2017, c'è qualche motivo per evitare di imparare Powershell?
jpaugh,

2
@jpaugh Non tutti i sistemi di build hanno PowerShell disponibile.
Roi Danton,

1

Non penseresti che ci sia molto da aggiungere qui, ma forse è tempo di un modo unificato di farlo in tutte le versioni. Ho combinato l'approccio di query del registro (VS2015 e precedenti) con l'uso di vswhere (VS2017 e successivi) per trovare questo:

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
}

1

Ci sono molte risposte corrette. Tuttavia, qui un One-Liner in PowerShell che utilizzo per determinare il percorso MSBuild per la versione più recente :

Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\MSBuild\ToolsVersions\' | 
    Get-ItemProperty -Name MSBuildToolsPath | 
    Sort-Object PSChildName | 
    Select-Object -ExpandProperty MSBuildToolsPath -first 1

+1 Davvero utile! Ma nella mia risposta utilizzo -last 1(anziché -first 1per ottenere la versione più recente) e concateno anche il nome del file (per ottenere correttamente il percorso completo e non solo la cartella).
Mariano Desanze,

1

Questo metodo PowerShell ottiene il percorso di msBuild da più origini. Provare in ordine:

  1. Per prima cosa usa vswhere (perché Visual Studio sembra avere versioni più aggiornate di msBuild) ad es

    C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\MSBuild\15.0\Bin\MSBuild.exe
  2. Se non trovato, provando il registro (versione quadro) ad es

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

Codice 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
}

0

Per Visual Studio 2017 senza conoscere l'edizione esatta è possibile utilizzarlo in uno 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)

Il comando findstr è di ignorare alcuni eseguibili msbuild (in questo esempio amd64).


0

aggiungi il ramo vswhere per https://github.com/linqpadless/LinqPadless/blob/master/build.cmd , funziona bene sul mio computer e il ramo vswhere funziona sul computer del mio amico. Può essere, il ramo vswhere dovrebbe spostarsi in avanti come primo controllo.

@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


0

Ottieni l'ultima versione di MsBuild. Il modo migliore, per tutti i tipi di installazione di msbuild, per diverse architetture di processori (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;
}

-2

Se vuoi compilare un progetto Delphi, guarda "ERRORE MSB4040 Non c'è destinazione nel progetto" quando usi msbuild + Delphi2009

La risposta corretta si dice: "Esiste un file batch chiamato rsvars.bat (cercarlo nella cartella RAD Studio). prima di chiamare MSBuild e imposterà le variabili di ambiente necessarie. Assicurarsi che le cartelle siano corrette in rsvars .bat se il compilatore si trova in una posizione diversa da quella predefinita. "

Questo pipistrello non solo aggiorna la variabile di ambiente PATH nella cartella .NET corretta con la versione MSBuild.exe corretta, ma registra anche altre variabili necessarie.


Questa risposta non è correlata a Delphi e non è più efficace per gli utenti di Delphi.
Nashev,

2
Mi dispiace per essere conciso. Intendevo più robusto come in, funziona per più di un semplice Delphi. Potrebbe esserci un modo più semplice per farlo in Delphi, ma l'OP non ha chiesto di Delphi e questa discussione ha circa 18 risposte che pochi vedranno mai. Se per te è importante che gli altri lo vedano, ti consiglio di creare una nuova domanda specifica per Delphi e di auto-risposta. Se arrivassimo a 6 o meno risposte che riguardavano ogni versione di MSBuild, sarei molto felice
jpaugh
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.