Compartilhar via

about_Object_Creation

Descrição curta

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, esta lista não é definitiva:

  • new-object: cria uma instância de um objeto .NET Framework ou objeto COM.
  • / ConvertFrom-Csv: cria objetos personalizados (PSCustomObject) dos itens definidos como valores separados por caracteres.
  • ConvertFrom-Json: cria objetos personalizados definidos em JSON (JavaScript Object Notation).
  • ConvertFrom-StringData: cria objetos personalizados definidos como pares de valor de chave.
  • de Tipo de Adição: permite definir uma classe em sua sessão do PowerShell que você pode criar uma instância com New-Object.
  • Novo Módulo: o parâmetro AsCustomObject cria um objeto personalizado que você define usando scriptblock.
  • de Membros Adicionais: 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 de new() estático
  • Digitando tabelas de hash de nomes de propriedade e valores de propriedade

Método static new()

Todos os tipos de .NET têm um método new() que permite construir 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 método new 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 de .NET estão carregados no momento para criar uma instância.

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

Objetos criados usando o método new() podem não ter as mesmas propriedades que objetos do mesmo tipo que são 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 Tipos Estendidos, consulte about_Types.ps1xml.

Esse recurso foi adicionado ao PowerShell 5.0

Criar objetos a partir de tabelas de hash

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

A sintaxe é a seguinte:

[<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 ao PowerShell versão 3.0

Criar objetos personalizados a partir 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 definir alguns valores variáveis e, em seguida, usar 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 cmdlet Update-Help.

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

objetos de tipo PSObject mantêm a lista de membros na ordem em que os membros foram adicionados ao objeto. Embora objetos hashable não garantam a ordem dos pares chave-valor, a conversão de um hash literal para [pscustomobject] mantém a ordem.

O hashtable deve ser um literal. Se você encapsular o hashtable em parênteses ou se converter uma variável contendo um hashtable, não haverá garantia de que a ordem seja preservada.

$hash = @{
    Name      = "Server30"
    System    = "Server Core"
    PSVersion = "4.0"
}
$Asset = [pscustomobject]$hash
$Asset

System      Name     PSVersion
------      ----     ---------
Server Core Server30 4.0

Criar objetos não personalizados a partir 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 do tipo qualificado por namespace é necessário, embora você possa omitir qualquer componente inicial namespace do System.

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 do PowerShell são projetadas para funcionar 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. o 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 têm espaços reservados (parâmetros de tipo) para um ou mais dos tipos que 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.

Consulte também

  • Last updated on