Como executar um arquivo EXE no PowerShell com parâmetros com espaços e aspas

Como você executa o seguinte comando no PowerShell?

C: \ Arquivos de programas \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql = "Fonte de dados = mysource; Segurança integrada = false; ID do usuário = sa; Pwd = sapass!; Database = mydb;" -dest: dbfullsql = "Fonte de dados =. \ mydestsource; Segurança integrada = false; ID do usuário = sa; Pwd = sapass!; Banco de dados = mydb;", nome do computador = 10.10.10.10, nome do usuário = administrador, senha = adminpass "

Quando o PowerShell vê um comando que começa com uma string, ele apenas avalia a string, ou seja, normalmente faz eco na tela, por exemplo:

PS> "Hello World"
Hello World

Se você deseja que o PowerShell interprete a sequência como um nome de comando, use o operador de chamada (&) da seguinte forma:

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

Depois disso, você provavelmente só precisará citar pares de parâmetros / argumentos que contêm espaços e / ou caracteres de cotação. Quando você invoca um arquivo EXE como este com argumentos complexos de linha de comando, geralmente é muito útil ter uma ferramenta que mostre como o PowerShell envia os argumentos para o arquivo EXE. As extensões da comunidade do PowerShell possuem essa ferramenta. É chamado eco. Você acabou de substituir o arquivo EXE por echoargs - deixando todos os argumentos no lugar, e ele mostrará como o arquivo EXE receberá os argumentos, por exemplo:

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>

Usando ecos, você pode experimentar até acertar, por exemplo:

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;>

Acontece que eu estava tentando muito antes manter as aspas duplas em torno da cadeia de conexão. Aparentemente, isso não é necessário porque mesmo o cmd.exe os removerá.

BTW, tiramos o chapéu para a equipe do PowerShell. Eles foram bastante úteis para me mostrar o encantamento específico de aspas simples e duplas para obter o resultado desejado - se você precisasse manter as aspas duplas internas no lugar. :-) Eles também percebem que essa é uma área de dor, mas são motivados pelo número de pessoas afetadas por um problema específico. Se essa é uma área problemática para você, vote neste envio de bug do PowerShell .

Para obter mais informações sobre como o PowerShell analisa, confira a série de blogs do PowerShell efetivo - especificamente o item 10 - "Compreendendo os modos de análise do PowerShell"

ATUALIZAÇÃO 4/4/2012: Essa situação fica muito mais fácil de lidar no PowerShell V3. Veja esta postagem do blog para obter detalhes .

Basta adicionar o operador & antes do nome .exe. Aqui está um comando para instalar o SQL Server Express no modo silencioso:

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

& $fileExe  /CONFIGURATIONFILE=$CONFIGURATIONFILE

Eu tinha espaços no comando e nos parâmetros, e é isso que funcionou para mim:

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

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

É basicamente o mesmo que a resposta do Akira, mas isso funciona se você construir dinamicamente seus parâmetros de comando e colocá-los em uma variável.

Isso funcionou para mim:

& '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')

Basta colocar caminhos ou cadeias de conexão em um item da matriz e dividir as outras coisas em um item da matriz cada.

Existem muitas outras opções aqui: https://social.technet.microsoft.com/wiki/contents/articles/7703.powershell-running-executables.aspx

A Microsoft deve tornar esse caminho mais simples e compatível com a sintaxe do prompt de comando.

Existem alguns métodos que você pode usar para fazer isso.

Existem outros métodos, como usar o cmdlet Operador de chamadas ( & ), Invoke-Expression etc. Mas eles são considerados inseguros. A Microsoft recomenda o uso do Start-Process .

Método 1

Um exemplo simples

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

No seu caso

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"

Nesse método, você separa cada parâmetro no ArgumentList usando vírgulas.

Método 2

Exemplo Simples

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

No seu caso

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"

Este método é mais fácil, pois permite digitar seus parâmetros de uma só vez.

Observe que no powershell para representar as aspas (") em uma string, você deve inserir o acento grave (`) (esta é a tecla acima da tecla Tab no teclado dos EUA).

O parâmetro -NoNewWindow é usado para exibir o novo processo na janela atual do console. Por padrão, o Windows PowerShell abre uma nova janela.

Referências: PowerShell / Scripting / Start-Process

Veja esta página: https://slai.github.io/posts/powershell-and-external-commands-done-right/

Resumo usando vshadow como executável externo:

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

Caso alguém esteja se perguntando como executar um arquivo executável:

.....>. \ file.exe

ou

......> completo \ caminho \ para \ arquivo.exe

Consegui fazer meu comando semelhante funcionar usando a seguinte abordagem:

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

Para o seu comando (não que isso ajude muito agora), as coisas seriam mais ou menos assim:

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

Os pontos principais são:

• Use aspas ao redor do argumento de origem e remova as aspas incorporadas ao redor da cadeia de conexão
• Use os nomes de chave alternativos na construção da cadeia de conexão SQL que não possui espaços. Por exemplo, use "UID" em vez de "ID do usuário", "Servidor" em vez de "Fonte de dados", "Conexão confiável" em vez de "Segurança integrada" e assim por diante. Só consegui fazê-lo funcionar depois de remover todos os espaços da cadeia de conexão.

Eu não tentei adicionar a parte "nomedocomputador" no final da linha de comando, mas espero que essas informações ajudem outras pessoas que estão lendo isso a se aproximarem do resultado desejado.

Nova string de escape no PowerShell V3, citada em Novos Recursos do Idioma V3 :

Reutilização mais fácil de linhas de comando do cmd.exe

A web está cheia de linhas de comando escritas para o Cmd.exe. Essas linhas de comando funcionam com bastante frequência no PowerShell, mas quando incluem determinados caracteres, por exemplo, um ponto-e-vírgula (;), um sinal de dólar ($) ou chaves, você precisa fazer algumas alterações, provavelmente adicionando algumas aspas. Esta parecia ser a fonte de muitas dores de cabeça menores.

Para ajudar a resolver esse cenário, adicionamos uma nova maneira de "escapar" da análise de linhas de comando. Se você usar um parâmetro mágico -%, interromperemos a análise normal da sua linha de comando e mudaremos para algo muito mais simples. Não combinamos aspas. Não paramos no ponto e vírgula. Não expandimos variáveis ​​do PowerShell. Expandimos as variáveis ​​de ambiente se você usar a sintaxe Cmd.exe (por exemplo,% TEMP%). Fora isso, os argumentos até o final da linha (ou canal, se você estiver canalizando) são passados ​​como estão. Aqui está um exemplo:

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

Você pode usar:

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"

O principal a ser observado aqui é que o FilePath deve estar na posição 0, de acordo com o Guia da Ajuda. Para chamar o guia de Ajuda de um commandlet, basta digitar Get-Help <Commandlet-name> -Detailed. Nesse caso, é Get-Help Start-Process -Detailed.

Tentei todas as sugestões, mas ainda não consegui executar msiexec.execom parâmetros que continham espaços. Então, minha solução acabou usando 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()

Isso funcionou para mim:

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

A chave parece ser que todo o comando está entre aspas externas, o "e" "comercial" é usado para especificar que outro arquivo de comando filho está sendo executado e, finalmente, as aspas com escape (dobrado-duplo-) ao redor do caminho / nome do arquivo com espaços em que você queria executar em primeiro lugar.

Isso também é a conclusão da única solução alternativa para o problema de conexão do MS que -File não repassa códigos de retorno diferentes de zero e -Command é a única alternativa. Mas até agora, pensava-se que uma limitação do comando era que não suportava espaços. Também atualizei esse item de feedback.

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

Uma resposta alternativa é usar uma opção de comando codificado em Base64 :

powershell -EncodedCommand "QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA=="

Quando decodificado, você verá que é o snippet original do OP com todos os argumentos e aspas duplas preservados.

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.

O comando original:

 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"

Isso se transforma quando codificado como Base64:

QwA6AFwAUAByAG8AZwByAGEAbQAgAEYAaQBsAGUAcwBcAEkASQBTAFwATQBpAGMAcgBvAHMAbwBmAHQAIABXAGUAYgAgAEQAZQBwAGwAbwB5AFwAbQBzAGQAZQBwAGwAbwB5AC4AZQB4AGUAIAAtAHYAZQByAGIAOgBzAHkAbgBjACAALQBzAG8AdQByAGMAZQA6AGQAYgBmAHUAbABsAHMAcQBsAD0AIgBEAGEAdABhACAAUwBvAHUAcgBjAGUAPQBtAHkAcwBvAHUAcgBjAGUAOwBJAG4AdABlAGcAcgBhAHQAZQBkACAAUwBlAGMAdQByAGkAdAB5AD0AZgBhAGwAcwBlADsAVQBzAGUAcgAgAEkARAA9AHMAYQA7AFAAdwBkAD0AcwBhAHAAYQBzAHMAIQA7AEQAYQB0AGEAYgBhAHMAZQA9AG0AeQBkAGIAOwAiACAALQBkAGUAcwB0ADoAZABiAGYAdQBsAGwAcwBxAGwAPQAiAEQAYQB0AGEAIABTAG8AdQByAGMAZQA9AC4AXABtAHkAZABlAHMAdABzAG8AdQByAGMAZQA7AEkAbgB0AGUAZwByAGEAdABlAGQAIABTAGUAYwB1AHIAaQB0AHkAPQBmAGEAbABzAGUAOwBVAHMAZQByACAASQBEAD0AcwBhADsAUAB3AGQAPQBzAGEAcABhAHMAcwAhADsARABhAHQAYQBiAGEAcwBlAD0AbQB5AGQAYgA7ACIALABjAG8AbQBwAHUAdABlAHIAbgBhAG0AZQA9ADEAMAAuADEAMAAuADEAMAAuADEAMAAsAHUAcwBlAHIAbgBhAG0AZQA9AGEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIALABwAGEAcwBzAHcAbwByAGQAPQBhAGQAbQBpAG4AcABhAHMAcwAiAA==

e aqui está como replicar em casa:

$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

Você pode executar arquivos exe de maneiras diferentes no PowerShell. Por exemplo, se você deseja executar o unrar.exe e extrair um arquivo .rar, basta escrever no PowerShell:

$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;

Mas, às vezes, isso não funciona, portanto, você deve usar o parâmetro &, como mostrado acima: Por exemplo, com o vboxmanage.exe (uma ferramenta para gerenciar máquinas virtuais de caixa virtual), você deve chamar os parameteres fora da string dessa maneira, sem aspas:

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

Se você deseja chamar simplesmente um arquivo arquivado no winrar como arquivos .exe, também pode descompactá-lo com o cmdlet invoke-command e um parâmetro Silent / S (ele se extrairá na mesma pasta em que foi compactado).

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

Portanto, existem várias maneiras de executar arquivos .exe com argumentos no PowerShell.

Às vezes, é preciso encontrar uma solução alternativa para fazê-lo funcionar corretamente, o que pode exigir mais esforço e sofrimento :) dependendo da maneira como o .exe foi compilado ou criado por seus criadores.

Eu uso esse método simples, limpo e eficaz.

Coloco argumentos em uma matriz, 1 por linha. Dessa forma, é muito fácil ler e editar. Então eu uso um truque simples de passar todos os argumentos dentro de aspas duplas para uma função com 1 único parâmetro. Isso os nivela, incluindo matrizes, em uma única string, que eu executo usando a 'Invoke-Expression' do PS. Esta diretiva foi projetada especificamente para converter uma string em um comando executável. Funciona bem:

                    # 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";

Eu tinha o seguinte código funcionando perfeitamente no meu laptop:

& $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"

Então, quando tentei executá-lo diretamente em um servidor, comecei a receber esses erros "Unrecognized argument ...etc.... All arguments must begin with "-". "

Depois de tentar todas as soluções possíveis (sem sucesso), descobri que o Powershell no servidor (Windows 2008 R2) era a versão 3.0, enquanto o meu laptop tinha 5.0. (você pode usar "$ PSVersionTable" para ver a versão).

Depois de atualizar o Powershell para a versão mais recente, ele começou a funcionar novamente.

O Cmd pode gerenciar a execução de um exe citado, mas o Powershell não pode. Eu só vou lidar com a execução do exe, já que não o tenho. Se você literalmente precisar enviar aspas duplas para o argumento de um comando externo, esse é outro problema que já foi abordado em outro lugar.

1) adicione a pasta exe ao seu caminho, talvez no seu perfil $

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

2) coloque entre aspas os espaços:

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

Então, encontrei um problema semelhante e resolvi resolvê-lo desta maneira:

1. Escapa os caracteres das aspas (") com um backtick (`)
2. Coloque sua nova expressão entre aspas (")
3. Usando o operador de chamada (&), emita o comando invoke-expressionna nova sequência

Solução de exemplo:

& {invoke-expression "C: \ Arquivos de programas \ IIS \ Microsoft Web Deploy \ msdeploy.exe -verb: sync -source: dbfullsql =` "Fonte de dados = mysource; Segurança integrada = false; Segurança integrada = false; ID do usuário = sa; Pwd = sapass !; Database = mydb; `" -dest: dbfullsql = `" Fonte de dados =. \ Mydestsource; Segurança integrada = false; ID do usuário = sa; Pwd = sapass!; Banco de dados = mydb; `", computername = 10.10.10.10, nome de usuário = administrador, senha = adminpass` ""}

Para o nome do executável, o cmdlet new-alias pode ser empregado para evitar lidar com espaços ou precisar adicionar o executável ao ambiente $ PATH.

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

Para listar ou modificar aliases de PS, consulte também

PS> get-alias
PS> set-alias

De Jeffery Hicks Aarticle

Outras respostas abordam os argumentos.