Add-Type

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

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.

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.

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.

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.

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.)

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.

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.