Comment exécuter un fichier EXE dans PowerShell avec des paramètres avec des espaces et des guillemets

Comment exécutez-vous la commande suivante dans PowerShell?

C: \ Program Files \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql = "Data Source = mysource; Integrated Security = false; User ID = sa; Pwd = sapass!; Database = mydb;" -dest: dbfullsql = "Data Source =. \ mydestsource; Integrated Security = false; User ID = sa; Pwd = sapass!; Database = mydb;", computername = 10.10.10.10, username = administrator, password = adminpass "

Lorsque PowerShell voit une commande commençant par une chaîne, il évalue simplement la chaîne, c'est-à-dire qu'il la renvoie généralement à l'écran, par exemple:

PS> "Hello World"
Hello World

Si vous souhaitez que PowerShell interprète la chaîne comme un nom de commande, utilisez l'opérateur d'appel (&) comme suit:

PS> & 'C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe'

Après cela, vous n'aurez probablement qu'à citer des paires paramètre / argument contenant des espaces et / ou des caractères de citation. Lorsque vous appelez un fichier EXE comme celui-ci avec des arguments de ligne de commande complexes, il est généralement très utile d'avoir un outil qui vous montrera comment PowerShell envoie les arguments au fichier EXE. Les extensions de communauté PowerShell disposent d'un tel outil. Cela s'appelle des échoargs. Vous remplacez simplement le fichier EXE par echoargs - en laissant tous les arguments en place, et cela vous montrera comment le fichier EXE recevra les arguments, par exemple:

PS> echoargs -verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass

Arg 0 is <-verb:sync>
Arg 1 is <-source:dbfullsql=Data>
Arg 2 is <Source=mysource;Integrated>
Arg 3 is <Security=false;User>
Arg 4 is <ID=sa;Pwd=sapass!;Database=mydb;>
Arg 5 is <-dest:dbfullsql=Data>
Arg 6 is <Source=.\mydestsource;Integrated>
Arg 7 is <Security=false;User>
Arg 8 is <ID=sa;Pwd=sapass!;Database=mydb; computername=10.10.10.10 username=administrator password=adminpass>

En utilisant des échos, vous pouvez expérimenter jusqu'à ce que vous obteniez les bons résultats, par exemple:

PS> echoargs -verb:sync "-source:dbfullsql=Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;"
Arg 0 is <-verb:sync>
Arg 1 is <-source:dbfullsql=Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;>

Il s'avère que j'essayais trop avant de conserver les guillemets doubles autour de la chaîne de connexion. Apparemment, cela n'est pas nécessaire car même cmd.exe les supprimera.

BTW, chapeau à l'équipe PowerShell. Ils m'ont été très utiles en me montrant l'incantation spécifique des guillemets simples et doubles pour obtenir le résultat souhaité - si vous aviez besoin de garder les guillemets internes en place. :-) Ils réalisent également que c'est un domaine douloureux, mais ils sont motivés par le nombre de personnes affectées par un problème particulier. Si cela vous inquiète, veuillez voter pour cette soumission de bogue PowerShell .

Pour plus d'informations sur la façon dont PowerShell analyse, consultez ma série de blogs PowerShell efficace - en particulier le point 10 - «Comprendre les modes d'analyse PowerShell»

MISE À JOUR 4/4/2012: Cette situation devient beaucoup plus facile à gérer dans PowerShell V3. Voir cet article de blog pour plus de détails .

Ajoutez simplement l' opérateur & avant le nom .exe. Voici une commande pour installer SQL Server Express en mode silence:

$fileExe = "T:\SQLEXPRADV_x64_ENU.exe"
$CONFIGURATIONFILE = "T:\ConfSetupSql2008Express.ini"

& $fileExe  /CONFIGURATIONFILE=$CONFIGURATIONFILE

J'avais des espaces dans les commandes et les paramètres, et c'est ce qui a fonctionné pour moi:

$Command = "E:\X64\Xendesktop Setup\XenDesktopServerSetup.exe"
$Parms = "/COMPONENTS CONTROLLER,DESKTOPSTUDIO,DESKTOPDIRECTOR,LICENSESERVER,STOREFRONT /PASSIVE /NOREBOOT /CONFIGURE_FIREWALL /NOSQL"

$Prms = $Parms.Split(" ")
& "$Command" $Prms

C'est fondamentalement la même chose que la réponse d'Akira, mais cela fonctionne si vous créez dynamiquement vos paramètres de commande et les placez dans une variable.

Cela a fonctionné pour moi:

& 'D:\Server\PSTools\PsExec.exe' @('\\1.1.1.1', '-accepteula', '-d', '-i', $id, '-h', '-u', 'domain\user', '-p', 'password', '-w', 'C:\path\to\the\app', 'java', '-jar', 'app.jar')

Placez simplement les chemins ou les chaînes de connexion dans un élément de tableau et divisez les autres éléments en un élément de tableau chacun.

Il existe de nombreuses autres options ici: https://social.technet.microsoft.com/wiki/contents/articles/7703.powershell-running-executables.aspx

Microsoft devrait rendre cette méthode plus simple et compatible avec la syntaxe d'invite de commande.

Il existe plusieurs méthodes que vous pouvez utiliser pour le faire.

Il existe d'autres méthodes comme l'utilisation de l'opérateur d'appel ( & ), l' applet de commande Invoke-Expression, etc. Mais elles sont considérées comme dangereuses. Microsoft recommande d'utiliser Start-Process .

Méthode 1

Un exemple simple

Start-Process -NoNewWindow -FilePath "C:\wamp64\bin\mysql\mysql5.7.19\bin\mysql" -ArgumentList "-u root","-proot","-h localhost"

Dans ton cas

Start-Process -NoNewWindow -FilePath "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe" -ArgumentList "-verb:sync","-source:dbfullsql=`"Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`"","-dest:dbfullsql=`"Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`"","computername=10.10.10.10","username=administrator","password=adminpass"

Dans cette méthode, vous séparez chaque paramètre de la ArgumentList à l'aide de virgules.

Méthode 2

Exemple simple

Start-Process -NoNewWindow -FilePath "C:\wamp64\bin\mysql\mysql5.7.19\bin\mysql" -ArgumentList "-u root -proot -h localhost"

Dans ton cas

Start-Process -NoNewWindow -FilePath "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe" -ArgumentList "-verb:sync -source:dbfullsql=`"Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`" -dest:dbfullsql=`"Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;`",computername=10.10.10.10,username=administrator,password=adminpass"

Cette méthode est plus simple car elle permet de taper vos paramètres en une seule fois.

Notez que dans powershell pour représenter le guillemet (") dans une chaîne, vous devez insérer l' accent grave (`) (c'est la touche au-dessus de la touche Tab du clavier américain).

-Le paramètre NoNewWindow est utilisé pour afficher le nouveau processus dans la fenêtre de console actuelle. Par défaut, Windows PowerShell ouvre une nouvelle fenêtre.

Références: Powershell / Scripting / Start-Process

Voir cette page: https://slai.github.io/posts/powershell-and-external-commands-done-right/

Résumé utilisant vshadow comme exécutable externe:

$exe = "H:\backup\scripts\vshadow.exe"
&$exe -p -script=H:\backup\scripts\vss.cmd E: M: P:

Au cas où quelqu'un se demanderait comment exécuter simplement un fichier exécutable:

.....>. \ file.exe

ou

......> full \ path \ to \ file.exe

J'ai pu faire fonctionner ma commande similaire en utilisant l'approche suivante:

msdeploy.exe -verb=sync "-source=dbFullSql=Server=THESERVER;Database=myDB;UID=sa;Pwd=saPwd" -dest=dbFullSql=c:\temp\test.sql

Pour votre commande (pas que cela aide beaucoup maintenant), les choses ressembleraient à ceci:

msdeploy.exe -verb=sync "-source=dbfullsql=Server=mysource;Trusted_Connection=false;UID=sa;Pwd=sapass!;Database=mydb;" "-dest=dbfullsql=Server=mydestsource;Trusted_Connection=false;UID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass

Les points clés sont:

• Utilisez des guillemets autour de l'argument source et supprimez les guillemets intégrés autour de la chaîne de connexion
• Utilisez les autres noms de clés pour créer la chaîne de connexion SQL qui ne contient pas d'espace. Par exemple, utilisez "UID" au lieu de "User Id", "Server" au lieu de "Data Source", "Trusted_Connection" au lieu de "Integrated Security", etc. Je n'ai pu le faire fonctionner qu'une fois que j'ai supprimé tous les espaces de la chaîne de connexion.

Je n'ai pas essayé d'ajouter la partie "computername" à la fin de la ligne de commande, mais j'espère que ces informations aideront les autres personnes à lire ceci maintenant à se rapprocher du résultat souhaité.

Nouvelle chaîne d'échappement dans PowerShell V3, extraite des nouvelles fonctionnalités du langage V3 :

Réutilisation plus facile des lignes de commande à partir de Cmd.exe

Le Web est plein de lignes de commande écrites pour Cmd.exe. Ces lignes de commandes fonctionnent assez souvent dans PowerShell, mais lorsqu'elles incluent certains caractères, par exemple un point-virgule (;), un signe dollar ($) ou des accolades, vous devez apporter des modifications, en ajoutant probablement des guillemets. Cela semblait être la source de nombreux maux de tête mineurs.

Pour aider à résoudre ce scénario, nous avons ajouté une nouvelle façon «d'échapper» à l'analyse des lignes de commande. Si vous utilisez un paramètre magique -%, nous arrêtons notre analyse normale de votre ligne de commande et passons à quelque chose de beaucoup plus simple. Nous ne correspondons pas aux citations. Nous ne nous arrêtons pas au point-virgule. Nous ne développons pas les variables PowerShell. Nous développons les variables d'environnement si vous utilisez la syntaxe Cmd.exe (par exemple% TEMP%). En dehors de cela, les arguments jusqu'à la fin de la ligne (ou du tuyau, si vous êtes un tuyau) sont passés tels quels. Voici un exemple:

PS> echoargs.exe --% %USERNAME%,this=$something{weird}
Arg 0 is <jason,this=$something{weird}>

Vous pouvez utiliser:

Start-Process -FilePath "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe" -ArgumentList "-verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass"

L'essentiel à noter ici est que FilePath doit être en position 0, selon le Guide d'aide. Pour appeler le guide d'aide d'une commande, tapez simplement Get-Help <Commandlet-name> -Detailed. Dans ce cas, c'est le cas Get-Help Start-Process -Detailed.

J'ai essayé toutes les suggestions, mais je n'ai toujours pas pu exécuter les msiexec.exeparamètres contenant des espaces. Ma solution a donc fini par utiliser System.Diagnostics.ProcessStartInfo:

# can have spaces here, no problems
$settings = @{
  CONNECTION_STRING = "... ..."
  ENTITY_CONTEXT = "... ..."
  URL = "..."
}

$settingsJoined = ($settings.Keys | % { "$_=""$($settings[$_])""" }) -join " "
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.WorkingDirectory = $ScriptDirectory
$pinfo.FileName = "msiexec.exe"
$pinfo.RedirectStandardError = $true
$pinfo.RedirectStandardOutput = $true
$pinfo.UseShellExecute = $false
$pinfo.Arguments = "/l* install.log /i installer.msi $settingsJoined"
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
$p.Start() | Out-Null
$p.WaitForExit()
$stdout = $p.StandardOutput.ReadToEnd()

Cela a fonctionné pour moi:

PowerShell.exe -Command "& ""C:\Some Script\Path With Spaces.ps1"""

La clé semble être que toute la commande est entourée de guillemets externes, l'esperluette "&" est utilisée pour spécifier qu'un autre fichier de commande enfant est en cours d'exécution, puis finalement des guillemets échappés (doublés-doubles) autour du chemin / nom de fichier avec des espaces en vous vouliez exécuter en premier lieu.

C'est également l'achèvement de la seule solution de contournement au problème de connexion MS que -File ne renvoie pas de codes retour non nuls et -Commande est la seule alternative. Mais jusqu'à présent, on pensait qu'une limitation de -Command était qu'il ne supportait pas les espaces. J'ai également mis à jour cet élément de rétroaction.

http://connect.microsoft.com/PowerShell/feedback/details/750653/powershell-exe-doesn-t-return-correct-exit-codes-when-using-the-file-option

Une autre solution consiste à utiliser un commutateur de commande codé en Base64 :

powershell -EncodedCommand "QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA=="

Une fois décodé, vous verrez qu'il s'agit de l'extrait d'origine de l'OP avec tous les arguments et guillemets conservés.

powershell.exe -EncodedCommand

Accepts a base-64-encoded string version of a command. Use this parameter
to submit commands to Windows PowerShell that require complex quotation
marks or curly braces.

La commande d'origine:

 C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe -verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass"

Il se transforme en ceci lorsqu'il est codé en Base64:

QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA==

et voici comment reproduire à la maison:

$command = 'C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe -verb:sync -source:dbfullsql="Data Source=mysource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;" -dest:dbfullsql="Data Source=.\mydestsource;Integrated Security=false;User ID=sa;Pwd=sapass!;Database=mydb;",computername=10.10.10.10,username=administrator,password=adminpass"'
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
$encodedCommand = [Convert]::ToBase64String($bytes)
$encodedCommand

#  The clip below copies the base64 string to your clipboard for right click and paste.
$encodedCommand | Clip

Vous pouvez exécuter des fichiers exe de différentes manières en PowerShell. Par exemple, si vous souhaitez exécuter unrar.exe et extraire un fichier .rar, vous pouvez simplement écrire en PowerShell ceci:

$extract_path = "C:\Program Files\Containing folder";
$rar_to_extract = "C:\Path_to_arch\file.rar"; #(or.exe if its a big file)  
C:\Path_here\Unrar.exe x -o+ -c- $rar_to_extract $extract_path;

Mais parfois, cela ne fonctionne pas, vous devez donc utiliser le paramètre & comme indiqué ci-dessus: Par exemple, avec vboxmanage.exe (un outil pour gérer les machines virtuelles virtualbox), vous devez appeler les paramètres en dehors de la chaîne comme ceci, sans guillemets:

> $vmname = "misae_unrtes_1234123"; #(name too long, we want to change this)
> & 'C:\Program Files\Oracle\VirtualBox\VBoxManage.exe' modifyvm $vmname --name UBUNTU;

Si vous voulez appeler simplement un fichier archivé winrar en tant que fichiers .exe, vous pouvez également le décompresser avec l'applet de commande invoke-command et un paramètre / S silencieux (il va s'extraire dans le même dossier que celui où il a été compressé).

> Invoke-Command -ScriptBlock { C:\Your-path\archivefile.exe /S };

Il existe donc plusieurs façons d'exécuter des fichiers .exe avec des arguments dans PowerShell.

Parfois, il faut trouver une solution de contournement pour le faire fonctionner correctement, ce qui peut nécessiter des efforts et des douleurs supplémentaires :) selon la façon dont le fichier .exe a été compilé ou créé par ses créateurs.

J'utilise cette méthode simple, propre et efficace.

Je place les arguments dans un tableau, 1 par ligne. De cette façon, il est très facile à lire et à modifier. Ensuite, j'utilise une astuce simple pour passer tous les arguments entre guillemets doubles à une fonction avec 1 paramètre unique. Cela les aplatit, y compris les tableaux, en une seule chaîne, que j'exécute ensuite en utilisant «Invoke-Expression» de PS. Cette directive est spécialement conçue pour convertir une chaîne en commande exécutable. Fonctionne bien:

                    # function with one argument will flatten 
                    # all passed-in entries into 1 single string line
Function Execute($command) {
                    # execute:
    Invoke-Expression $command;
                    # if you have trouble try:
  # Invoke-Expression "& $command";
                    # or if you need also output to a variable
  # Invoke-Expression $command | Tee-Object -Variable cmdOutput;

}

#  ... your main code here ...

               # The name of your executable app
$app = 'my_app.exe';
               # List of arguments:
               #    Notice the type of quotes - important !
               #    Those in single quotes are normal strings, like 'Peter'
$args = 'arg1',
        'arg2',
        $some_variable,
        'arg4',
        "arg5='with quotes'",
        'arg6',
        "arg7 \ with \ $other_variable",
        'etc...';

               # pass all arguments inside double quotes
Execute "$app $args";

J'ai eu le code suivant fonctionnant parfaitement sur mon ordinateur portable:

& $msdeploy `
-source:package="$publishFile" `
-dest:auto,computerName="$server",includeAcls="False",UserName="$username",Password="$password",AuthType="$auth" `
-allowUntrusted  `
-verb:sync  `
-enableRule:DoNotDeleteRule `
-disableLink:AppPoolExtension  `
-disableLink:ContentExtension  `
-disableLink:CertificateExtension  `
-skip:objectName=filePath,absolutePath="^(.*Web\.config|.*Environment\.config)$" `
-setParam:name=`"IIS Web Application Name`",value="$appName"

Ensuite, quand j'ai essayé de l'exécuter directement sur un serveur, j'ai commencé à obtenir ces erreurs "Unrecognized argument ...etc.... All arguments must begin with "-". "

Après avoir essayé toutes les solutions de contournement possibles (sans succès), j'ai découvert que Powershell sur le serveur (Windows 2008 R2) était la version 3.0, alors que mon ordinateur portable en avait 5.0. (vous pouvez utiliser "$ PSVersionTable" pour voir la version).

Après avoir mis à niveau Powershell vers la dernière version, il a recommencé à fonctionner.

Cmd peut gérer l'exécution d'un exe cité, mais pas Powershell. Je vais juste m'occuper de gérer l'exe lui-même, car je ne l'ai pas. Si vous devez littéralement envoyer des guillemets doubles à un argument d'une commande externe, c'est un autre problème qui a été abordé ailleurs.

1) ajoutez le dossier exe à votre chemin, peut-être dans votre profil $

$env:path += ';C:\Program Files\IIS\Microsoft Web Deploy\'
msdeploy

2) citez les espaces:

C:\Program` Files\IIS\Microsoft` Web` Deploy\msdeploy.exe

J'ai donc rencontré un problème similaire et j'ai choisi de le résoudre de cette façon:

1. Échappez à vos guillemets (") avec un backtick (`)
2. Entourez votre nouvelle expression de guillemets (")
3. À l'aide de l'opérateur d'appel (&), exécutez la commande invoke-expressionsur la nouvelle chaîne

Exemple de solution:

& {invoke-expression "C: \ Program Files \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql =` "Data Source = mysource; Integrated Security = false; User ID = sa; Pwd = sapass !; Database = mydb; `" -dest: dbfullsql = `" Data Source =. \ Mydestsource; Integrated Security = false; User ID = sa; Pwd = sapass!; Database = mydb; `", computername = 10.10.10.10, nom d'utilisateur = administrateur, mot de passe = adminpass` ""}

Pour le nom de l'exécutable, l' applet de commande new-alias peut être utilisée pour éviter de traiter des espaces ou d'avoir besoin d'ajouter l'exécutable à l'environnement $ PATH.

PS> new-alias msdeploy "C:\Program Files\IIS\Microsoft Web Deploy\msdeploy.exe"
PS> msdeploy ...

Pour répertorier ou modifier les alias PS, voir également

PS> get-alias
PS> set-alias

De Jeffery Hicks Aarticle

D'autres réponses répondent aux arguments.