Add-Type
Adiciona uma classe do Microsoft .NET a uma sessão do PowerShell.
Sintaxe
Add-Type
[-CodeDomProvider <CodeDomProvider>]
[-CompilerParameters <CompilerParameters>]
[-TypeDefinition] <String>
[-Language <Language>]
[-ReferencedAssemblies <String[]>]
[-OutputAssembly <String>]
[-OutputType <OutputAssemblyType>]
[-PassThru]
[-IgnoreWarnings]
[<CommonParameters>]
Add-Type
[-CodeDomProvider <CodeDomProvider>]
[-CompilerParameters <CompilerParameters>]
[-Name] <String>
[-MemberDefinition] <String[]>
[-Namespace <String>]
[-UsingNamespace <String[]>]
[-Language <Language>]
[-ReferencedAssemblies <String[]>]
[-OutputAssembly <String>]
[-OutputType <OutputAssemblyType>]
[-PassThru]
[-IgnoreWarnings]
[<CommonParameters>]
Add-Type
[-CompilerParameters <CompilerParameters>]
[-Path] <String[]>
[-ReferencedAssemblies <String[]>]
[-OutputAssembly <String>]
[-OutputType <OutputAssemblyType>]
[-PassThru]
[-IgnoreWarnings]
[<CommonParameters>]
Add-Type
[-CompilerParameters <CompilerParameters>]
-LiteralPath <String[]>
[-ReferencedAssemblies <String[]>]
[-OutputAssembly <String>]
[-OutputType <OutputAssemblyType>]
[-PassThru]
[-IgnoreWarnings]
[<CommonParameters>]
Add-Type
-AssemblyName <String[]>
[-PassThru]
[-IgnoreWarnings]
[<CommonParameters>]
Description
O Add-Type
cmdlet permite definir uma classe do Microsoft .NET Framework em sua sessão do PowerShell.
Em seguida, você pode instanciar objetos, usando o New-Object
cmdlet, e usá-los da mesma forma que usaria qualquer objeto .NET Framework. Se você adicionar um Add-Type
comando ao seu perfil do PowerShell, a classe estará disponível em todas as sessões do PowerShell.
Você pode especificar o tipo especificando um assembly existente ou arquivos de código-fonte, ou você pode especificar o código-fonte embutido ou salvo em uma variável. Você pode até especificar apenas um método e Add-Type
definirá e gerará a classe. No Windows, você pode usar esse recurso para fazer chamadas de Invocação de Plataforma (P/Invoke) para funções não gerenciadas no PowerShell. Se você especificar o código-fonte, Add-Type
compilará o código-fonte especificado e gerará um assembly na memória que contém os novos tipos do .NET Framework.
Você pode usar os parâmetros de para especificar uma linguagem e um compilador alternativos, C# é o padrão, opções do compilador, dependências de Add-Type
assembly, o namespace de classe, os nomes do tipo e o assembly resultante.
Exemplos
Exemplo 1: Adicionar um tipo .NET a uma sessão
Este exemplo adiciona a classe BasicTest à sessão especificando o código-fonte armazenado em uma variável. A classe BasicTest é usada para adicionar números inteiros, criar um objeto e multiplicar números inteiros.
$Source = @"
public class BasicTest
{
public static int Add(int a, int b)
{
return (a + b);
}
public int Multiply(int a, int b)
{
return (a * b);
}
}
"@
Add-Type -TypeDefinition $Source
[BasicTest]::Add(4, 3)
$BasicTestObject = New-Object BasicTest
$BasicTestObject.Multiply(5, 2)
A $Source
variável armazena o código-fonte da classe. O tipo tem um método estático chamado Add
e um método não estático chamado Multiply
.
O Add-Type
cmdlet adiciona a classe à sessão. Como ele está usando código-fonte embutido, o comando usa o parâmetro TypeDefinition para especificar o $Source
código na variável.
O Add
método estático da classe BasicTest usa os caracteres de dois-pontos duplos (::
) para especificar um membro estático da classe. Os números inteiros são adicionados e a soma é exibida.
O New-Object
cmdlet instancia uma instância da classe BasicTest . Ele salva o novo objeto na $BasicTestObject
variável.
$BasicTestObject
usa o Multiply
método. Os números inteiros são multiplicados e o produto é exibido.
Exemplo 2: Examinar um tipo adicionado
Este exemplo usa o Get-Member
cmdlet para examinar os objetos que os Add-Type
cmdlets e New-Object
criaram no Exemplo 1.
[BasicTest] | Get-Member
TypeName: System.RuntimeType
Name MemberType Definition
---- ---------- ----------
AsType Method type AsType()
Clone Method System.Object Clone(), System.Object ICloneable.Clone()
Equals Method bool Equals(System.Object obj), bool Equals(type o)
FindInterfaces Method type[] FindInterfaces(System.Reflection.TypeFilter filter...
...
[BasicTest] | Get-Member -Static
TypeName: BasicTest
Name MemberType Definition
---- ---------- ----------
Add Method static int Add(int a, int b)
Equals Method static bool Equals(System.Object objA, System.Object objB)
new Method BasicTest new()
ReferenceEquals Method static bool ReferenceEquals(System.Object objA, System.Object objB)
$BasicTestObject | Get-Member
TypeName: BasicTest
Name MemberType Definition
---- ---------- ----------
Equals Method bool Equals(System.Object obj)
GetHashCode Method int GetHashCode()
GetType Method type GetType()
Multiply Method int Multiply(int a, int b)
ToString Method string ToString()
O Get-Member
cmdlet obtém o tipo e os membros da classe BasicTest que Add-Type
foram adicionados à sessão. O Get-Member
comando revela que é um objeto System.RuntimeType , que é derivado da classe System.Object .
O Get-Member
parâmetro Static obtém as propriedades estáticas e os métodos da classe BasicTest . A saída mostra que o Add
método está incluído.
O Get-Member
cmdlet obtém os membros do objeto armazenados na $BasicTestObject
variável.
$BasicTestObject
foi criado usando o New-Object
cmdlet com a classe BasicTest . A saída revela que o $BasicTestObject
valor da variável é uma instância da classe BasicTest e que inclui um membro chamado Multiply
.
Exemplo 3: Adicionar tipos de um assembly
Este exemplo adiciona as classes do Accessibility.dll
assembly à sessão atual.
$AccType = Add-Type -AssemblyName "accessib*" -PassThru
A $AccType
variável armazena um objeto criado com o Add-Type
cmdlet. Add-Type
usa o parâmetro AssemblyName para especificar o nome do assembly. O caractere curinga asterisco (*
) permite que você obtenha a montagem correta mesmo quando não tiver certeza do nome ou da ortografia. O parâmetro PassThru gera objetos que representam as classes que são adicionadas à sessão.
Exemplo 4: Chamar APIs nativas do Windows
Este exemplo demonstra como chamar APIs nativas do Windows no PowerShell. Add-Type
usa o mecanismo de Invocação de Plataforma (P/Invoke) para chamar uma função User32.dll
do PowerShell. Este exemplo funciona apenas em computadores que executam o sistema operacional Windows.
$Signature = @"
[DllImport("user32.dll")]public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
"@
$addTypeSplat = @{
MemberDefinition = $Signature
Name = "Win32ShowWindowAsync"
Namespace = 'Win32Functions'
PassThru = $true
}
$ShowWindowAsync = Add-Type @addTypeSplat
# Minimize the PowerShell console
$ShowWindowAsync::ShowWindowAsync((Get-Process -Id $pid).MainWindowHandle, 2)
# Restore the PowerShell console
$ShowWindowAsync::ShowWindowAsync((Get-Process -Id $Pid).MainWindowHandle, 4)
A $Signature
variável armazena a assinatura C# da ShowWindowAsync
função. Para garantir que o método resultante esteja visível em uma sessão do PowerShell, a public
palavra-chave foi adicionada à assinatura padrão. Para obter mais informações, consulte Função ShowWindowAsync .
A $ShowWindowAsync
variável armazena o objeto criado pelo Add-Type
parâmetro PassThru .
O Add-Type
cmdlet adiciona a ShowWindowAsync
função à sessão do PowerShell como um método estático. O comando usa o parâmetro MemberDefinition para especificar a definição de método salva na $Signature
variável. O comando usa os parâmetros Name e Namespace para especificar um nome e um namespace para a classe. O parâmetro PassThru gera um objeto que representa os tipos.
O novo ShowWindowAsync
método estático é usado nos comandos para minimizar e restaurar o console do PowerShell. O método usa dois parâmetros: o identificador da janela e um inteiro que especifica como a janela é exibida.
Para minimizar o console do PowerShell, ShowWindowAsync
use o Get-Process
cmdlet com a $PID
variável automática para obter o processo que está hospedando a sessão atual do PowerShell. Em seguida, ele usa a propriedade MainWindowHandle do processo atual e um valor de 2
, que representa o SW_MINIMIZE
valor.
Para restaurar a janela, ShowWindowAsync
usa um valor de para a posição da 4
janela, que representa o SW_RESTORE
valor.
Para maximizar a janela, use o valor de 3
que representa SW_MAXIMIZE
.
Exemplo 5: Adicionar um tipo de um arquivo do Visual Basic
Este exemplo usa o Add-Type
cmdlet para adicionar a classe VBFromFile definida no Hello.vb
arquivo à sessão atual. O texto do Hello.vb
arquivo é mostrado na saída do comando.
Add-Type -Path "C:\PS-Test\Hello.vb"
[VBFromFile]::SayHello(", World")
# From Hello.vb
Public Class VBFromFile
Public Shared Function SayHello(sourceName As String) As String
Dim myValue As String = "Hello"
return myValue + sourceName
End Function
End Class
Hello, World
Add-Type
usa o parâmetro Path para especificar o arquivo de origem, Hello.vb
, e adiciona o tipo definido no arquivo. A SayHello
função é chamada como um método estático da classe VBFromFile .
Exemplo 6: Adicionar uma classe com JScript.NET
Este exemplo usa JScript.NET para criar uma nova classe, FRectangle, em sua sessão do PowerShell.
Add-Type @'
class FRectangle {
var Length : double;
var Height : double;
function Perimeter() : double {
return (Length + Height) * 2; }
function Area() : double {
return Length * Height; } }
'@ -Language JScript
$rect = [FRectangle]::new()
$rect
Length Height
------ ------
0 0
Exemplo 7: Adicionar um compilador F#
Este exemplo mostra como usar o Add-Type
cmdlet para adicionar um compilador de código F# à sua sessão do PowerShell. Para executar este exemplo no PowerShell, você deve ter o FSharp.Compiler.CodeDom.dll
que está instalado com a linguagem F#.
Add-Type -Path "FSharp.Compiler.CodeDom.dll"
$Provider = New-Object Microsoft.FSharp.Compiler.CodeDom.FSharpCodeProvider
$FSharpCode = @"
let rec loop n =if n <= 0 then () else beginprint_endline (string_of_int n);loop (n-1)end
"@
$FSharpType = Add-Type -TypeDefinition $FSharpCode -CodeDomProvider $Provider -PassThru |
Where-Object { $_.IsPublic }
$FSharpType::loop(4)
4
3
2
1
Add-Type
usa o parâmetro Path para especificar um assembly e obtém os tipos no assembly.
New-Object
cria uma instância do provedor de código F# e salva o $Provider
resultado na variável. A $FSharpCode
variável salva o código F# que define o método Loop .
A $FSharpType
variável armazena os resultados do Add-Type
cmdlet que salva os tipos públicos definidos no $FSharpCode
. O parâmetro TypeDefinition especifica o código-fonte que define os tipos. O parâmetro CodeDomProvider especifica o compilador de código-fonte. O parâmetro PassThru direciona Add-Type
para retornar um objeto Runtime que representa os tipos.
Os objetos são enviados pelo pipeline para o Where-Object
cmdlet, que retorna apenas os tipos públicos. O Where-Object
cmdlet é usado porque o provedor F# gera tipos não públicos para dar suporte ao tipo público resultante.
O método Loop é chamado como um método estático do tipo armazenado na $FSharpType
variável.
Parâmetros
-AssemblyName
Especifica o nome de um assembly que inclui os tipos. Add-Type
usa os tipos do assembly especificado. Esse parâmetro é necessário quando você está criando tipos com base em um nome de assembly.
Insira o nome completo ou simples, também conhecido como nome parcial, de um assembly. Caracteres curinga são permitidos no nome do assembly. Se você inserir um nome simples ou parcial, Add-Type
resolve-o com o nome completo e, em seguida, usa o nome completo para carregar o assembly.
O uso dos parâmetros Path ou LiteralPath garante que você esteja carregando o assembly que pretendia carregar. Quando você usa o parâmetro AssemblyName, o PowerShell solicita que o .NET resolva o nome do assembly usando o processo de resolução de assembly padrão do .NET. Como o .NET pesquisa a pasta do aplicativo primeiro, Add-Type
pode carregar um assembly em vez da $PSHOME
versão na pasta atual. Para obter mais informações, consulte Local do assembly.
Se o .NET não resolver o nome, o PowerShell procurará no local atual para localizar o assembly. Quando você usa curingas no parâmetro AssemblyName , o processo de resolução do assembly do .NET falha, fazendo com que o PowerShell procure no local atual.
Tipo: | String[] |
Aliases: | AN |
Cargo: | Named |
Valor padrão: | None |
Obrigatório: | True |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | True |
-CodeDomProvider
Especifica um compilador ou gerador de código. Add-Type
usa o compilador especificado para compilar o código-fonte. O padrão é o compilador C#. Use esse parâmetro se você estiver usando um idioma que não pode ser especificado usando o parâmetro Language . O CodeDomProvider especificado deve ser capaz de gerar assemblies do código-fonte.
Tipo: | CodeDomProvider |
Aliases: | Provider |
Cargo: | Named |
Valor padrão: | C# compiler |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-CompilerParameters
Especifica as opções para o compilador de código fonte. Essas opções são enviadas sem revisão para o compilador.
Esse parâmetro permite que você direcione o compilador para gerar um arquivo executável, inserir recursos ou definir opções de linha de comando, como a /unsafe
opção. Esse parâmetro implementa a classe CompilerParameters , System.CodeDom.Compiler.CompilerParameters.
Você não pode usar os parâmetros CompilerParameters e ReferencedAssemblies no mesmo comando.
Tipo: | CompilerParameters |
Aliases: | CP |
Cargo: | Named |
Valor padrão: | None |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-IgnoreWarnings
Ignora os avisos do compilador. Use esse parâmetro para impedir o Add-Type
tratamento de avisos do compilador como erros.
Tipo: | SwitchParameter |
Cargo: | Named |
Valor padrão: | False |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-Language
Especifica a linguagem usada no código-fonte. O Add-Type
cmdlet usa o valor desse parâmetro para selecionar o CodeDomProvider apropriado. CSharp é o valor padrão. Os valores aceitáveis para este parâmetro são os seguintes:
CSharp
CSharpVersion2
CSharpVersion3
JScript
VisualBasic
Tipo: | Language |
Valores aceitos: | CSharp, CSharpVersion2, CSharpVersion3, JScript, VisualBasic |
Cargo: | Named |
Valor padrão: | CSharp |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-LiteralPath
Especifica o caminho para arquivos de código fonte ou arquivos DLL de assembly que contêm os tipos. Ao contrário de Path, o valor do parâmetro LiteralPath é usado exatamente como é digitado. Nenhum caractere é interpretado como caractere curinga. Se o caminho incluir caracteres de escape, coloque-o entre aspas simples. As aspas simples informam ao PowerShell para não interpretar nenhum caractere como sequências de escape.
O uso dos parâmetros Path ou LiteralPath garante que você esteja carregando o assembly que pretendia carregar.
Tipo: | String[] |
Aliases: | PSPath |
Cargo: | Named |
Valor padrão: | None |
Obrigatório: | True |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-MemberDefinition
Especifica novas propriedades ou métodos para a classe. Add-Type
gera o código de modelo necessário para dar suporte às propriedades ou métodos.
No Windows, você pode usar esse recurso para fazer chamadas de Invocação de Plataforma (P/Invoke) para funções não gerenciadas no PowerShell.
Tipo: | String[] |
Cargo: | 1 |
Valor padrão: | None |
Obrigatório: | True |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-Name
Especifica o nome da classe a ser criada. Esse parâmetro é necessário ao gerar um tipo por meio de uma definição de membro.
O nome do tipo e o namespace devem ser exclusivos dentro de uma sessão. Você não pode descarregar um tipo ou alterá-lo. Para alterar o código de um tipo, você deve alterar o nome ou iniciar uma nova sessão do PowerShell. Caso contrário, o comando falhará.
Tipo: | String |
Cargo: | 0 |
Valor padrão: | None |
Obrigatório: | True |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-Namespace
Especifica um namespace para o tipo.
Se esse parâmetro não estiver incluído no comando, o tipo será criado no namespace Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes . Se o parâmetro for incluído no comando com um valor de cadeia de caracteres vazio ou um valor de $Null
, o tipo será gerado no namespace global.
Tipo: | String |
Aliases: | NS |
Cargo: | Named |
Valor padrão: | None |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-OutputAssembly
Gera um arquivo DLL para o assembly com o nome especificado no local. Insira um caminho e um nome de arquivo opcionais. Caracteres curinga são permitidos. Por padrão, Add-Type
gera o assembly somente na memória.
Tipo: | String |
Aliases: | OA |
Cargo: | Named |
Valor padrão: | None |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | True |
-OutputType
Especifica o tipo de saída do assembly de saída. Por padrão, nenhum tipo de saída é especificado. Este parâmetro é válido somente quando um assembly de saída é especificado no comando. Para obter mais informações sobre os valores, consulte Enumeração OutputAssemblyType.
Os valores aceitáveis para este parâmetro são os seguintes:
ConsoleApplication
Library
WindowsApplication
Tipo: | OutputAssemblyType |
Aliases: | OT |
Valores aceitos: | ConsoleApplication, Library, WindowsApplication |
Cargo: | Named |
Valor padrão: | None |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-PassThru
Retorna um objeto System.Runtime que representa os tipos que foram adicionados. Por padrão, esse cmdlet não gera nenhuma saída.
Tipo: | SwitchParameter |
Cargo: | Named |
Valor padrão: | False |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-Path
Especifica o caminho para arquivos de código fonte ou arquivos DLL de assembly que contêm os tipos.
Se você enviar arquivos de código-fonte, Add-Type
compilará o código nos arquivos e criará um assembly na memória dos tipos. A extensão de arquivo especificada no valor de Path determina o compilador que Add-Type
usa.
Se você enviar um arquivo de assembly, o usará Add-Type
os tipos do assembly. Para especificar um assembly na memória ou o cache de assembly global, use o parâmetro AssemblyName .
Tipo: | String[] |
Cargo: | 0 |
Valor padrão: | None |
Obrigatório: | True |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-ReferencedAssemblies
Especifica os assemblies dos quais depende o tipo. Por padrão, Add-Type
referências System.dll
e System.Management.Automation.dll
. Os assemblies que você especificar usando esse parâmetro são referenciados além os assemblies padrão.
Você não pode usar os parâmetros CompilerParameters e ReferencedAssemblies no mesmo comando.
Tipo: | String[] |
Aliases: | RA |
Cargo: | Named |
Valor padrão: | None |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-TypeDefinition
Especifica o código-fonte que contém as definições de tipo. Insira o código-fonte em uma cadeia de caracteres ou cadeia de caracteres here, ou insira uma variável que contenha o código-fonte. Para obter mais informações sobre here-strings, consulte about_Quoting_Rules.
Inclua uma declaração de namespace em sua definição de tipo. Se você omitir a declaração de namespace, seu tipo pode ter o mesmo nome que outro tipo ou o atalho para outro tipo, causando uma substituição não intencional. Por exemplo, se você definir um tipo chamado Exception, os scripts que usam Exception como atalho para System.Exception falharão.
Tipo: | String |
Cargo: | 0 |
Valor padrão: | None |
Obrigatório: | True |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
-UsingNamespace
Especifica outros namespaces que são necessários para a classe. Isso é muito parecido com a palavra-chave C#, Using
.
Por padrão, Add-Type
faz referência ao namespace System . Quando o parâmetro MemberDefinition é usado, Add-Type
também faz referência ao namespace System.Runtime.InteropServices por padrão. Os namespaces que você adiciona usando o parâmetro UsingNamespace são referenciados além dos namespaces padrão.
Tipo: | String[] |
Aliases: | Using |
Cargo: | Named |
Valor padrão: | System namespace |
Obrigatório: | False |
Aceitar a entrada de pipeline: | False |
Aceitar caracteres curinga: | False |
Entradas
None
Você não pode canalizar objetos para esse cmdlet.
Saídas
None
Por padrão, esse cmdlet não retorna nenhuma saída.
Quando você usa o parâmetro PassThru , esse cmdlet retorna um objeto System.Type que representa o novo tipo.
Observações
Os tipos que você adiciona existem apenas na sessão atual. Para usar os tipos em todas as sessões, adicione-os ao seu perfil do PowerShell. Para obter mais informações sobre o perfil, consulte about_Profiles.
Os nomes de tipo e namespaces devem ser exclusivos em uma sessão. Você não pode descarregar um tipo ou alterá-lo. Se você precisar alterar o código de um tipo, deverá alterar o nome ou iniciar uma nova sessão do PowerShell. Caso contrário, o comando falhará.
A classe CodeDomProvider para algumas linguagens, como IronPython e J#, não gera saída. Como resultado, os tipos escritos nessas linguagens não podem ser usados com Add-Type
.
Esse cmdlet é baseado na classe CodeDomProvider do Microsoft .NET Framework.