about_Object_Creation

Articolo
07/07/2023

Descrizione breve

Viene illustrato come creare oggetti in PowerShell.

Descrizione lunga

È possibile creare oggetti in PowerShell e usare gli oggetti creati in comandi e script.

Esistono molti modi per creare oggetti, questo elenco non è definitivo:

New-Object: crea un'istanza di un oggetto .NET Framework o di un oggetto COM.
Import-Csv ConvertFrom-CSV /: crea oggetti personalizzati (PSCustomObject) dagli elementi definiti come valori separati da caratteri.
ConvertFrom-Json: crea oggetti personalizzati definiti in JSON (JavaScript Object Notation).
ConvertFrom-StringData: crea oggetti personalizzati definiti come coppie chiave-valore.
Add-Type: consente di definire una classe nella sessione di PowerShell di cui è possibile creare un'istanza con New-Object.
New-Module: il parametro AsCustomObject crea un oggetto personalizzato definito usando il blocco di script.
Add-Member: aggiunge proprietà agli oggetti esistenti. È possibile usare Add-Member per creare un oggetto personalizzato da un tipo semplice, ad esempio [System.Int32].
Select-Object: seleziona le proprietà di un oggetto. È possibile usare Select-Object per creare proprietà personalizzate e calcolate su un oggetto già creato.

In questo articolo sono illustrati i metodi aggiuntivi seguenti:

Chiamando il costruttore di un tipo usando un metodo statico new()
Tramite il typecasting di tabelle hash di nomi di proprietà e valori di proprietà

Metodo static new()

Tutti i tipi .NET hanno un new() metodo che consente di costruire più facilmente istanze. È anche possibile visualizzare tutti i costruttori disponibili per un determinato tipo.

Per visualizzare i costruttori per un tipo, specificare il nome del new metodo dopo il nome del tipo e premere <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)

È ora possibile creare un System.Uri specificando il costruttore appropriato.

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

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

È possibile usare l'esempio seguente per determinare i tipi .NET attualmente caricati per creare un'istanza.

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

Gli oggetti creati con il new() metodo potrebbero non avere le stesse proprietà degli oggetti dello stesso tipo creati dai cmdlet di PowerShell. I cmdlet, i provider e il sistema di tipi estesi di PowerShell possono aggiungere proprietà aggiuntive all'istanza.

Ad esempio, il provider FileSystem in PowerShell aggiunge sei valori NoteProperty all'oggetto DirectoryInfo restituito da 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 si crea direttamente un oggetto DirectoryInfo , questi sei valori NoteProperty non sono disponibili.

$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

Per altre informazioni sul sistema di tipi estesi, vedere about_Types.ps1xml.

Questa funzionalità è stata aggiunta in PowerShell 5.0

Creare oggetti da tabelle hash

È possibile creare un oggetto da una tabella hash di proprietà e valori di proprietà.

La sintassi è la seguente:

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

Questo metodo funziona solo per le classi con un costruttore senza parametri. Le proprietà dell'oggetto devono essere pubbliche e impostabili.

Questa funzionalità è stata aggiunta in PowerShell versione 3.0

Creare oggetti personalizzati da tabelle hash

Gli oggetti personalizzati sono molto utili e sono facili da creare usando il metodo della tabella hash. La classe PSCustomObject è progettata in modo specifico per questo scopo.

Gli oggetti personalizzati sono un ottimo modo per restituire l'output personalizzato da una funzione o uno script. Questa operazione è più utile rispetto alla restituzione di un output formattato che non può essere riformattato o inviato tramite pipe ad altri comandi.

I comandi nell'insieme Test-Object function impostano alcuni valori di variabile e quindi usano tali valori per creare un oggetto personalizzato. È possibile visualizzare questo oggetto in uso nella sezione di esempio dell'argomento della Guida dei 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

L'output di questa funzione è una raccolta di oggetti personalizzati formattati come tabella per impostazione predefinita.

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

Gli utenti possono gestire le proprietà degli oggetti personalizzati esattamente come fanno con gli oggetti standard.

(Test-Object).ModuleName

 PSScheduledJob
 PSWorkflow

Gli oggetti tipo PSObject mantengono l'elenco dei membri nell'ordine in cui i membri sono stati aggiunti all'oggetto. Anche se gli oggetti Hashtable non garantiscono l'ordine delle coppie chiave-valore, eseguire il cast di una tabella hash letterale per [pscustomobject] mantenere l'ordine.

La tabella hash deve essere un valore letterale. Se si esegue il wrapping della tabella hash tra parentesi o se si esegue il cast di una variabile contenente una tabella hash, non è garantito che l'ordine venga mantenuto.

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

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

Creare oggetti non personalizzati da tabelle hash

È anche possibile usare tabelle hash per creare oggetti per classi non personalizzate. Quando si crea un oggetto per una classe non personalizzata, è necessario il nome del tipo qualificato dallo spazio dei nomi, anche se è possibile omettere qualsiasi componente dello spazio dei nomi system iniziale.

Ad esempio, il comando seguente crea un oggetto opzione di sessione.

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

I requisiti della funzionalità tabella hash, in particolare il requisito del costruttore senza parametri, eliminano molte classi esistenti. Tuttavia, la maggior parte delle classi di opzioni di PowerShell è progettata per funzionare con questa funzionalità, nonché altre classi molto utili, ad esempio la 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
...

È anche possibile usare la funzionalità tabella hash quando si impostano i valori dei parametri. Ad esempio, il valore del parametro SessionOption dell'oggetto New-PSSession. il cmdlet può essere una tabella hash.

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

Oggetti generici

È anche possibile creare oggetti generici in PowerShell. I generics sono classi, strutture, interfacce e metodi dotati di segnaposto (parametri di tipo) per uno o più dei tipi archiviati o usati.

Nell'esempio seguente viene creato un oggetto Dictionary .

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

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

Per altre informazioni sui generics, vedere Generics in .NET.

Condividi tramite