Informazioni sulle pipeline

Articolo
05/09/2024

Breve descrizione

Combinazione di comandi in pipeline in PowerShell

Descrizione lunga

Una pipeline è una serie di comandi connessi dagli operatori della pipeline () (|ASCII 124). Ogni operatore della pipeline invia i risultati del comando precedente al comando successivo.

L'output del primo comando può essere inviato per l'elaborazione come input al secondo comando. E tale output può essere inviato a un altro comando. Il risultato è una catena di comandi o una pipeline complessa composta da una serie di comandi semplici.

Ad esempio,

Command-1 | Command-2 | Command-3

In questo esempio gli oggetti che Command-1 generano vengono inviati a Command-2. Command-2 elabora gli oggetti e li invia a Command-3. Command-3 elabora gli oggetti e li invia alla pipeline. Poiché nella pipeline non sono presenti più comandi, i risultati vengono visualizzati nella console.

In una pipeline i comandi vengono elaborati in ordine da sinistra a destra. L'elaborazione viene gestita come singola operazione e l'output viene visualizzato come generato.

Ecco un semplice esempio. Il comando seguente ottiene il processo blocco note e quindi lo arresta.

Ad esempio,

Get-Process notepad | Stop-Process

Il primo comando usa il cmdlet per ottenere un oggetto che rappresenta il Get-Process processo blocco note. Usa un operatore della pipeline (|) per inviare l'oggetto processo al Stop-Process cmdlet, che arresta il processo blocco note. Si noti che il Stop-Process comando non ha un parametro Name o ID per specificare il processo, perché il processo specificato viene inviato tramite la pipeline.

Questo esempio di pipeline ottiene i file di testo nella directory corrente, seleziona solo i file che sono più di 10.000 byte di lunghezza, li ordina per lunghezza e visualizza il nome e la lunghezza di ogni file in una tabella.

Get-ChildItem -Path *.txt |
  Where-Object {$_.length -gt 10000} |
    Sort-Object -Property length |
      Format-Table -Property name, length

Questa pipeline è costituita da quattro comandi nell'ordine specificato. La figura seguente mostra l'output da ogni comando mentre viene passato al comando successivo nella pipeline.

Get-ChildItem -Path *.txt
| (FileInfo objects for *.txt)
V
Where-Object {$_.length -gt 10000}
| (FileInfo objects for *.txt)
| (      Length > 10000      )
V
Sort-Object -Property Length
| (FileInfo objects for *.txt)
| (      Length > 10000      )
| (     Sorted by length     )
V
Format-Table -Property name, length
| (FileInfo objects for *.txt)
| (      Length > 10000      )
| (     Sorted by length     )
| (   Formatted in a table   )
V

Name                       Length
----                       ------
tmp1.txt                    82920
tmp2.txt                   114000
tmp3.txt                   114000

Uso delle pipeline

La maggior parte dei cmdlet di PowerShell è progettata per supportare le pipeline. Nella maggior parte dei casi, è possibile inviare i risultati di un cmdlet Get a un altro cmdlet dello stesso sostantivo. Ad esempio, è possibile inviare l'output Get-Service del cmdlet ai Start-Service cmdlet o Stop-Service .

Questa pipeline di esempio avvia il servizio WMI nel computer:

Get-Service wmi | Start-Service

Per un altro esempio, è possibile inviare l'output di Get-Item o Get-ChildItem all'interno del provider del New-ItemProperty Registro di sistema di PowerShell al cmdlet. In questo esempio viene aggiunta una nuova voce del Registro di sistema , NoOfEmployees, con un valore pari a 8124, alla chiave del Registro di sistema MyCompany .

Get-Item -Path HKLM:\Software\MyCompany |
  New-ItemProperty -Name NoOfEmployees -Value 8124

Molti dei cmdlet di utilità, ad esempio Get-Member, , Where-ObjectSort-Object, Group-Objecte Measure-Object vengono usati quasi esclusivamente nelle pipeline. È possibile eseguire la pipe di qualsiasi tipo di oggetto a questi cmdlet. In questo esempio viene illustrato come ordinare tutti i processi nel computer in base al numero di handle aperti in ogni processo.

Get-Process | Sort-Object -Property handles

È possibile eseguire la pipe degli oggetti alla formattazione, all'esportazione e ai cmdlet di output, ad esempio Format-List, Export-CSVFormat-TableExport-ClixmlOut-File, e .

In questo esempio viene illustrato come usare il Format-List cmdlet per visualizzare un elenco di proprietà per un oggetto process.

Get-Process winlogon | Format-List -Property *

Con un po' di pratica, si noterà che la combinazione di comandi semplici nelle pipeline consente di risparmiare tempo e digitazione e rende più efficiente lo scripting.

Funzionamento delle pipeline

Questa sezione illustra come gli oggetti di input sono associati ai parametri dei cmdlet e elaborati durante l'esecuzione della pipeline.

Accetta input della pipeline

Per supportare la pipelining, il cmdlet di ricezione deve avere un parametro che accetta l'input della pipeline. Usare il comando con le opzioni Full o Parameter per determinare quali parametri di un cmdlet accettano l'input Get-Help della pipeline.

Ad esempio, per determinare quali parametri del cmdlet accettano l'input Start-Service della pipeline, digitare:

Get-Help Start-Service -Full

oppure

Get-Help Start-Service -Parameter *

La Guida per il cmdlet mostra che solo i parametri InputObject e Name accettano l'input Start-Service della pipeline.

-InputObject <ServiceController[]>
Specifies ServiceController objects representing the services to be started.
Enter a variable that contains the objects, or type a command or expression
that gets the objects.

Required?                    true
Position?                    0
Default value                None
Accept pipeline input?       True (ByValue)
Accept wildcard characters?  false

-Name <String[]>
Specifies the service names for the service to be started.

The parameter name is optional. You can use Name or its alias, ServiceName,
or you can omit the parameter name.

Required?                    true
Position?                    0
Default value                None
Accept pipeline input?       True (ByPropertyName, ByValue)
Accept wildcard characters?  false

Quando si inviano oggetti tramite la pipeline a Start-Service, PowerShell tenta di associare gli oggetti ai parametri InputObject e Name .

Metodi di accettazione dell'input della pipeline

I parametri dei cmdlet possono accettare l'input della pipeline in uno dei due modi diversi:

ByValue: il parametro accetta valori corrispondenti al tipo .NET previsto o che può essere convertito in tale tipo.

Ad esempio, il parametro Name di Start-Service accetta l'input della pipeline in base al valore. Può accettare oggetti stringa o oggetti che possono essere convertiti in stringhe.
ByPropertyName: il parametro accetta l'input solo quando l'oggetto di input ha una proprietà dello stesso nome del parametro.

Ad esempio, il parametro Name di Start-Service può accettare oggetti con una proprietà Name . Per elencare le proprietà di un oggetto, inoltrarlo a Get-Member.

Alcuni parametri possono accettare oggetti in base al valore o al nome della proprietà, semplificando l'input dalla pipeline.

Associazione di parametri

Quando si esegue la pipe degli oggetti da un comando a un altro comando, PowerShell tenta di associare gli oggetti con pipe a un parametro del cmdlet di ricezione.

Il componente di associazione dei parametri di PowerShell associa gli oggetti di input ai parametri del cmdlet in base ai criteri seguenti:

Il parametro deve accettare l'input da una pipeline.
Il parametro deve accettare il tipo di oggetto inviato o un tipo che può essere convertito nel tipo previsto.
Il parametro non è stato usato nel comando.

Ad esempio, il cmdlet include molti parametri, ma solo due di essi, Nome e InputObject accettano l'input Start-Service della pipeline. Il parametro Name accetta stringhe e il parametro InputObject accetta oggetti di servizio. È pertanto possibile eseguire la pipe di stringhe, gli oggetti del servizio e gli oggetti con proprietà che possono essere convertite in oggetti stringa o di servizio.

PowerShell gestisce l'associazione dei parametri in modo efficiente. Non è possibile suggerire o forzare l'associazione di PowerShell a un parametro specifico. Il comando ha esito negativo se PowerShell non può associare gli oggetti pipe.

Per altre informazioni sulla risoluzione degli errori di associazione, vedere Analisi degli errori della pipeline più avanti in questo articolo.

Elaborazione one-at-a-time

Gli oggetti piping in un comando sono molto simili all'uso di un parametro del comando per inviare gli oggetti. Si esaminerà un esempio di pipeline. In questo esempio viene usata una pipeline per visualizzare una tabella di oggetti servizio.

Get-Service | Format-Table -Property Name, DependentServices

Funzionalmente, si tratta di usare il parametro InputObject di per Format-Table inviare la raccolta di oggetti.

Ad esempio, è possibile salvare la raccolta di servizi in una variabile passata usando il parametro InputObject .

$services = Get-Service
Format-Table -InputObject $services -Property Name, DependentServices

In alternativa, è possibile incorporare il comando nel parametro InputObject .

Format-Table -InputObject (Get-Service) -Property Name, DependentServices

Tuttavia, c'è una differenza importante. Quando si esegue la pipe di più oggetti a un comando, PowerShell invia gli oggetti al comando uno alla volta. Quando si usa un parametro di comando, gli oggetti vengono inviati come singolo oggetto matrice. Questa differenza secondaria ha conseguenze significative.

Quando si esegue una pipeline, PowerShell enumera automaticamente qualsiasi tipo che implementa l'interfaccia e invia i membri tramite la IEnumerable pipeline una alla volta. L'eccezione è [hashtable], che richiede una chiamata al GetEnumerator() metodo .

Negli esempi seguenti, una matrice e una tabella hash vengono reindirizzate al Measure-Object cmdlet per contare il numero di oggetti ricevuti dalla pipeline. La matrice include più membri e la tabella hash include più coppie chiave-valore. Solo la matrice viene enumerata una alla volta.

@(1,2,3) | Measure-Object

Count    : 3
Average  :
Sum      :
Maximum  :
Minimum  :
Property :

@{"One"=1;"Two"=2} | Measure-Object

Count    : 1
Average  :
Sum      :
Maximum  :
Minimum  :
Property :

Analogamente, se si esegue la pipe di più oggetti di elaborazione dal Get-Process cmdlet al Get-Member cmdlet, PowerShell invia ogni oggetto di processo, uno alla volta, a Get-Member. Get-Member visualizza la classe .NET (tipo) degli oggetti process e le relative proprietà e metodi.

Get-Process | Get-Member

TypeName: System.Diagnostics.Process

Name      MemberType     Definition
----      ----------     ----------
Handles   AliasProperty  Handles = Handlecount
Name      AliasProperty  Name = ProcessName
NPM       AliasProperty  NPM = NonpagedSystemMemorySize
...

Nota

Get-Member elimina i duplicati, quindi se gli oggetti sono tutti dello stesso tipo, visualizza solo un tipo di oggetto.

Tuttavia, se si usa il parametro InputObject di Get-Member, Get-Member riceve una matrice di oggetti System.Diagnostics.Process come singola unità. Visualizza le proprietà di una matrice di oggetti. Si noti il simbolo della matrice ([]) dopo il nome del tipo System.Object .

Ad esempio,

Get-Member -InputObject (Get-Process)

TypeName: System.Object[]

Name               MemberType    Definition
----               ----------    ----------
Count              AliasProperty Count = Length
Address            Method        System.Object& Address(Int32 )
Clone              Method        System.Object Clone()
...

Questo risultato potrebbe non essere quello previsto. Ma dopo averlo capito, è possibile usarlo. Ad esempio, tutti gli oggetti matrice hanno una proprietà Count . È possibile usarlo per contare il numero di processi in esecuzione nel computer.

Ad esempio,

(Get-Process).count

È importante ricordare che gli oggetti inviati alla pipeline vengono recapitati uno alla volta.

Analisi degli errori della pipeline

Quando PowerShell non può associare gli oggetti con pipe a un parametro del cmdlet di ricezione, il comando ha esito negativo.

Nell'esempio seguente si tenta di spostare una voce del Registro di sistema da una chiave del Registro di sistema a un'altra. Il Get-Item cmdlet ottiene il percorso di destinazione, che viene quindi inviato tramite pipe al Move-ItemProperty cmdlet. Il Move-ItemProperty comando specifica il percorso corrente e il nome della voce del Registro di sistema da spostare.

Get-Item -Path HKLM:\Software\MyCompany\sales |
Move-ItemProperty -Path HKLM:\Software\MyCompany\design -Name product

Il comando ha esito negativo e PowerShell visualizza il messaggio di errore seguente:

Move-ItemProperty : The input object can't be bound to any parameters for
the command either because the command doesn't take pipeline input or the
input and its properties do not match any of the parameters that take
pipeline input.
At line:1 char:23
+ $a | Move-ItemProperty <<<<  -Path HKLM:\Software\MyCompany\design -Name p

Per analizzare, usare il cmdlet per tracciare il Trace-Command componente di associazione dei parametri di PowerShell. Nell'esempio seguente viene tracciata l'associazione dei parametri durante l'esecuzione della pipeline. Il parametro PSHost visualizza i risultati della traccia nella console e il parametro FilePath invia i risultati della debug.txt traccia al file per un riferimento successivo.

Trace-Command -Name ParameterBinding -PSHost -FilePath debug.txt -Expression {
  Get-Item -Path HKLM:\Software\MyCompany\sales |
    Move-ItemProperty -Path HKLM:\Software\MyCompany\design -Name product
}

I risultati della traccia sono lunghi, ma mostrano i valori associati al Get-Item cmdlet e quindi i valori denominati associati al Move-ItemProperty cmdlet.

...
BIND NAMED cmd line args [`Move-ItemProperty`]
BIND arg [HKLM:\Software\MyCompany\design] to parameter [Path]
...
BIND arg [product] to parameter [Name]
...
BIND POSITIONAL cmd line args [`Move-ItemProperty`]
...

Infine, indica che il tentativo di associare il percorso al parametro Destination di Move-ItemProperty non riuscito.

...
BIND PIPELINE object to parameters: [`Move-ItemProperty`]
PIPELINE object TYPE = [Microsoft.Win32.RegistryKey]
RESTORING pipeline parameter's original values
Parameter [Destination] PIPELINE INPUT ValueFromPipelineByPropertyName NO
COERCION
Parameter [Credential] PIPELINE INPUT ValueFromPipelineByPropertyName NO
COERCION
...

Usare il Get-Help cmdlet per visualizzare gli attributi del parametro Destination .

Get-Help Move-ItemProperty -Parameter Destination

-Destination <String>
    Specifies the path to the destination location.

    Required?                    true
    Position?                    1
    Default value                None
    Accept pipeline input?       True (ByPropertyName)
    Accept wildcard characters?  false

I risultati mostrano che Destination accetta l'input della pipeline solo "per nome della proprietà". Pertanto, l'oggetto piped deve avere una proprietà denominata Destination.

Usare Get-Member per visualizzare le proprietà dell'oggetto proveniente da Get-Item.

Get-Item -Path HKLM:\Software\MyCompany\sales | Get-Member

L'output mostra che l'elemento è un oggetto Microsoft.Win32.RegistryKey che non ha una proprietà Destination . Questo spiega perché il comando non è riuscito.

Il parametro Path accetta l'input della pipeline in base al nome o al valore.

Get-Help Move-ItemProperty -Parameter Path

-Path <String[]>
    Specifies the path to the current location of the property. Wildcard
    characters are permitted.

    Required?                    true
    Position?                    0
    Default value                None
    Accept pipeline input?       True (ByPropertyName, ByValue)
    Accept wildcard characters?  true

Per correggere il comando, è necessario specificare la destinazione nel Move-ItemProperty cmdlet e usare Get-Item per ottenere il percorso dell'elemento da spostare.

Ad esempio,

Get-Item -Path HKLM:\Software\MyCompany\design |
Move-ItemProperty -Destination HKLM:\Software\MyCompany\sales -Name product

Continuazione linea intrinseca

Come già illustrato, una pipeline è una serie di comandi connessi dagli operatori della pipeline (|), in genere scritti in una singola riga. Tuttavia, per la leggibilità, PowerShell consente di suddividere la pipeline tra più righe. Quando un operatore pipe è l'ultimo token nella riga, il parser di PowerShell aggiunge la riga successiva al comando corrente per continuare la costruzione della pipeline.

Ad esempio, la pipeline a riga singola seguente: