Add-Type

Adiciona um tipo Microsoft .NET Framework (uma classe) a uma sessão do Windows PowerShell.

Sintaxe

Add-Type -AssemblyName <string[]> [-IgnoreWarnings] [-PassThru] [<CommonParameters>]

Add-Type [-Name] <string> [-MemberDefinition] <string[]> [-CodeDomProvider <CodeDomProvider>] [-CompilerParameters <CompilerParameters>] [-Language {<CSharp> | <CSharpVersion3> | <VisualBasic> | <JScript>}] [-Namespace <string>] [-OutputAssembly <string>] [-OutputType <OutputAssemblyType>] [-ReferencedAssemblies <string[]>] [-UsingNamespace <string[]>] [-IgnoreWarnings] [-PassThru] [<CommonParameters>]

Add-Type [-Path] <string[]> [-CompilerParameters <CompilerParameters>] [-OutputAssembly <string>] [-OutputType <OutputAssemblyType>] [-ReferencedAssemblies <string[]>] [-IgnoreWarnings] [-PassThru] [<CommonParameters>]

Add-Type [-TypeDefinition] <string> [-CodeDomProvider <CodeDomProvider>] [-CompilerParameters <CompilerParameters>] [-Language {<CSharp> | <CSharpVersion3> | <VisualBasic> | <JScript>}] [-OutputAssembly <string>] [-OutputType <OutputAssemblyType>] [-ReferencedAssemblies <string[]>] [-IgnoreWarnings] [-PassThru] [<CommonParameters>]

Descrição

O cmdlet Add-Type permite que você defina uma classe .NET Framework em sua sessão do Windows PowerShell. Em seguida, é possível criar uma instância de objetos (usando o cmdlet New-Object) e usar os objetos, da mesma maneira que você usa qualquer objeto .NET Framework. Se você adicionar um comando Add-Type a seu perfil do Windows PowerShell, a classe será disponibilizada em todas as sessões do Windows PowerShell.

Você pode determinar o tipo especificando um assembly existente ou arquivos de código-fonte ou especificar código-fonte embutido ou salvo em uma variável. Você pode até especificar apenas um método e o Add-Type definirá e gerará a classe. É possível usar esse recurso para fazer chamadas de Invocação de Plataforma (P/Invoque) para funções não gerenciadas no Windows PowerShell. Se você especificar código-fonte, Add-Type compilará o código-fonte especificado e gerará um assembly na memória contendo os novos tipos .NET Framework.

É possível usar os parâmetros de Add-Type para especificar uma linguagem e um compilador (CSharp é o padrão) alternativos, opções de compilador, dependências de assembly, o namespace da classe, os nomes do tipo e o assembly resultante.

Parâmetros

-AssemblyName <string[]>

Especifica o nome de um assembly que inclui os tipos. O Add-Type utiliza 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 o "nome parcial") de um assembly. São permitidos caracteres curinga no nome do assembly. Se você inserir um nome simples ou parcial, o Add-Type o resolverá para o nome completo e usará o nome completo para carregar o assembly.

Esse parâmetro não aceita um caminho ou nome de arquivo. Para inserir o caminho para o arquivo DLL (Biblioteca de vínculo dinâmico) do assembly, use o parâmetro Path.

Necessário?	true
Posição?	named
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	true

-CodeDomProvider <CodeDomProvider>

Especifica um gerador de código ou compilador. O Add-Type usa o compilador especificado para compilar o código-fonte. O padrão é o compilador CSharp. Use esse parâmetro se estiver usando uma linguagem que não pode ser especificada usando o parâmetro Language. O CodeDomProvider especificado deve poder gerar assemblies a partir do código-fonte.

Necessário?	false
Posição?	named
Valor padrão	Compilador CSharp
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-CompilerParameters <CompilerParameters>

Especifica as opções do compilador de código-fonte. Essas opções são enviadas ao compilador sem revisão.

Esse parâmetro permite direcionar o compilador para gerar um arquivo executável, incorporar recursos ou definir opções de linha de comando, como a opção "/unsafe". Ele implementa a classe CompilerParameters (System.CodeDom.Compiler.CompilerParameters).

Necessário?	false
Posição?	named
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-IgnoreWarnings

Ignora avisos do compilador. Use este parâmetro para impedir que Add-Type trate avisos do compilador como erros.

Necessário?	false
Posição?	named
Valor padrão	False
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-Language <Language>

Especifica a linguagem usada no código-fonte. O Add-Type usa a linguagem para selecionar o compilador de código correto.

Os valores válidos são: "CSharp", "CSharpVersion3", "VisualBasic" e "JScript". “CSharp” é o padrão.

Necessário?	false
Posição?	named
Valor padrão	CSharp
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-MemberDefinition <string[]>

Especifica novas propriedades ou métodos da classe. O Add-Type gera o código de modelo que é necessário para dar suporte às propriedades ou métodos.

É possível usar esse recurso para fazer chamadas de Invocação de Plataforma (P/Invoque) para funções não gerenciadas no Windows PowerShell. Para obter mais informações, consulte os exemplos.

Necessário?	true
Posição?	2
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-Name <string>

Especifica o nome da classe a ser criada. Esse parâmetro é necessário ao gerar um tipo de uma definição de membro.

O nome e o namespace do tipo devem ser exclusivos dentro de uma sessão. Você não pode descarregar ou alterar um tipo. Se você precisar alterar o código de um tipo, deverá alterar o nome ou iniciar uma nova sessão do Windows PowerShell. Caso contrário, o comando falhará.

Necessário?	true
Posição?	1
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-Namespace <string>

Especifica um namespace para o tipo.

Se esse parâmetro não for 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 vazia ou um valor de $null, o tipo será gerado no namespace global.

Necessário?	false
Posição?	named
Valor padrão	Microsoft.PowerShell.Commands.AddType.AutoGeneratedTypes
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-OutputAssembly <string>

Gera um arquivo DLL para o assembly com o nome especificado no local. Digite um caminho (opcional) e um nome de arquivo. São permitidos caracteres curinga. Por padrão, o Add-Type gera o assembly apenas na memória.

Necessário?	false
Posição?	named
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	true

-OutputType <OutputAssemblyType>

Especifica o tipo de saída do assembly de saída. Os valores válidos são Library, ConsoleApplication e WindowsApplication.

Por padrão, nenhum tipo de saída é especificado.

Este parâmetro é válido apenas quando um assembly de saída é especificado no comando.

Necessário?	false
Posição?	named
Valor padrão	Nenhum
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-PassThru

Retorna um objeto System.Runtime que representa os tipos adicionados. Por padrão, este cmdlet não gera nenhuma saída.

Necessário?	false
Posição?	named
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-Path <string[]>

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, o Add-Type compilará o código nos arquivos e criará um assembly na memória dos tipos. A extensão de nome de arquivo especificada no valor de Path determina o compilador a ser usado pelo Add-Type.

Se você enviar um arquivo de assembly, o Add-Type utilizará os tipos do assembly. Para especificar um assembly na memória ou o GAC (Cache de Assembly Global) use o parâmetro AssemblyName.

Necessário?	true
Posição?	1
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-ReferencedAssemblies <string[]>

Especifica os assemblies dos quais o tipo depende. Por padrão, o Add-Type referencia System.dll e System.Management.Automation.dll. Os assemblies especificados usando esse parâmetro são referenciados além dos assemblies padrão.

Necessário?	false
Posição?	named
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-TypeDefinition <string>

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 cadeias de caracteres here, 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 poderá ter o mesmo nome que outro tipo ou o atalho para outro tipo provocando uma substituição não intencional. Por exemplo, se você definir um tipo denominado "Exception", haverá falha nos scripts que usarem "Exception" como o atalho para System.Exception.

Necessário?	true
Posição?	1
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

-UsingNamespace <string[]>

Especifica outros namespaces que são necessários para a classe. É muito parecido com a palavra-chave Using no C#.

Por padrão, o Add-Type referencia o namespace System. Quando o parâmetro MemberDefinition é usado, por padrão, o Add-Type também referencia o namespace System.Runtime.InteropServices. Os namespaces adicionados usando o parâmetro UsingNamespace são referenciados além dos namespaces padrão.

Necessário?	false
Posição?	named
Valor padrão
Aceitar entrada do pipeline?	false
Aceitar caracteres curinga?	false

<CommonParameters>

Esse cmdlet oferece suporte aos parâmetros comuns: -Verbose, -Debug, -ErrorAction, -ErrorVariable, -OutBuffer e -OutVariable. Para obter mais informações, consulte about_Commonparameters.

Entradas e saídas

O tipo de entrada é o tipo dos objetos que você pode canalizar para o cmdlet. O tipo de retorno é o tipo dos objetos que o cmdlet retorna.

Entradas	Nenhum Não é possível enviar objetos para Add-Type.
Saídas	Nenhum ou System.RuntimeType Quando você usar o parâmetro PassThru, Add-Type retornará um objeto System.RuntimeType que representa o novo tipo. Caso contrário, esse cmdlet não gera nenhuma saída.

Observações

Os tipos adicionados existem apenas na sessão atual. Para usar os tipos em todas as sessões, adicione-os ao perfil do Windows PowerShell. Para obter mais informações sobre os perfis, consulte about_Profiles.

Os nomes (e os namespaces) do tipo devem ser exclusivos dentro de uma sessão. Você não pode descarregar ou alterar um tipo. Se você precisar alterar o código de um tipo, deverá alterar o nome ou iniciar uma nova sessão do Windows PowerShell. Caso contrário, o comando falhará.

A classe CodeDomProvider para algumas linguagens, como IronPython e JSharp, não gera saída. Como resultado, os tipos gravados nessas linguagens não podem ser usados com o Add-Type.

Esse cmdlet é baseado na classe CodeDomProvider. Para obter mais informações sobre essa classe, consulte o Microsoft .NET Framework SDK.

Exemplo 1

C:\PS>$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);
    }
}
"@

C:\PS> Add-Type -TypeDefinition $source

C:\PS> [BasicTest]::Add(4, 3)

C:\PS> $basicTestObject = New-Object BasicTest 
C:\PS> $basicTestObject.Multiply(5, 2)

Descrição
-----------
Esses comandos adicionam a classe BasicTest à sessão especificando código-fonte que é armazenado em uma variável. O tipo tem um método estático chamado Add e um método não estático chamado Multiplique.

O primeiro comando armazena o código-fonte da classe na variável $source.

O segundo comando usa o cmdlet Add-Type para adicionar a classe à sessão. Como ele está usando código-fonte embutido, o comando usa o parâmetro TypeDefinition para especificar o código na variável $source.

Os comandos restantes usam a nova classe.

O terceiro comando chama o método estático Add da classe BasicTest. Ele usa os caracteres de dois-pontos duplos (::) para especificar um membro estático da classe.

O quarto comando usa o cmdlet New-Object para criar uma instância da classe BasicTest. Ele salva o novo objeto na variável $basicTestObject. 

O quinto comando usa o método Multiply de $basicTestObject.

Exemplo 2

C:\PS>[BasicTest] | get-member

C:\PS> [BasicTest] | get-member -static

C:\PS> $basicTestObject | get-member

C:\PS> [BasicTest] | get-member


   TypeName: System.RuntimeType

Name                           MemberType Definition
----                           ---------- ----------
Clone                          Method     System.Object Clone()
Equals                         Method     System.Boolean Equals
FindInterfaces                 Method     System.Type[] FindInt
...


C:\PS> [BasicTest] | get-member -static

   TypeName: BasicTest

Name            MemberType Definition
----            ---------- ----------
Add             Method     static System.Int32 Add(Int32 a, Int32 b)
Equals          Method     static System.Boolean Equals(Object objA,
ReferenceEquals Method     static System.Boolean ReferenceEquals(Obj


C:\PS> $basicTestObject | get-member

   TypeName: BasicTest

Name        MemberType Definition
----        ---------- ----------
Equals      Method     System.Boolean Equals(Object obj)
GetHashCode Method     System.Int32 GetHashCode()
GetType     Method     System.Type GetType()
Multiply    Method     System.Int32 Multiply(Int32 a, Int32 b)
ToString    Method     System.String ToString()

Descrição
-----------
Esses comandos usam o cmdlet Get-Member para examinar os objetos que os cmdlets Add-Type e New-Object criaram no exemplo anterior.

O primeiro comando usa o cmdlet Get-Member para obter o tipo e os membros da classe BasicTest que o Add-Type adicionou à sessão. O comando Get-Member revela que ele é um objeto System.RuntimeType derivado da classe System.Object.

O segundo comando usa o parâmetro Static de Get-Member para obter as propriedades e os métodos estáticos da classe BasicTest. A saída mostra que o método Add está incluído.

O terceiro comando usa Get-Member para obter os membros do objeto armazenado na variável $BasicTestObject. Essa foi a instância do objeto que foi criada usando o cmdlet New-Object com a classe $BasicType. 

A saída revela que o valor da variável $basicTestObject é uma instância da classe BasicTest e que ela inclui um membro chamado Multiply.

Exemplo 3

C:\PS>$accType = add-type -assemblyname accessib* -passthru

Descrição
-----------
Esse comando adiciona as classes do assembly Acessibility à sessão atual. O comando usa o parâmetro AssemblyName para especificar o nome do assembly. O caractere curinga permite obter o assembly correto, mesmo quando você não tem certeza sobre o nome ou sua ortografia.

O comando usa o parâmetro PassThru para gerar objetos que representam as classes adicionadas à sessão e salva os objetos na variável $accType.

Exemplo 4

C:\PS>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

C:\PS> [VBFromFile]::SayHello(", World")
Hello, World

Descrição
-----------
Esse exemplo usa o cmdlet Add-Type para adicionar a classe VBFromFile definida no arquivo Hello.vb para a sessão atual. O texto do arquivo Hello.vb é mostrado na saída do comando.

O primeiro comando usa o cmdlet Add-Type para adicionar o tipo definido no arquivo Hello.vb à sessão atual. O comando usa o parâmetro path para especificar o arquivo de origem. 

O segundo comando chama a função SayHello como um método estático da classe VBFromFile.

Exemplo 5

C:\PS>$signature = @"
[DllImport("user32.dll")]
public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
"@

$showWindowAsync = Add-Type -memberDefinition $signature -name "Win32ShowWindowAsync" -namespace Win32Functions -passThru

# Minimize the Windows PowerShell console
$showWindowAsync::ShowWindowAsync((Get-Process -id $pid).MainWindowHandle, 2) 

# Restore it
$showWindowAsync::ShowWindowAsync((Get-Process -id $pid).MainWindowHandle, 4)

Descrição
-----------
Os comandos desse exemplo demonstram como chamar APIs nativas do Windows no Windows PowerShell. O Add-Type usa o mecanismo de Invocação de Plataforma (P/Invoque) para chamar uma função no User32.dll do Windows PowerShell.

O primeiro comando armazena a assinatura do C# da função ShowWindowAsync na variável $signature. (Para obter mais informações, consulte "ShowWindowAsync Function" (em inglês) na biblioteca do MSDN em https://go.microsoft.com/fwlink/?LinkId=143643.) Para garantir que o método resultante será visível em uma sessão do Windows PowerShell, a palavra-chave "public" foi adicionada à assinatura padrão.

O segundo comando usa o cmdlet Add-Type para adicionar a função ShowWindowAsync à sessão do Windows PowerShell como um método estático de uma classe criada pelo Add-Type. O comando usa o parâmetro MemberDefinition para especificar a definição do método salva na variável $signature.
 
O comando usa os parâmetros Name e Namespace para especificar um nome e um namespace para a classe. Ele usa o parâmetro PassThru para gerar um objeto que representa os tipos e salva o objeto na variável $showWindowAsync.

O terceiro e o quarto comandos usam o novo método estático ShowWindowAsync. O método usa dois parâmetros, o identificador de janela e um inteiro especificam como a janela será mostrada.

O terceiro comando chama-se ShowWindowAsync. Ele usa o cmdlet Get-Process com a variável automática $pid para obter o processo que está hospedando a sessão atual do Windows PowerShell. Em seguida, ele usa a propriedade MainWindowHandle do processo atual e um valor de “2” que representa o valor de SW_MINIMIZE.

Para restaurar a janela, o quarto comando usa um valor de “4” para a posição da janela, que representa o valor de SW_RESTORE. (SW_MAXIMIZE é 3.)

Exemplo 6

C:\PS>Add-Type -MemberDefinition $jsMethod -Name "PrintInfo" -Language JScript

Descrição
-----------
Esse comando usa o cmdlet Add-Type para adicionar um método do código JScript embutido à sessão do Windows PowerShell. Usa o parâmetro MemberDefinition para enviar código-fonte armazenado na variável $jsMethod. Ele usa a variável Name para especificar um nome para a classe que o Add-Type cria para o método e o parâmetro Language para especificar a linguagem JScript.

Exemplo 7

C:\PS>Add-Type -Path FSharp.Compiler.CodeDom.dll


C:\PS> Add-Type -Path FSharp.Compiler.CodeDom.dll
C:\PS> $provider = New-Object Microsoft.FSharp.Compiler.CodeDom.FSharpCodeProvider

C:\PS> $fSharpCode = @" 
let rec loop n = 
if n <= 0 then () else begin
print_endline (string_of_int n);
loop (n-1)
end
"@

C:\PS> $fsharpType = Add-Type -TypeDefinition $fSharpCode -CodeDomProvider $provider -PassThru | where { $_.IsPublic }
C:\PS> $fsharpType::loop(4)
4
3
2
1

Descrição
-----------
Esse exemplo mostra como usar o cmdlet Add-Type para adicionar um compilador de código de FSharp a sua sessão do Windows PowerShell. Para executar esse exemplo no Windows PowerShell, você deve ter o FSharp.Compiler.CodeDom.dll que é instalado com a linguagem FSharp.

O primeiro comando no exemplo usa o cmdlet Add-Type com o parâmetro Path para especificar um assembly. O Add-Type obtém os tipos no assembly.

O segundo comando usa o cmdlet New-Object para criar uma instância de provedor de código de FSharp e salva o resultado na variável $provider.

O terceiro comando salva o código FSharp que define o método Loop na variável $FSharpCode.

O quarto comando usa o cmdlet Add-Type para salvar os tipos públicos definidos no $fSharpCode na variável $fSharpType. 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 o Add-Type para retornar um objeto Runtime que representa os tipos, e um operador de pipeline (|) envia o objeto Runtime ao cmdlet Where-Object que retorna apenas os tipos públicos. O filtro de Where-Object é usado porque o provedor de FSharp gera tipos não públicos para dar suporte ao tipo público resultante.

O quinto comando chama o método Loop como um método estático do tipo armazenado na variável $fSharpType.

Consulte também

Conceitos

Add-Member
New-Object