Windows PowerShell è un ambiente command-shell che supporta lo scripting orientato agli oggetti basato sul Microsoft .NET Framework. Il suo cuore è il cmdlet PowerShell, un comando leggero che esegue un’azione specifica e, nel processo, restituisce un oggetto .NET. PowerShell consente di utilizzare cmdlets per accedere a una varietà di sistemi ed eseguire numerosi compiti contro questi sistemi. Tuttavia, le cmdlets da sole non sono sempre sufficienti per eseguire determinate azioni. Per queste azioni, è spesso necessario creare i propri oggetti basati sulle classi .NET. Un tipo di oggetto .NET che potete costruire è l’oggetto personalizzato. Un oggetto personalizzato vi permette di definire i tipi di dati assegnati a quell’oggetto e le azioni che può eseguire. Dopo aver capito come costruire un oggetto personalizzato, avrai un potente strumento per costruire script che possono estendere la portata già significativa di PowerShell.
Nota che il .NET Framework e la programmazione orientata agli oggetti sono argomenti complessi, ben oltre lo scopo di questo articolo. Per apprezzare pienamente la natura orientata agli oggetti di PowerShell, può aiutare avere almeno una comprensione di base di questi concetti. Per maggiori informazioni sul .NET Framework, vedi l’articolo MSDN “Panoramica del .NET Framework”. Per un’introduzione alla programmazione orientata agli oggetti, vedi l’articolo MSDN “Programmazione orientata agli oggetti (C# e Visual Basic).”
Creazione di un oggetto personalizzato
Per creare un oggetto personalizzato in PowerShell, devi prima usare il cmdlet New-Object per costruire l’oggetto iniziale. Questo cmdlet ti permette di creare oggetti .NET o COM da un assortimento di classi. Un oggetto personalizzato è un tipo speciale di oggetto .NET basato sulla classe Object o PSObject .NET. Non c’è differenza tra i due quando si crea l’oggetto iniziale. Tuttavia, la classe PSObject è generalmente preferita a causa dei problemi che possono sorgere quando si aggiungono proprietà a un oggetto basato sulla classe Object, quindi usiamo PSObject.
Per creare un oggetto basato sulla classe PSObject, è necessario utilizzare il cmdlet New-Object con il parametro -TypeName e specificare la classe PSObject come valore del parametro, così:
$system = New-Object -TypeName PSObject
Quando si esegue questo comando, verrà generato un oggetto PSCustomObject e assegnato alla variabile $system. Più spesso che no, vorrete assegnare l’oggetto ad una variabile in modo da poter lavorare facilmente con i membri dell’oggetto. I membri sono i componenti che costituiscono un oggetto, come le proprietà, i metodi, le proprietà alias e i set di membri.
Quando si lavora con gli oggetti in PowerShell, i due tipi di membri che probabilmente utilizzerete sono le proprietà e i metodi. Una proprietà descrive un aspetto specifico dell’oggetto. Per esempio, uno dei membri della classe FileInfo .NET è la proprietà Length, che fornisce la dimensione di un file in byte. Se create un oggetto FileInfo basato su quella classe, potete usare la proprietà Length per accedere alla dimensione del file associato a quell’oggetto. Un metodo esegue un’azione relativa all’oggetto. Per esempio, la classe FileInfo include anche il metodo Delete, che potete usare per cancellare il file rappresentato dall’oggetto.
Essere in grado di identificare facilmente i membri di un oggetto rende più facile lavorare con quell’oggetto. Per ottenere un elenco dei membri che compongono un oggetto, potete usare il cmdlet Get-Member. Per esempio, per vedere i membri del nuovo oggetto che è stato assegnato alla variabile $system, potete collegare la variabile $system al cmdlet Get-Member:
$system | Get-Member
Come mostra la figura 1, l’oggetto che avete creato è basato sulla classe System.Management.Automation.PSCustomObject, che include solo un piccolo numero di membri, tutti metodi. Ma questo è il motivo per cui è chiamato un oggetto personalizzato: puoi personalizzarlo aggiungendo i tuoi membri.
Prima di mostrarti come aggiungere membri, lasciami aggiungere che, come molte classi .NET, la classe PSCustomObject include anche una serie di membri nascosti di vari tipi, come memberset e codeproperty. Potete visualizzare questi membri includendo il parametro -Force quando chiamate il cmdlet Get-Member. Sebbene una discussione sui membri nascosti vada oltre lo scopo di questo articolo, potresti trovare utile ad un certo punto esplorare i membri nascosti disponibili per la classe PSCustomObject e altre classi .NET per trarre pieno vantaggio dai tuoi oggetti PowerShell.
Aggiungimento di proprietà ad un oggetto personalizzato
Un oggetto personalizzato è utile solo quanto i membri associati all’oggetto. Puoi aggiungere diversi tipi di membri a un oggetto personalizzato. Per questo esempio, aggiungerai i membri NoteProperty e ScriptMethod. Un membro NoteProperty è simile a una normale proprietà, e un membro ScriptMethod è molto simile a un normale metodo. Non puoi aggiungere una proprietà o un metodo regolare ad un oggetto personalizzato, ecco perché userai NoteProperty e ScriptMethod. (Per informazioni sui membri supportati in un oggetto personalizzato, consultate l’argomento PowerShell TechNet “Add-Member.”)
Iniziamo ad aggiungere un paio di membri NoteProperty all’oggetto $system. Per aggiungere i membri, potete usare il cmdlet Add-Member per definire i nomi e i valori delle proprietà. Per esempio, supponiamo che vogliate aggiungere proprietà note basate su dati recuperati attraverso le funzionalità di Windows Management Instrumentation (WMI) incorporate in PowerShell. (WMI fornisce un’infrastruttura per la gestione dei dati e delle operazioni nei sistemi operativi Windows). Il modello di oggetto WMI include numerose classi che supportano una vasta gamma di operazioni di gestione. Per esempio, la classe Win32_OperatingSystem fornisce l’accesso a informazioni quali il nome del sistema operativo installato su un computer e l’ultimo service pack applicato a tale sistema operativo.
Per creare un oggetto WMI, si utilizza il cmdlet Get-WmiObject e si specifica la classe desiderata. Per esempio, per creare un oggetto WMI Win32_OperatingSystem e assegnarlo alla variabile $os, useresti il codice:
$os = Get-WmiObject Win32_OperatingSystem
In questo caso, stai recuperando informazioni sul sistema dal computer locale, ma la bellezza di WMI è la sua capacità di accedere e gestire anche computer Windows remoti.
Puoi quindi usare la variabile $os per accedere alle informazioni restituite da tale oggetto. Assegnare un oggetto ad una variabile in questo modo blocca i dati in quel momento. Per esempio, se un nuovo service pack viene applicato al sistema operativo dopo aver creato la variabile $os, la proprietà CSDVersion dell’oggetto non rifletterà il cambiamento perché l’oggetto era stato creato sulla base dei dati originali.
Dopo aver definito la variabile $os, è necessario specificare due comandi Add-Member. Ogni comando prenderà quattro parametri:
- -InputObject. Usate il parametro -InputObject per identificare l’oggetto che riceve le nuove proprietà della nota. In questo caso, dovete specificare l’oggetto $system.
- -MemberType. Il parametro -MemberType indica il tipo di membro da creare, quindi è necessario specificare NoteProperty.
- -Name. Usate il parametro -Name per specificare il nome del nuovo membro. Per questo esempio, chiamiamo il primo membro OperatingSystem e il secondo membro ServicePack.
- -Value. Questo parametro specifica il valore del membro. Per la prima proprietà nota, è necessario specificare $os.Caption per restituire il nome del sistema operativo. Per la seconda proprietà della nota, dovete specificare $os.CSDVersion per restituire l’ultimo service pack applicato al sistema operativo.
Ecco come appaiono i due comandi Add-Member:
Add-Member -InputObject $system -MemberType NoteProperty ` -Name OperatingSystem -Value $os.CaptionAdd-Member -InputObject $system -MemberType NoteProperty ` -Name ServicePack -Value $os.CSDVersion
Nota che ho spezzato ogni comando Add-Member in due righe. Alla fine di ogni prima riga, ho incluso un segno di spunta (`) in modo che il processore PowerShell sappia di continuare alla riga successiva per il comando completo.
Dopo aver eseguito i comandi Add-Member, puoi chiamare la variabile $system per visualizzarne il contenuto:
$system
La figura 2 mostra dei risultati di esempio.
Puoi anche usare la variabile $system per chiamare singoli membri. Basta specificare il nome della variabile, seguito da un punto, poi il nome del membro. Per esempio, il seguente comando restituisce il valore corrente della proprietà nota di OperatingSystem:
$system.OperatingSystem
Un vantaggio della creazione di un oggetto personalizzato è che ti permette di creare proprietà nota basate su dati che provengono da fonti diverse così come una proprietà nota il cui valore è una stringa specifica. Per esempio, date un’occhiata al codice nel listato 1, che aggiunge tre nuove proprietà di nota all’oggetto $system.
$mem = Get-WmiObject Win32_PhysicalMemory$disk = Get-WmiObject Win32_DiskDriveAdd-Member -InputObject $system -MemberType NoteProperty ` -Name PhysicalMemory ` -Value (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name DiskSize ` -Value (("{0:N2}" -f ($disk.Size/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name Owner -Value "janetp"
La maggior parte degli elementi nel listato 1 li avete visti nell’esempio precedente. Tuttavia, notate che il codice sta creando un’istanza della classe Win32_PhysicalMemory, che è assegnata alla variabile $mem, e un’istanza della classe Win32_DiskDrive, che è assegnata alla variabile $disk. Due delle proprietà delle note aggiunte usano questi nuovi oggetti WMI come fonti di dati.
Il primo comando Add-Member recupera i dati dalla proprietà $mem.Capacity, che fornisce la capacità della memoria sul sistema di destinazione. In questo caso, però, il parametro -Value è un po’ più complesso di quanto visto nell’esempio precedente. Innanzitutto, il comando specifica “{0:N2}” seguito da -f, che è una costruzione .NET per formattare il numero in uscita. Fondamentalmente, questo specifica che un numero viene restituito con due cifre decimali. Le istruzioni di formattazione sono seguite da una breve espressione ($mem.Capacity/1GB) che divide il valore Capacity per 1GB. Il valore Capacity fornisce la dimensione della memoria in byte. PowerShell rende facile convertire i byte in gigabyte semplicemente dividendo per 1GB. Infine, il comando inserisce la stringa ‘ GB’ (compreso lo spazio) nell’output e racchiude il tutto tra parentesi.
Il secondo comando Add-Member segue la stessa logica per restituire la dimensione del disco rigido del computer. Usa la proprietà $disk.Size per restituire la dimensione in byte, poi la converte in gigabyte.
Il terzo comando Add-Member aggiunge una proprietà nota chiamata Owner e le assegna il valore stringa janetp. In questo caso, “proprietario” può significare qualsiasi cosa: l’utente principale, l’ultimo utente, l’amministratore, o qualsiasi significato vogliate imporre alla proprietà. L’ho inclusa qui solo per dimostrare che potete aggiungere una proprietà nota il cui valore è una semplice stringa.
Dopo aver aggiunto i tre membri all’oggetto personalizzato, potete ancora una volta chiamare la variabile $system. Restituirà risultati come quelli mostrati nella Figura 3.
Ora avete un singolo oggetto che contiene dati derivati da tre diversi oggetti WMI. L’oggetto contiene anche la proprietà Owner, che è basata su un valore stringa. Puoi chiamare quella proprietà nota come faresti con qualsiasi altro membro:
$system.Owner
Come ti aspetteresti, il comando restituisce il valore janetp. Tuttavia, puoi cambiare quel valore con uno diverso assegnando un nuovo valore alla proprietà, come in questo caso:
$system.Owner = "rogert"
In questo caso, il valore rogert è stato assegnato alla proprietà Owner note. Se ora chiami quella proprietà nota, restituirà il nuovo valore.
Come per molti dei compiti che puoi eseguire in PowerShell, ci sono diversi modi per aggiungere un membro a un oggetto personalizzato. Per esempio, PowerShell 3.0 permette di creare una tabella hash e passare l’hash al comando New-Object. Il codice nel listato 2 crea le stesse cinque proprietà delle note ma usa una tabella hash per passare i nomi e i valori dei membri.
$info = @{ "OperatingSystem" = $os.Caption; "ServicePack" = $os.CSDVersion; "PhysicalMemory" = (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB'); "DiskSize" = (("{0:N2}" -f ($disk.Size/1GB)) + ' GB'); "Owner" = 'janetp'}$system = New-Object -TypeName PSObject -Property $info$system
Questo codice crea prima una tabella hash che definisce cinque coppie proprietà/valore, ognuna corrispondente alle proprietà delle note. Come mostra il codice, è necessario separare le coppie proprietà/valore con il punto e virgola. Dovete anche racchiudere l’insieme delle cinque coppie proprietà/valore tra parentesi graffe e far precedere la parentesi aperta dal simbolo at (@). Infine, dovete assegnare la tabella hash alla variabile $info.
Dopo aver definito la tabella hash, il codice usa il cmdlet New-Object per creare un oggetto basato sulla classe PSObject e lo assegna alla variabile $system. Solo che questa volta, il comando include il parametro -Property, che prende la variabile $info come valore.
Finalmente, il codice chiama la variabile $system, che restituisce risultati come quello in Figura 4. Notate l’ordine in cui le proprietà sono state aggiunte all’oggetto. Uno dei problemi nell’usare una tabella hash per aggiungere le proprietà delle note è che non si può controllare il loro ordine. Per controllare l’ordine, devi usare il cmdlet Add-Member per aggiungere ogni membro.
Aggiungimento di metodi ad un oggetto personalizzato
Ora che hai visto come è facile aggiungere proprietà, accedere ai loro valori e cambiarli, passiamo ai metodi. Questi sono un po’ più complicati perché i metodi devono fare qualcosa, ed è necessario definire quel qualcosa come parte del valore del metodo.
Per esempio, il codice nel listato 3 crea un metodo che recupera la data e l’ora correnti e le restituisce sia nel loro formato originale che come valori UTC (Coordinated Universal Time).
$method ={ $a = Get-Date -Format F; "Local: " + $a; $b = Get-Date; "UTC: " + $b.ToUniversalTime().DateTime}Add-Member -InputObject $system -MemberType ScriptMethod ` -Name GetUTC -Value $method
Per mantenere il codice leggibile, è possibile assegnare il valore del metodo ad una variabile (ad esempio, $metodo). Questo valore include le espressioni necessarie per restituire le informazioni su data e ora. Tuttavia, è necessario definire il valore come un blocco di script per passarlo nel comando Add-Member. Per farlo, racchiudi il contenuto del valore tra parentesi graffe. PowerShell assegnerà quindi il valore nella sua forma attuale alla variabile come oggetto ScriptBlock.
Nel listato 3, il valore del metodo include due espressioni. La prima espressione restituisce la data e l’ora correnti, e la seconda espressione restituisce la versione UTC. Iniziate la prima espressione usando il cmdlet Get-Date per recuperare la data e l’ora correnti, che assegnate alla variabile $a. Si noti che quando si chiama il cmdlet Get-Date, è necessario includere il parametro -Format, insieme al valore F. Questo dice a PowerShell di visualizzare il timestamp in un formato completo di data e ora, come in Monday, August 19, 2013 12:28:25 PM. Si aggiunge poi la stringa “Local: “
Nella seconda espressione, si inizia di nuovo con il cmdlet Get-Date per restituire la data e l’ora corrente, che si assegna alla variabile $b. Usate poi il metodo ToUniversalTime della variabile per restituire la data e l’ora come valore UTC, quindi specificate la proprietà DateTime per restituire il formato corretto.
Se doveste chiamare la variabile $method a questo punto, essa restituirebbe le due espressioni come stringhe, proprio come sono state digitate. Poiché avete definito il valore della variabile come un blocco di script, i comandi non vengono elaborati quando vengono assegnati alla variabile $method. Invece, la variabile $metodo è creata come un oggetto ScriptBlock, che potete confermare usando il metodo GetType per vedere il tipo della variabile:
$method.GetType()
Per lavorare con il blocco di script, dovete aggiungere il metodo come membro dell’oggetto $system dopo aver definito la variabile $metodo. Per farlo, si crea un comando Add-Member che specifica ScriptMethod come tipo, GetUTC come nome e la variabile $metodo come valore.
Dopo aver eseguito il codice nel listato 3, potete usare la variabile $system per chiamare il metodo GetUTC nello stesso modo in cui avete chiamato le proprietà:
$system.GetUTC()
Nota, però, che quando chiamate il metodo script, dovete includere le parentesi, proprio come fate per qualsiasi altro metodo, anche se non state passando argomenti. Il metodo dovrebbe ora restituire risultati simili a quelli della Figura 5, ma con la data e l’ora in cui è stato chiamato il metodo.
Nella vita reale, probabilmente vorrete creare metodi che abbiano più forza. Per esempio, l’oggetto $system potrebbe incorporare compiti di gestione WMI nei suoi metodi di script. Se lo fate, avete bisogno di testare completamente il metodo per assicurarvi che i vostri comandi stiano facendo esattamente ciò che dovrebbero fare. PowerShell e WMI sono entrambi strumenti potenti, quindi dovrebbero essere usati con cura quando si gestiscono i computer Windows.
Aggiungimento di oggetti personalizzati a un array
Gli oggetti personalizzati non sono limitati agli oggetti indipendenti che si usano una volta e si gettano via. Si possono aggiungere questi oggetti ad un array di oggetti, e poi accedere agli oggetti attraverso quell’array. Per esempio, supponiamo che vogliate manipolare le informazioni che recuperate da più computer. Queste informazioni potrebbero includere dettagli sulla memoria e sulle unità logiche disponibili su quei sistemi. Vuoi essere in grado di lavorare con questi dettagli in modo significativo in PowerShell. A causa della natura orientata agli oggetti di PowerShell, mettere queste informazioni in oggetti è spesso il modo più semplice per lavorare con quei dati.
Guardiamo un esempio di come potresti farlo. Per questa discussione, l’approccio usato per raccogliere le informazioni sui vari computer non è importante. Potreste, per esempio, impostare un ciclo foreach in PowerShell che usa WMI per recuperare le informazioni dalle diverse stazioni di lavoro. Indipendentemente dal metodo usato, per brevità, supponiamo che tu abbia raccolto le informazioni in un file di testo separato da virgole che contiene i dati mostrati nella Figura 6.
Il file di testo include una riga di intestazione e una riga per ogni unità logica del sistema. Per esempio, la prima riga di dati fornisce dettagli sull’unità logica C sul computer ws01. L’unità logica ha una capacità di 500GB, con 225GB di spazio libero. Il sistema ha anche 4GB di memoria. La seconda riga indica che lo stesso computer contiene anche l’unità logica D, che ha la stessa capacità dell’unità C ma con 320GB di spazio libero.
L’obiettivo è di trasformare ogni riga di dati nel proprio oggetto personalizzato, quindi aggiungere questi oggetti a un array. Puoi poi agire sugli oggetti all’interno dell’array inviando i dati ad altri comandi PowerShell. Il codice nel listato 4 definisce un array vuoto, importa i dati dal file di testo, poi usa un ciclo foreach per creare gli oggetti e aggiungerli all’array.
$SystemInfo = @()$SourceData = Import-CSV C:\DataFiles\SourceData.txtforeach ($source in $SourceData){ $system = New-Object -TypeName PSObject $system | Add-Member -Type NoteProperty ` -Name Computer -Value $source.Computer $system | Add-Member -Type NoteProperty ` -Name DeviceID -Value $source.DeviceID $system | Add-Member -Type NoteProperty ` -Name DriveSize -Value ($source.DriveSize) $system | Add-Member -Type NoteProperty ` -Name UsedSpace ` -Value ($source.DriveSize - $Source.FreeSpace) $system | Add-Member -Type NoteProperty ` -Name FreeSpace -Value ($source.FreeSpace) $SystemInfo += $system}
Come potete vedere, il primo passo è creare l’array vuoto (@()) e assegnarlo alla variabile $SystemInfo. Alla fine, aggiungerai gli oggetti personalizzati a questo array.
In seguito, userai il cmdlet Import-CSV per importare i dati nella variabile $SourceData. Per questo esercizio, il file di testo è chiamato SourceData.txt e salvato nella cartella C:\DataFiles. Il cmdlet Import-CSV recupera ogni riga come un proprio oggetto, salvandolo in $SourceData. A questo punto, potresti usare quella variabile per accedere ai dati, ma non avresti alcun controllo sui membri inclusi nell’oggetto, né saresti in grado di aggiungere membri.
Il prossimo passo, quindi, è quello di creare un ciclo foreach che ti permette di creare un oggetto personalizzato per ogni riga del file di testo. La condizione foreach ($source in $SourceData) specifica che ogni riga in $SourceData dovrebbe essere assegnata alla variabile $source mentre il codice itera attraverso il ciclo foreach. La logica definita all’interno del blocco di script foreach (racchiuso tra parentesi graffe) verrà quindi eseguita una volta per ogni riga, con un diverso oggetto $source applicato durante ogni iterazione. (Per maggiori informazioni sulla creazione di un ciclo foreach, vedi l’argomento di PowerShell TechNet about_ForEach.)
Diamo un’occhiata più da vicino al blocco di script foreach. Il primo comando crea l’oggetto iniziale e lo salva nella variabile $system, come avete visto negli esempi precedenti. Successivamente, la variabile $system è collegata ad un comando Add-Member per creare la prima proprietà della nota. Questo è un formato leggermente diverso da quello usato prima. Invece di includere il parametro -InputObject nel comando Add-Member, si manda semplicemente $system al comando. Questo ottiene gli stessi risultati che avete visto negli esempi precedenti di comandi Add-Member. Ho preso questo approccio qui semplicemente per dimostrare un altro modo in cui PowerShell ti permette di aggiungere membri.
Per il valore del comando Add-Member, usi la variabile $source per chiamare la proprietà Computer, che corrisponde al campo Computer nei dati sorgente. Il secondo comando Add-Member funziona allo stesso modo, eccetto che recupera i dati dalla proprietà DeviceID. Notate che la proprietà Memory non è inclusa. Quando stai creando un oggetto personalizzato, puoi omettere proprietà specifiche o metterle in un ordine diverso.
Il terzo comando Add-Member funziona allo stesso modo dei primi due, tranne che accede alla proprietà DriveSize. Poiché potreste voler lavorare con questi dati come un valore numerico piuttosto che come una stringa, il comando converte esplicitamente i dati in un numero. Questo si ottiene precedendo il nome della proprietà con per indicare che si vuole il tipo di datiint, poi racchiudendo l’intera espressione della proprietà tra parentesi.
Il quarto comando Add-Member fa qualcosa di un po’ diverso. Crea un membro calcolato che sottrae il valore FreeSpace dal valore DriveSize per determinare la quantità di spazio usato. Di nuovo, il nome della proprietà è preceduto da e l’intera espressione è racchiusa tra parentesi. Essere in grado di creare una proprietà calcolata è una delle ragioni principali per cui potreste voler creare oggetti personalizzati.
L’ultimo comando Add-Member funziona proprio come il terzo, eccetto che recupera i dati dalla proprietà FreeSpace.
L’ultimo comando nel blocco di script foreach aggiunge l’oggetto $system corrente all’array $SystemInfo. Notate che l’operatore += è usato per assicurare che il nuovo oggetto $system venga aggiunto ad ogni iterazione del ciclo, senza che nulla venga sovrascritto.
Dopo aver eseguito il codice nel listato 4, potete chiamare la variabile per vederne il contenuto. La Figura 7 mostra una lista parziale dei dati ora memorizzati nell’array $SystemInfo.
In particolare, mostra i dati per i primi sette oggetti nell’array, che corrisponde alle prime sette righe di dati nel file di testo originale. Ogni raggruppamento rappresenta uno degli oggetti aggiunti all’array $SystemInfo. Potete verificare che avete creato un array di oggetti usando il metodo GetType per recuperare il tipo della variabile:
$SystemInfo.GetType()
Se questo comando restituisce un BaseType di System.Array, la variabile $SystemInfo è effettivamente un array di oggetti capace di contenere oggetti personalizzati. Potete quindi usare questa variabile per manipolare i dati come meglio credete. Per esempio, potete passare la variabile a un comando Sort-Object per ordinare i dati in ordine decrescente, in base ai valori FreeSpace:
$SystemInfo | Sort FreeSpace -Descending
In questo caso, il comando usa l’alias Sort per fare riferimento al cmdlet Sort-Object e include la proprietà FreeSpace e il parametro -Descending. Come potete vedere nella figura 8, gli oggetti sono ora elencati secondo i valori di FreeSpace, con la quantità più alta di spazio libero elencata per prima. Ancora una volta, questa è solo una lista parziale.
Puoi anche ordinare i dati in base a più colonne. Per esempio, potresti ordinare i dati prima per la proprietà Computer, poi per la proprietà FreeSpace, in ordine decrescente:
$SystemInfo | Sort Computer, FreeSpace -Descending
Come ti aspetteresti, i risultati ora sono molto diversi, come mostra la Figura 9.
Una delle conseguenze dell’ordinamento delle colonne in questo modo è che i valori del computer e dello spazio libero sono ordinati in ordine decrescente. Il cmdlet Sort-Object non vi permette di ordinare facilmente una colonna in ordine crescente e un’altra in ordine decrescente. Se si specifica il parametro -Descending, tutti i dati vengono ordinati in quell’ordine. Tuttavia, potete aggirare questa limitazione creando espressioni per ogni proprietà che specificano come ordinare quei valori. Per esempio, il seguente comando ordina prima per la proprietà Computer in ordine crescente, poi per la proprietà FreeSpace in ordine decrescente:
$SystemInfo | Sort ` @{Expression="Computer"; Descending=$false}, @{Expression="FreeSpace"; Descending=$true}
La prima espressione Sort-Object imposta la proprietà Expression su Computer e la proprietà Descending su $false. La seconda espressione imposta la proprietà Expression su FreeSpace e la proprietà Descending su $true (le variabili $true e $false sono variabili di sistema integrate che forniscono i valori booleani vero e falso di 1 e 0, rispettivamente). Dovete poi racchiudere ogni espressione tra parentesi graffe e far precedere ogni parentesi aperta dal simbolo at (@). Ora i dati saranno ordinati nell’ordine desiderato, come mostrato nella Figura 10.
Questo potrebbe sembrare eccessivo sull’argomento dell’ordinamento, ma indica la flessibilità di lavorare con oggetti in un array. E non siete certamente limitati al cmdlet Sort-Object. Per esempio, il seguente comando invia la variabile $SystemInfo alla cmdlet Where-Object:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending
In questo caso, il comando usa l’alias Where per fare riferimento alla cmdlet Where-Object. Inoltre, specifica che il valore DriveSize deve essere maggiore di 250 per essere incluso nei risultati. (In PowerShell, -gt è usato per l’operatore greater than.) I risultati che soddisfano questi criteri sono indirizzati al cmdlet Sort-Object in modo che i dati siano visualizzati nel giusto ordine.
Puoi anche indirizzare i dati ordinati a un comando Select-Object, come questo:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending | Select -First 5
Questo comando usa il cmdlet Select-Object (referenziato dall’alias Select) per restituire solo le prime cinque righe del set di risultati. Come puoi vedere, una volta che aggiungi oggetti personalizzati all’array $SystemInfo, hai una varietà di opzioni per lavorare con questi oggetti.
Per ottenere il massimo dai tuoi oggetti personalizzati
Per la maggior parte, creare oggetti personalizzati in PowerShell è un processo abbastanza semplice. Se c’è qualche complessità coinvolta, generalmente deriva dalle espressioni di valore che definisci per le tue proprietà o metodi di script. Le espressioni in questi esempi sono relativamente semplici rispetto ai tipi di espressioni che puoi creare in PowerShell. Anche così, quello che hai visto qui dovrebbe fornirti le basi di cui hai bisogno per creare oggetti personalizzati. Quando sono usati in modo efficace, possono essere una componente potente dei tuoi script PowerShell, sia che tu crei oggetti individuali, che li aggiungi a un array, o che li usi in qualche altro modo. Potresti, per esempio, creare oggetti personalizzati all’interno del tuo profilo PowerShell in modo che siano disponibili ogni volta che inizi una nuova sessione. Come usi gli oggetti personalizzati nei tuoi script dipende da te. Sappi solo che l’oggetto personalizzato è uno strumento efficace e flessibile che può servire a molte delle tue esigenze di scripting.
Per ulteriori informazioni sulla creazione di oggetti personalizzati in Windows PowerShell, vedi “Creating Custom Objects in Windows PowerShell” di Bill Stewart.