Add-Type

Add-Type
    [-TypeDefinition] <String>
    [-CodeDomProvider <CodeDomProvider>]
    [-CompilerParameters <CompilerParameters>]
    [-Language <Language>]
    [-ReferencedAssemblies <String[]>]
    [-OutputAssembly <String>]
    [-OutputType <OutputAssemblyType>]
    [-PassThru]
    [-IgnoreWarnings]
    [<CommonParameters>]

Add-Type
    [-Name] <String>
    [-MemberDefinition] <String[]>
    [-CodeDomProvider <CodeDomProvider>]
    [-CompilerParameters <CompilerParameters>]
    [-Namespace <String>]
    [-UsingNamespace <String[]>]
    [-Language <Language>]
    [-ReferencedAssemblies <String[]>]
    [-OutputAssembly <String>]
    [-OutputType <OutputAssemblyType>]
    [-PassThru]
    [-IgnoreWarnings]
    [<CommonParameters>]

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

Add-Type
    -LiteralPath <String[]>
    [-CompilerParameters <CompilerParameters>]
    [-ReferencedAssemblies <String[]>]
    [-OutputAssembly <String>]
    [-OutputType <OutputAssemblyType>]
    [-PassThru]
    [-IgnoreWarnings]
    [<CommonParameters>]

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

O cmdlet Add-Type permite definir uma classe do Microsoft .NET Framework em sua sessão do PowerShell. Em seguida, você pode instanciar objetos usando o cmdlet New-Object e usar os objetos da mesma forma que usaria qualquer objeto do .NET Framework. Se você adicionar um comando Add-Type 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 ou arquivos de código-fonte existentes ou pode especificar o código-fonte embutido ou salvo em uma variável. Você pode até mesmo especificar apenas um método e Add-Type define e gera 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 compila o código-fonte especificado e gera um assembly na memória que contém os novos tipos do .NET Framework.

Você pode usar os parâmetros de Add-Type para especificar uma linguagem e um compilador alternativos, C# é o padrão, opções do compilador, dependências de assembly, o namespace de classe, os nomes do tipo e o assembly resultante.

Este exemplo adiciona a classe BasicTest à sessão especificando o código-fonte armazenado em uma variável. A classe BasicTest é usada para adicionar inteiros, criar um objeto e multiplicar 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 variável $Source 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 cmdlet Add-Type adiciona a classe à sessão. Como ele está usando o código-fonte embutido, o comando usa o parâmetro TypeDefinition para especificar o código na variável $Source.

O método estático Add da classe BasicTest usa os caracteres de dois-pontos (::) para especificar um membro estático da classe. Os inteiros são adicionados e a soma é exibida.

O cmdlet cria uma instância da classe BasicTest . Ele salva o novo objeto na variável $BasicTestObject.

$BasicTestObject usa o método Multiply. Os inteiros são multiplicados e o produto é exibido.

Este exemplo usa o cmdlet Get-Member para examinar os objetos que os cmdlets Add-Type 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 cmdlet Get-Member obtém o tipo e os membros da classe BasicTest que Add-Type adicionados à sessão. O comando revela que é um objeto System.RuntimeType , derivado da classe System.Object.

O parâmetro estático obtém as propriedades estáticas e os métodos da classe BasicTest. A saída mostra que o método Add está incluído.

O cmdlet Get-Member obtém os membros do objeto armazenado na variável $BasicTestObject. $BasicTestObject foi criado usando o cmdlet New-Object com a classe BasicTest. A saída revela que o valor da variável $BasicTestObject é uma instância da classe BasicTest e que inclui um membro chamado Multiply.

Este exemplo adiciona as classes do assembly Accessibility.dll à sessão atual.

$AccType = Add-Type -AssemblyName "accessib*" -PassThru

A variável $AccType armazena um objeto criado com o cmdlet Add-Type. Add-Type usa o parâmetro AssemblyName para especificar o nome do assembly. O caractere curinga asterisco (*) permite que você obtenha o assembly correto mesmo quando não tiver certeza do nome ou de sua ortografia. O parâmetro PassThru gera objetos que representam as classes adicionadas à sessão.

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 em User32.dll do PowerShell. Este exemplo só funciona 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 variável $Signature armazena a assinatura C# da função ShowWindowAsync. Para garantir que o método resultante esteja visível em uma sessão do PowerShell, a palavra-chave public foi adicionada à assinatura padrão. Para obter mais informações, consulte função ShowWindowAsync.

A variável armazena o objeto criado pelo parâmetro PassThru. O cmdlet Add-Type adiciona a função ShowWindowAsync à 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 variável $Signature. 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 método estático ShowWindowAsync é usado nos comandos para minimizar e restaurar o console do PowerShell. O método usa dois parâmetros: o identificador de janela e um inteiro que especifica como a janela é exibida.

Para minimizar o console do PowerShell, ShowWindowAsync usa o cmdlet Get-Process com a variável $PID automática para obter o processo que hospeda a sessão atual do PowerShell. Em seguida, ele usa a propriedade MainWindowHandle do processo atual e um valor de 2, que representa o valor SW_MINIMIZE.

Para restaurar a janela, ShowWindowAsync usa um valor de 4 para a posição da janela, que representa o valor SW_RESTORE.

Para maximizar a janela, use o valor de 3 que representa SW_MAXIMIZE.

Este exemplo usa o cmdlet para adicionar a classe VBFromFile definida no arquivo à sessão atual. O texto do arquivo Hello.vb é 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.vbe adiciona o tipo definido no arquivo. A função é chamada como um método estático da classe VBFromFile.

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

Este exemplo mostra como usar o cmdlet Add-Type para adicionar um compilador de código F# à sessão do PowerShell. Para executar este exemplo no PowerShell, você deve ter o FSharp.Compiler.CodeDom.dll 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 resultado na variável $Provider. A variável salva o código F# que define o método Loop .

A variável $FSharpType armazena os resultados do cmdlet Add-Type que salva os tipos públicos definidos em $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 para retornar um objeto Runtime que representa os tipos. Os objetos são enviados pelo pipeline para o cmdlet Where-Object, que retorna apenas os tipos públicos. O cmdlet Where-Object é 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 variável $FSharpType.

Este cmdlet suporta os parâmetros comuns: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction e -WarningVariable. Para obter mais informações, consulte about_CommonParameters.

Não é possível transferir objetos para esse cmdlet.

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.

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.

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 alguns idiomas, 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 baseia-se noda classe CodeDomProvider do Microsoft .NET Framework.