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 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 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 Platform Invoke (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 alternativa e um compilador, C# é o padrão, opções do compilador, dependências de assembly, o namespace de Add-Type classe, os nomes do tipo e o assembly resultante.

A partir do PowerShell 7, Add-Type não compila um tipo se já existir um tipo com o mesmo nome. Além disso, Add-Type procura assemblies em uma ref pasta sob a 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 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 $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 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 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 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 foi adicionada à 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 onde 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 você não tem certeza do nome ou de sua 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 Platform Invoke (P/Invoke) para chamar uma função do User32.dll 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 $Signature variável armazena a assinatura C# da ShowWindowAsync função. Para garantir que o método resultante seja 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 de janela e um inteiro que especifica como a janela é exibida.

Para minimizar o console do PowerShell, ShowWindowAsync usa 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 que 3 representa SW_MAXIMIZE.

Parâmetros

-AssemblyName

-CompilerOptions

-IgnoreWarnings

-Language

-LiteralPath

-MemberDefinition

-Name

-Namespace

-OutputAssembly

-OutputType

-PassThru

-Path

-ReferencedAssemblies

-TypeDefinition

-UsingNamespace

Entradas

None

Não é possível canalizar objetos para este 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.

Notas

Os tipos que você adiciona existem somente 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 dentro de uma sessão. Não é possível descarregar um tipo ou alterá-lo. Se precisar alterar o código de um tipo, altere o nome ou inicie 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 (Global Assembly Cache). 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 usá-los Add-Type para carregá-los. 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 pelo nome do tipo, em vez de pelo caminho. O carregamento de assemblies a partir de um caminho arbitrário requer Add-Type, uma vez que esses assemblies não podem ser carregados automaticamente.

Ligações Relacionadas

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