about_Object_Creation

Artigo
05/09/2024

Descrição breve

Explica como criar objetos no PowerShell.

Descrição longa

Você pode criar objetos no PowerShell e usar os objetos criados em comandos e scripts.

Há várias maneiras de criar objetos, essa lista não é definitiva:

New-Object: cria uma instância de um objeto .NET Framework ou objeto COM.
Import-Csv/ ConvertFrom-CSV: cria objetos personalizados (PSCustomObject) dos itens definidos como valores separados por vírgulas.
ConvertFrom-Json: cria objetos personalizados definidos em JSON (JavaScript Object Notation).
ConvertFrom-StringData: cria objetos personalizados definidos como pares de valores de chave.
Add-Type: permite que você defina uma classe em sua sessão do PowerShell que você pode instanciar com New-Object.
New-Module: o parâmetro AsCustomObject cria um objeto personalizado que você define usando o bloco de script.
Add-Member: adiciona propriedades a objetos existentes. Você pode usar Add-Member para criar um objeto personalizado de um tipo simples, como [System.Int32].
Select-Object: seleciona propriedades em um objeto . Você pode usar Select-Object para criar propriedades personalizadas e calculadas em um objeto já instanciado.

Os seguintes métodos adicionais são abordados neste artigo:

Chamando o construtor de um tipo usando um método estático new()
Por tabelas de hash de typecasting de nomes de propriedade e valores de propriedade

Método static new()

Todos os tipos .NET têm um new() método que permite que você construa instâncias com mais facilidade. Você também pode ver todos os construtores disponíveis para um determinado tipo.

Para ver os construtores de um tipo, especifique o nome do new método após o nome do tipo e pressione <ENTER>.

[System.Uri]::new

OverloadDefinitions
-------------------
uri new(string uriString)
uri new(string uriString, bool dontEscape)
uri new(uri baseUri, string relativeUri, bool dontEscape)
uri new(string uriString, System.UriKind uriKind)
uri new(uri baseUri, string relativeUri)
uri new(uri baseUri, uri relativeUri)

Agora, você pode criar um System.Uri especificando o construtor apropriado.

[System.Uri]::new("https://www.bing.com")

AbsolutePath   : /
AbsoluteUri    : https://www.bing.com/
LocalPath      : /
Authority      : www.bing.com
...

Você pode usar o exemplo a seguir para determinar quais tipos do .NET estão carregados no momento para criar uma instância.

[AppDomain]::CurrentDomain.GetAssemblies() |
  ForEach-Object {
    $_.GetExportedTypes() |
      ForEach-Object { $_.FullName }
  }

Os objetos criados usando o new() método podem não ter as mesmas propriedades que objetos do mesmo tipo criados por cmdlets do PowerShell. Cmdlets, provedores e Sistema de Tipo Estendido do PowerShell podem adicionar propriedades extras à instância.

Por exemplo, o provedor FileSystem no PowerShell adiciona seis valores NoteProperty ao objeto DirectoryInfo retornado por Get-Item.

$PSDirInfo = Get-Item /
$PSDirInfo | Get-Member | Group-Object MemberType | Select-Object Count, Name

Count Name
----- ----
    4 CodeProperty
   13 Property
    6 NoteProperty
    1 ScriptProperty
   18 Method

Quando você cria um objeto DirectoryInfo diretamente, ele não tem esses seis valores NoteProperty .

$NewDirInfo = [System.IO.DirectoryInfo]::new('/')
$NewDirInfo | Get-Member | Group-Object MemberType | Select-Object Count, Name

Count Name
----- ----
    4 CodeProperty
   13 Property
    1 ScriptProperty
   18 Method

Para obter mais informações sobre o Sistema de Tipo Estendido, consulte about_Types.ps1xml.

Esse recurso foi adicionado ao PowerShell 5.0

Create objetos de tabelas de hash

Você pode criar um objeto a partir de uma tabela de hash de propriedades e valores de propriedade.

A sintaxe é mostrada a seguir:

[<class-name>]@{
  <property-name>=<property-value>
  <property-name>=<property-value>
}

Esse método funciona apenas para classes que têm um construtor sem parâmetros. As propriedades do objeto devem ser públicas e configuráveis.

Esse recurso foi adicionado no PowerShell versão 3.0

Create objetos personalizados de tabelas de hash

Objetos personalizados são muito úteis e são fáceis de criar usando o método de tabela de hash. A classe PSCustomObject foi projetada especificamente para essa finalidade.

Objetos personalizados são uma excelente maneira de retornar a saída personalizada de uma função ou script. Isso é mais útil do que retornar a saída formatada que não pode ser reformatada ou canalizada para outros comandos.

Os comandos no Test-Object function definem alguns valores variáveis e, em seguida, usam esses valores para criar um objeto personalizado. Você pode ver esse objeto em uso na seção de exemplo do tópico de ajuda do Update-Help cmdlet.

function Test-Object {
  $ModuleName = "PSScheduledJob"
  $HelpCulture = "en-us"
  $HelpVersion = "3.1.0.0"
  [PSCustomObject]@{
    "ModuleName"=$ModuleName
    "UICulture"=$HelpCulture
    "Version"=$HelpVersion
  }
  $ModuleName = "PSWorkflow"
  $HelpCulture = "en-us"
  $HelpVersion = "3.0.0.0"
  [PSCustomObject]@{
    "ModuleName"=$ModuleName
    "UICulture"=$HelpCulture
    "Version"=$HelpVersion
  }
}
Test-Object

A saída dessa função é uma coleção de objetos personalizados formatados como uma tabela por padrão.

ModuleName        UICulture      Version
---------         ---------      -------
PSScheduledJob    en-us          3.1.0.0
PSWorkflow        en-us          3.0.0.0

Os usuários podem gerenciar as propriedades dos objetos personalizados da mesma forma que fazem com objetos padrão.

(Test-Object).ModuleName

 PSScheduledJob
 PSWorkflow

Create objetos não personalizados de tabelas de hash

Você também pode usar tabelas de hash para criar objetos para classes não personalizadas. Quando você cria um objeto para uma classe não personalizada, o nome de tipo qualificado por namespace é necessário, embora você possa omitir qualquer componente de namespace inicial do sistema .

Por exemplo, o comando a seguir cria um objeto de opção de sessão.

[System.Management.Automation.Remoting.PSSessionOption]@{
  IdleTimeout=43200000
  SkipCnCheck=$True
}

Os requisitos do recurso de tabela de hash, especialmente o requisito do construtor sem parâmetros, eliminam muitas classes existentes. No entanto, a maioria das classes de opção do PowerShell foi projetada para trabalhar com esse recurso, bem como outras classes muito úteis, como a classe ProcessStartInfo .

[System.Diagnostics.ProcessStartInfo]@{
  CreateNoWindow="$true"
  Verb="run as"
}

Arguments               :
ArgumentList            : {}
CreateNoWindow          : True
EnvironmentVariables    : {OneDriveConsumer, PROCESSOR_ARCHITECTURE,
                           CommonProgramFiles(x86), APPDATA...}
Environment             : {[OneDriveConsumer, C:\Users\user1\OneDrive],
                           [PROCESSOR_ARCHITECTURE, AMD64],
                           [CommonProgramFiles(x86),
                           C:\Program Files (x86)\Common Files],
                           [APPDATA, C:\Users\user1\AppData\Roaming]...}
RedirectStandardInput   : False
RedirectStandardOutput  : False
RedirectStandardError   : False
...

Você também pode usar o recurso de tabela de hash ao definir valores de parâmetro. Por exemplo, o valor do parâmetro SessionOption do New-PSSession. cmdlet pode ser uma tabela de hash.

New-PSSession -ComputerName Server01 -SessionOption @{
  IdleTimeout=43200000
  SkipCnCheck=$True
}
Register-ScheduledJob Name Test -FilePath .\Get-Inventory.ps1 -Trigger @{
  Frequency="Daily"
  At="15:00"
}

Objetos genéricos

Você também pode criar objetos genéricos no PowerShell. Genéricos são classes, estruturas, interfaces e métodos que possuem espaços reservados (parâmetros de tipo) para um ou mais dos tipos que eles armazenam ou usam.

O exemplo a seguir cria um objeto Dictionary .

$dict = New-Object 'System.Collections.Generic.Dictionary[String,Int]'
$dict.Add("One", 1)
$dict

Key Value
--- -----
One     1

Para obter mais informações sobre genéricos, consulte Genéricos no .NET.

Compartilhar via