Add-Type

Sintaxe

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

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

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

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

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

Description

O Add-Type cmdlet permite definir uma classe do Microsoft .NET Core 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 Core. 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 Core.

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.

A partir do PowerShell 7, Add-Type não compilará um tipo se um tipo com o mesmo nome já existir. Além disso, Add-Type procura assemblies em uma ref pasta na pasta que contém pwsh.dll.

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 JsonSchema.NET.dll assembly à sessão atual.

Set-Location -Path $PSHOME
$AccType = Add-Type -AssemblyName *jsonschema* -PassThru

Set-Location usa o parâmetro Path para especificar a $PSHOME variável. A variável faz referência ao diretório de instalação do PowerShell em que o arquivo DLL está localizado.

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.

Parâmetros

-AssemblyName

-CompilerOptions

-IgnoreWarnings

-Language

-LiteralPath

-MemberDefinition

-Name

-Namespace

-OutputAssembly

-OutputType

-PassThru

-Path

-ReferencedAssemblies

-TypeDefinition

-UsingNamespace

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.

Type

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

No Windows PowerShell (versão 5.1 e inferior), você precisa usar Add-Type para qualquer coisa que ainda não esteja carregada. Mais comumente, isso se aplica a assemblies encontrados no GAC (Cache de Assembly Global). No PowerShell 6 e superior, não há GAC, portanto, o PowerShell instala seus próprios assemblies no $PSHOME. Esses assemblies são carregados automaticamente mediante solicitação, portanto, não há necessidade de carregá-los Add-Type . No entanto, o uso Add-Type ainda é permitido para permitir que os scripts sejam implicitamente compatíveis com qualquer versão do PowerShell.

Os assemblies no GAC podem ser carregados por nome de tipo, em vez de por caminho. Carregar assemblies de um caminho arbitrário requer Add-Type, já que esses assemblies não podem ser carregados automaticamente.

Links Relacionados

• about_Profiles
• about_Quoting_Rules
• Add-Member
• New-Object
• OutputAssemblyType
• Invocação de plataforma (P/Invoke)
• Where-Object