about_Preference_Variables
Aggiornamento: maggio 2014
Si applica a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
ARGOMENTO
Variabili di preferenza
DESCRIZIONE BREVE
Variabili che personalizzano il comportamento di Windows PowerShell
DESCRIZIONE LUNGA
Windows PowerShell include un set di variabili che consentono di personalizzarne il comportamento. Queste "variabili di preferenza" funzionano come le opzioni nei sistemi basati su GUI.
Le variabili di preferenza interessano l'ambiente operativo di Windows PowerShell e tutti i comandi eseguiti nell'ambiente. In molti casi, i cmdlet hanno parametri che si possono usare per eseguire l'override del comportamento di preferenza per un comando specifico.
La tabella seguente elenca le variabili di preferenza e i relativi valori predefiniti.
Variable Default Value
-------- -------------
$ConfirmPreference High
$DebugPreference SilentlyContinue
$ErrorActionPreference Continue
$ErrorView NormalView
$FormatEnumerationLimit 4
$LogCommandHealthEvent False (not logged)
$LogCommandLifecycleEvent False (not logged)
$LogEngineHealthEvent True (logged)
$LogEngineLifecycleEvent True (logged)
$LogProviderLifecycleEvent True (logged)
$LogProviderHealthEvent True (logged)
$MaximumAliasCount 4096
$MaximumDriveCount 4096
$MaximumErrorCount 256
$MaximumFunctionCount 4096
$MaximumHistoryCount 4096
$MaximumVariableCount 4096
$OFS (Space character (" "))
$OutputEncoding ASCIIEncoding object
$ProgressPreference Continue
$PSDefaultParameterValues (None - empty hash table)
$PSEmailServer (None)
$PSModuleAutoLoadingPreference All
$PSSessionApplicationName WSMAN
$PSSessionConfigurationName https://schemas.microsoft.com/PowerShell/microsoft.PowerShell
$PSSessionOption (See below)
$VerbosePreference SilentlyContinue
$WarningPreference Continue
$WhatIfPreference 0
Windows PowerShell include anche le variabili di ambiente seguenti che archiviano le preferenze dell'utente. Per altre informazioni su queste variabili di ambiente, vedere about_Environment_Variables.
Variable
--------
PSExecutionPolicyPreference
PSModulePath
USO DELLE VARIABILI DI PREFERENZA
Questo documento descrive tutte le variabili di preferenza.
Per visualizzare il valore corrente di una determinata variabile di preferenza, digitarne il nome. Windows PowerShell fornirà il valore. Ad esempio, il comando seguente mostra il valore della variabile $ConfirmPreference.
PS> $ConfirmPreference
High
Per modificare il valore di una variabile, usare un'istruzione di assegnazione. Ad esempio, l'istruzione seguente assegna il valore "Medium" alla variabile $ConfirmPreference.
PS> $ConfirmPreference = "Medium"
Come tutte le variabili, i valori impostati sono specifici della sessione corrente di Windows PowerShell. Per renderli efficaci in tutte la sessioni di Windows PowerShell, aggiungerli al profilo di Windows PowerShell. Per altre informazioni, vedere about_Profiles.
USO IN MODALITÀ REMOTA
Quando si eseguono comandi in un computer remoto, i comandi remoti sono soggetti solo alle preferenze impostate nel client Windows PowerShell nel computer remoto. Ad esempio, quando si esegue un comando remoto, il valore della variabile $DebugPreference nel computer remoto determina come Windows PowerShell risponde ai messaggi di debug.
Per altre informazioni sui comandi remoti, vedere about_remote.
$ConfirmPreference
------------------
Determina se Windows PowerShell chiede automaticamente conferma prima di eseguire un cmdlet o una funzione.
Quando il valore della variabile $ConfirmPreference (High, Medium, Low) è minore o uguale al rischio assegnato al cmdlet o alla funzione (High, Medium, Low), Windows PowerShell chiede automaticamente conferma prima di eseguire il cmdlet o la funzione.
Se il valore della variabile $ConfirmPreference è None, Windows PowerShell non chiede mai conferma prima di eseguire un cmdlet o una funzione.
Per modificare il comportamento di conferma per tutte le funzioni e i cmdlet nella sessione, modificare il valore della variabile $ConfirmPreference.
Per eseguire l'override di $ConfirmPreference per un singolo comando, usare il parametro Confirm del cmdlet o della funzione. Per richiedere conferma, usare -Confirm. Per eliminare la conferma, usare -Confirm:$false.
Valori validi di $ConfirmPreference:
None: Windows PowerShell non chiede conferma automaticamente. Per richiedere conferma di un particolare comando, usare il parametro Confirm del cmdlet o della funzione.
Low: Windows PowerShell chiede conferma prima di eseguire i cmdlet o le funzioni con rischio basso, medio o alto.
Medium: Windows PowerShell chiede conferma prima di eseguire i cmdlet o le funzioni con rischio medio o alto.
High: Windows PowerShell chiede conferma prima di eseguire i cmdlet o le funzioni con rischio alto.
SPIEGAZIONE DETTAGLIATA
Quando le azioni di un cmdlet o di una funzione hanno un impatto considerevole sul sistema, ad esempio quelle che eliminano dati o usano una quantità significativa di risorse di sistema, Windows PowerShell può chiedere automaticamente conferma prima di eseguire l'azione.
Ad esempio:
PS> remove-item file.txt
Confirm
Are you sure you want to perform this action?
Performing operation "Remove File" on Target "C:\file.txt".
[Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"):
La stima del rischio è un attributo del cmdlet o della funzione noto come "ConfirmImpact". Non può essere modificata dagli utenti.
I cmdlet e le funzioni che possono rappresentare un rischio per il sistema hanno un parametro Confirm che si può usare per richiedere o eliminare la conferma per un singolo comando.
Dato che la maggior parte dei cmdlet e delle funzioni usa il valore di rischio predefinito Medium per ConfirmImpact e il valore predefinito di $ConfirmPreference è High, la conferma automatica si verifica raramente. È comunque possibile attivare la conferma automatica modificando il valore di $ConfirmPreference in Medium o Low.
ESEMPI
Questo esempio mostra l'effetto del valore predefinito di $ConfirmPreference. Il valore High conferma solo i cmdlet e le funzioni ad alto rischio. Dato che la maggior parte dei cmdlet e delle funzioni hanno un rischio medio, non vengono confermati automaticamente.
PS> $confirmpreference #Get the current value of the
High variable
PS> remove-item temp1.txt #Delete a file
PS> #Deleted without confirmation
PS> remove-item temp2.txt -confirm #Use the Confirm parameter to
request confirmation
Confirm
Are you sure you want to perform this action?
Performing operation "Remove File" on Target "C:\temp2.txt".
[Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"):
L'esempio seguente mostra l'effetto della modifica del valore di $ConfirmPreference in Medium. Dato che la maggior parte dei cmdlet e delle funzioni hanno un rischio medio, vengono confermati automaticamente. Per eliminare la richiesta di conferma per un singolo comando, usare il parametro Confirm con valore $false
PS> $confirmpreference = "Medium" #Change the value of $ConfirmPreference
PS> remove-item temp2.txt #Deleting a file triggers confirmation
Confirm
Are you sure you want to perform this action?
Performing operation "Remove File" on Target "C:\temp2.txt".
[Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"):
PS> remove-item temp3.txt -confirm:$false #Use Confirm parameter
to suppress confirmation
PS>
$DebugPreference
------------------
Determina la risposta di Windows PowerShell ai messaggi di debut generati da uno script, cmdlet o provider o da un comando Write-Debug alla riga di comando.
Alcuni cmdlet visualizzano messaggi di debug, che sono messaggi generalmente molto tecnici progettati per i programmatori e professionisti del supporto tecnico. Per impostazione predefinita, i messaggi di debug non vengono visualizzati, ma è possibile visualizzarli modificando il valore di $DebugPreference.
Si può usare anche il parametro comune Debug di un cmdlet per visualizzare o nascondere i messaggi di debug per un comando specifico. Per altre informazioni, digitare: "get-help about_commonparameters".
Valori validi:
Stop: visualizza il messaggio di debug e arresta l'esecuzione. Scrive un errore nella console.
Inquire: visualizza il messaggio di debug e chiede se si vuole continuare. Si noti che aggiungendo il parametro comune Debug a un comando, quando il comando è configurato per generare un messaggio di debug, il valore della variabile $DebugPreference viene impostato su Inquire.
Continue: visualizza il messaggio di debug e continua l'esecuzione.
SilentlyContinue: (impostazione predefinita) Nessun effetto. Il messaggio di debug non viene visualizzato e l'esecuzione continua senza interruzioni.
ESEMPI
Gli esempi seguenti mostrano l'effetto della modifica dei valori di $DebugPreference quando si immette un comando Write-Debug nella riga di comando. La modifica influisce su tutti i messaggi di debug, inclusi quelli generati da cmdlet e script. Gli esempi mostrano anche l'uso del parametro comune Debug, che visualizza o nasconde i messaggi di debug relativi a un singolo comando.
Questo esempio mostra l'effetto del valore predefinito "SilentlyContinue". Il messaggio di debug non viene visualizzato e l'elaborazione continua. L'ultimo comando usa il parametro Debug per eseguire l'override della preferenza per un singolo comando.
PS> $debugpreference # Get the current value of
SilentlyContinue $DebugPreference
PS> write-debug "Hello, World"
PS> # The debug message is not
displayed.
PS> write-debug "Hello, World" -Debug # Use the Debug parameter
DEBUG: Hello, World # The debug message is
is requested. displayed and confirmation
Confirm
Continue with this operation?
[Y] Yes [A] Yes to All [H] Halt Command [S] Suspend [?] Help (default is "Y"):
Questo esempio mostra l'effetto del valore "Continue". L'ultimo comando usa il parametro Debug con valore $false per eliminare il messaggio per un singolo comando.
PS> $debugpreference = "Continue" # Change the value to "Continue"
PS> write-debug "Hello, World"
DEBUG: Hello, World # The debug message is displayed
PS> and processing continues.
PS> write-debug "Hello, World" -Debug:$false
# Use the Debug parameter with
false.
PS> # The debug message is not
displayed.
Questo esempio mostra l'effetto del valore "Stop". L'ultimo comando usa il parametro Debug con valore $false per eliminare il messaggio per un singolo comando.
PS> $debugpreference = "Stop" #Change the value to "Stop"
PS> write-debug "Hello, World"
DEBUG: Hello, World
Write-Debug : Command execution stopped because the shell variable "DebugPreference" is
set to Stop.
At line:1 char:12
+ write-debug <<<< "Hello, World"
PS> write-debug "Hello, World" -Debug:$false
# Use the Debug parameter with
$false
PS> # The debug message is not
displayed and processing is
not stopped.
Questo esempio mostra l'effetto del valore "Inquire". L'ultimo comando usa il parametro Debug con valore $false per eliminare il messaggio per un singolo comando.
PS> $debugpreference = "Inquire"
PS> write-debug "Hello, World"
DEBUG: Hello, World
Confirm
Continue with this operation?
[Y] Yes [A] Yes to All [H] Halt Command [S] Suspend [?] Help (default is "Y"):
PS> write-debug "Hello, World" -Debug:$false
# Use the Debug parameter with
$false
PS> # The debug message is not
displayed and processing
continues without interruption.
$ErrorActionPreference
----------------------
Determina la risposta di Windows PowerShell a un errore non irreversibile, ovvero un errore che non interrompe l'elaborazione del cmdlet, nella riga di comando o in uno script, cmdlet o provider, ad esempio gli errori generati dal cmdlet Write-Error.
Si può usare anche il parametro comune ErrorAction di un cmdlet per eseguire l'override della preferenza per un comando specifico.
Valori validi:
Stop: visualizza il messaggio di errore e arresta l'esecuzione.
Inquire: visualizza il messaggio di errore e chiede se si vuole continuare.
Continue (impostazione predefinita): visualizza il messaggio di errore e prosegue con l'esecuzione.
Suspend: interrompe automaticamente un processo del flusso di lavoro per consentire di eseguire un'ulteriore analisi. Al termine di tale analisi, è possibile riprendere il flusso di lavoro.
SilentlyContinue: nessun effetto. Il messaggio di errore non viene visualizzato e l'esecuzione continua senza interruzioni.
NOTA:
Il valore Ignore del parametro comune ErrorAction non è un valore valido della variabile $ErrorActionPreference. Il valore Ignore è destinato all'uso per singoli comandi, non come preferenza salvata.
Né $ErrorActionPreference né il parametro comune ErrorAction incidono sulla risposta di Windows PowerShell agli errori irreversibili, ovvero quelli che interrompono l'elaborazione dei cmdlet.
Per altre informazioni sul parametro comune ErrorAction, vedere about_CommonParameters (https://go.microsoft.com/fwlink/?LinkID=113216).
ESEMPI
Questi esempi illustrano l'effetto dei diversi valori di $ErrorActionPreference e l'uso del parametro comune ErrorAction per eseguire l'override della preferenza per un singolo comando. Il parametro ErrorAction ha gli stessi valori validi della variabile $ErrorActionPreference.
Questo esempio mostra l'effetto del valore predefinito Continue.
PS> $erroractionpreference
Continue# Display the value of the preference.
PS> write-error "Hello, World"
# Generate a non-terminating error.
write-error "Hello, World" : Hello, World
# The error message is displayed and
execution continues.
PS> write-error "Hello, World" -ErrorAction:SilentlyContinue
# Use the ErrorAction parameter with a
value of "SilentlyContinue".
PS>
# The error message is not displayed and
execution continues.
Questo esempio mostra l'effetto del valore SilentlyContinue.
PS> $ErrorActionPreference = "SilentlyContinue"
# Change the value of the preference.
PS> write-error "Hello, World"
# Generate an error message.
PS>
# Error message is suppressed.
PS> write-error "Hello, World" -erroraction:continue
# Use the ErrorAction parameter with a
value of "Continue".
write-error "Hello, World" -erroraction:continue : Hello, World
# The error message is displayed and
execution continues.
Questo esempio mostra l'effetto di un errore reale. In questo caso, il comando ottiene un file non esistente, nofile.txt. Nell'esempio viene usato anche il parametro comune ErrorAction per eseguire l'override della preferenza.
PS> $erroractionpreference
SilentlyContinue # Display the value of the preference.
PS> get-childitem -path nofile.txt
PS> # Error message is suppressed.
PS> $ErrorActionPreference = "Continue"
# Change the value to Continue.
PS> get-childitem -path nofile.txt
Get-ChildItem : Cannot find path 'C:\nofile.txt' because it does not exist.
At line:1 char:4
+ get-childitem <<<< nofile.txt
PS> get-childitem -path nofile.txt -erroraction SilentlyContinue
# Use the ErrorAction parameter
PS>
# Error message is suppressed.
PS> $ErrorActionPreference = "Inquire"
# Change the value to Inquire.
PS> get-childitem -path nofile.txt
Confirm
Cannot find path 'C:\nofile.txt' because it does not exist.
[Y] Yes [A] Yes to All [H] Halt Command [S] Suspend [?] Help (default is "Y"): y
Get-ChildItem : Cannot find path 'C:\nofile.txt' because it does not exist.
At line:1 char:4
+ get-childitem <<<< nofile.txt
PS> $ErrorActionPreference = "Continue"
# Change the value to Continue.
PS> Get-Childitem nofile.txt -erroraction "Inquire"
# Use the ErrorAction parameter to override
the preference value.
Confirm
Cannot find path 'C:\nofile.txt' because it does not exist.
[Y] Yes [A] Yes to All [H] Halt Command [S] Suspend [?] Help (default is "Y"):
$ErrorView
----------
Determina il formato di visualizzazione dei messaggi di errore in Windows PowerShell.
Valori validi
NormalView (impostazione predefinita): Visualizzazione dettagliata progettata per la maggior parte degli utenti. È costituita da una descrizione dell'errore, dal nome dell'oggetto coinvolto nell'errore e da frecce (<<<<) che puntano alle parole del comando all'origine dell'errore.
CategoryView: Visualizzazione concisa e strutturata progettata per ambienti di produzione. Il formato è: {Category}: ({TargetName}:{TargetType}):[{Activity}], {Reason}
Per altre informazioni sui campi in CategoryView, vedere "ErrorCategoryInfo class" in Windows PowerShell SDK.
ESEMPI
Questi esempi mostrano l'effetto dei valori di ErrorView.
Questo esempio mostra come viene visualizzato un errore quando il valore di $ErrorView è NormalView. In questo caso viene usato il comando Get-ChildItem per trovare un file inesistente.
PS> $ErrorView # Verify the value.
NormalView
PS> get-childitem nofile.txt # Find a non-existent file.
Get-ChildItem : Cannot find path 'C:\nofile.txt' because it does not exist.
At line:1 char:14
+ get-childitem <<<< nofile.txt
Questo esempio mostra come viene visualizzato lo stesso errore quando il valore di $ErrorView è CategoryView.
PS> $ErrorView = "CategoryView" # Change the value to
CategoryView
PS> get-childitem nofile.txt
ObjectNotFound: (C:\nofile.txt:String) [Get-ChildItem], ItemNotFoundException
Questo esempio dimostra che il valore di ErrorView ha effetto solo sulla visualizzazione degli errori, non sulla struttura dell'oggetto errore archiviato nella variabile automatica $error. Per altre informazioni sulla variabile automatica $error, vedere about_automatic_variables.
Questo comando prende l'oggetto ErrorRecord associato all'errore più recente nella matrice di errori (elemento 0) e formatta tutte le proprietà dell'oggetto errore in un elenco.
PS> $error[0] | format-list -property * -force
Exception : System.Management.Automation.ItemNotFoundException: Cannot find path
'C:\nofile.txt' because it does not exist.
at System.Management.Automation.SessionStateInternal.GetChildItems(String path,
Boolean recurse, CmdletProviderContext context)
at System.Management.Automation.ChildItemCmdletProviderIntrinsics.Get(String path,
Boolean recurse, CmdletProviderContext context)
at Microsoft.PowerShell.Commands.GetChildItemCommand.ProcessRecord()
TargetObject : C:\nofile.txt
CategoryInfo : ObjectNotFound: (C:\nofile.txt:String) [Get-ChildItem],
ItemNotFoundException
FullyQualifiedErrorId : PathNotFound,Microsoft.PowerShell.Commands.GetChildItemCommand
ErrorDetails :
InvocationInfo : System.Management.Automation.InvocationInfo
$FormatEnumerationLimit
-----------------------
Determina quanti elementi enumerati sono inclusi in una visualizzazione. Questa variabile non ha effetto sugli oggetti sottostanti, ma solo sulla visualizzazione. Quando il valore di $FormatEnumerationLimit è minore del numero di elementi enumerati, Windows PowerShell aggiunge i puntini di sospensione (...) per indicare gli elementi non visualizzati.
Valid values: Integers (Int32)
Default value: 4
ESEMPI
Questo esempio mostra come usare la variabile $FormatEnumerationLimit per migliorare la visualizzazione degli elementi enumerati.
Il comando in questo esempio genera una tabella che elenca tutti i servizi in esecuzione nel computer suddivisi in due gruppi, uno per i servizi in esecuzione e uno per i servizi arrestati. Usa un comando Get-Service per ottenere tutti i servizi, quindi invia i risultati tramite la pipeline al cmdlet Group-Object, che raggruppa i risultati in base allo stato del servizio.
La visualizzazione risultante è una tabella che elenca lo stato nella colonna Name e i processi con tale stato nella colonna Group. Per modificare le etichette delle colonne, usare una tabella hash table. Per altre informazioni, vedere gli esempi in "get-help format-table -examples".
Nella colonna Group per ogni stato vengono elencati al massimo 4 servizi. Per aumentare il numero di elementi elencati, aumentare il valore di $FormatEnumerationLimit a 1000.
Nella visualizzazione risultante, l'elenco nella colonna Group ora è limitato dalla lunghezza di riga. Nel comando finale nell'esempio usare il parametro Wrap di Format-Table per visualizzare tutti i processi in ogni gruppo di stato.
PS> $formatenumerationlimit # Find the current value
4
PS> get-service | group-object -property status
# List all services grouped by
status
Count Name Group
----- ---- -----
60 Running {AdtAgent, ALG, Ati HotKey Poller, AudioSrv...}
41 Stopped {Alerter, AppMgmt, aspnet_state, ATI Smart...}
# The list is truncated after
4 items.
PS> $formatenumerationlimit = 1000
# Increase the limit to 1000.
PS> get-service | group-object -property status
# Repeat the command.
Count Name Group
----- ---- -----
60 Running {AdtAgent, ALG, Ati HotKey Poller, AudioSrv, BITS, CcmExec...
41 Stopped {Alerter, AppMgmt, aspnet_state, ATI Smart, Browser, CiSvc...
PS> get-service | group-object -property status | format-table -wrap
# Add the Wrap parameter.
Count Name Group
----- ---- -----
60 Running {AdtAgent, ALG, Ati HotKey Poller, AudioSrv, BITS, CcmExec, Client
for NFS, CryptSvc, DcomLaunch, Dhcp, dmserver, Dnscache, ERSvc,
Eventlog, EventSystem, FwcAgent, helpsvc, HidServ, IISADMIN,
InoRPC, InoRT, InoTask, lanmanserver, lanmanworkstation, LmHosts,
MDM, Netlogon, Netman, Nla, NtLmSsp, PlugPlay, PolicyAgent,
ProtectedStorage, RasMan, RemoteRegistry, RpcSs, SamSs, Schedule,
seclogon, SENS, SharedAccess, ShellHWDetection, SMT PSVC, Spooler,
srservice, SSDPSRV, stisvc, TapiSrv, TermService, Themes, TrkWks,
UMWdf, W32Time, W3SVC, WebClient, winmgmt, wscsvc, wuauserv,
WZCSVC, zzInterix}
41 Stopped {Alerter, AppMgmt, aspnet_state, ATI Smart, Browser, CiSvc,
ClipSrv, clr_optimization_v2.0.50727_32, COMSysApp, CronService,
dmadmin, FastUserSwitchingCompatibility, HTTPFilter, ImapiService,
Mapsvc, Messenger, mnmsrvc, MSDTC, MSIServer, msvsmon80, NetDDE,
NetDDEdsdm, NtmsSvc, NVSvc, ose, RasAuto, RDSessMgr, RemoteAccess,
RpcLocator, SCardSvr, SwPrv, SysmonLog, TlntSvr, upnphost, UPS,
VSS, WmdmPmSN, Wmi, WmiApSrv, xmlprov}
$Log*Event
----------
La variabile di preferenza Log*Event determina quali tipi di evento vengono scritti nel registro eventi di Windows PowerShell in Visualizzatore eventi. Per impostazione predefinita vengono registrati solo gli eventi del motore e del provider, ma è possibile usare le variabili di preferenza Log*Event per personalizzare il log, ad esempio per la registrazione degli eventi relativi ai comandi.
Le variabili di preferenza Log*Event sono le seguenti:
$LogCommandHealthEvent: Logs errors and exceptions in command initialization
and processing. Default = $false (not logged).
$LogCommandLifecycleEvent:
Logs the starting and stopping of commands and command pipelines
and security exceptions in command discovery. Default = $false (not logged).
$LogEngineHealthEvent: Logs errors and failures of sessions. Default = $true (logged).
$LogEngineLifecycleEvent: Logs the opening and closing of sessions.
Default = $true (logged).
$LogProviderHealthEvent: Logs provider errors, such as read and write errors,
lookup errors, and invocation errors. Default = $true (logged).
$LogProviderLifecycleEvent: Logs adding and removing of Windows PowerShell providers.
Default = $true (logged). (For information about Windows PowerShell providers, type:
"get-help about_provider".
Per abilitare un Log*Event, digitare la variabile con valore $true, ad esempio:
$LogCommandLifeCycleEvent
- or -
$LogCommandLifeCycleEvent = $true
Per disabilitare un tipo di evento, digitare la variabile con valore $false, ad esempio:
$LogCommandLifeCycleEvent = $false
Gli eventi che si abilitano sono validi solo per la console di Windows PowerShell corrente. Per applicare la configurazione a tutte le console, salvare le impostazioni delle variabili nel profilo di Windows PowerShell.
$MaximumAliasCount
------------------
Determina quanti alias sono consentiti in una sessione di Windows PowerShell. Il valore predefinito 4096 dovrebbe essere sufficiente nella maggior parte dei casi, ma può essere modificato in base alle esigenze.
Valid values: 1024 - 32768 (Int32)
Default: 4096
To count the aliases on your system, type:
(get-alias).count
$MaximumDriveCount
------------------
Determina quante unità Windows PowerShell sono consentite in una determinata sessione, inclusi le unità del file system e gli archivi dati esposti dai provider di Windows PowerShell e visualizzati come unità, come le unità Alias: e HKLM: .
Valid values: 1024 - 32768 (Int32)
Default: 4096
To count the aliases on your system, type:
(get-psdrive).count
$MaximumErrorCount
------------------
Determina quanti errori vengono salvati nella cronologia errori per la sessione.
Valid values: 256 - 32768 (Int32)
Default: 256
Gli oggetti che rappresentano ogni errore conservato vengono archiviati nella variabile automatica $Error. Questa variabile contiene una matrice di oggetti record di errore, uno per ogni errore. L'errore più recente è il primo oggetto nella matrice ($Error[0]).
Per contare gli errori nel sistema, usare la proprietà Count della matrice $Error. Digitare:
$Error.count
Per visualizzare un errore specifico, usare la notazione di matrice. Ad esempio, per visualizzare l'errore più recente, digitare:
$Error[0]
Per visualizzare l'errore mantenuto meno recente, digitare:
$Error[($Error.Count -1]
Per visualizzare le proprietà dell'oggetto ErrorRecord, digitare:
$Error[0] | format-list -property * -force
In questo comando, il parametro Force esegue l'override della formattazione speciale degli oggetti ErrorRecord e ripristina il formato convenzionale.
Per eliminare tutti gli errori dalla cronologia errori, usare il metodo Clear della matrice di errori.
PS> $Error.count
17
PS> $Error.clear()
PS>
PS> $Error.count
0
Per trovare tutte le proprietà e i metodi di una matrice di errori, usare il cmdlet Get-Member con il parametro InputObject. Quando si invia una raccolta di oggetti a Get-Member tramite pipe, Get-Member visualizza le proprietà e i metodi degli oggetti nella raccolta. Quando si usa il parametro InputObject di Get-Member, Get-Member visualizza le proprietà e i metodi della raccolta.
$MaximumFunctionCount
------------------
Determina quante funzioni sono consentite in una determinata sessione.
Valid values: 1024 - 32768 (Int32)
Default: 4096
Per visualizzare le funzioni nella sessione, usare l'unità Function: di Windows PowerShell che viene esposta dal provider Function di Windows PowerShell. Per altre informazioni sul provider Function, digitare "get-help function".
Per elencare le funzioni della sessione corrente, digitare:
get-childitem function:
Per contare le funzioni della sessione corrente, digitare:
(get-childitem function:).count
$MaximumHistoryCount
------------------
Determina quanti comandi vengono salvati nella cronologia comandi per la sessione corrente.
Valid values: 1 - 32768 (Int32)
Default: 4096
Per determinare il numero di comandi salvati nella cronologia dei comandi, digitare:
(get-history).count
Per visualizzare i comandi salvati nella cronologia dei comandi, usare il cmdlet Get-History. Per altre informazioni, vedere about_History (https://go.microsoft.com/fwlink/?LinkID=113233).
NOTA: In Windows PowerShell 2.0, il valore predefinito della variabile $MaximumHistoryCount è 64.
$MaximumVariableCount
------------------
Determina quante variabili sono consentite in una determinata sessione, incluse le variabili automatiche, le variabili di preferenza e le variabili create in comandi e script.
Valid values: 1024 - 32768 (Int32)
Default: 4096
Per visualizzare le variabili nella sessione, usare il cmdlet Get-Variable e le funzionalità dell'unità Variable: di Windows PowerShell e il provider Variable di Windows PowerShell. Per altre informazioni sul provider Variable, digitare "get-help variable".
Per trovare il numero corrente di variabili nel sistema, digitare:
(get-variable).count
$OFS
----
Separatore del campo di output. Specifica il carattere che separa gli elementi di una matrice quando la matrice viene convertita in una stringa.
Valid values: Any string.
Default: Space
Per impostazione predefinita, la variabile $OFS non esiste e l'output del separatore di file è uno spazio, ma è possibile aggiungere questa variabile e impostarla su qualsiasi stringa.
ESEMPI
Questo esempio mostra che viene usato uno spazio per separare i valori quando una matrice viene convertita in una stringa. In questo caso, una matrice di interi viene archiviata in una variabile e quindi viene eseguito il cast della variabile come stringa.
PS> $array = 1,2,3 # Store an array of integers.
PS> [string]$array # Cast the array to a string.
1 2 3 # Spaces separate the elements
Per cambiare il separatore, aggiungere la variabile $OFS assegnandole un valore. Per funzionare correttamente, la variabile deve essere denominata $OFS.
PS> $OFS = "+" # Create $OFS and assign a "+"
PS> [string]$array # Repeat the command
1+2+3 # Plus signs separate the elements
Per ripristinare il comportamento predefinito, si può assegnare uno spazio (" ") al valore di $OFS o eliminare la variabile. Questo comando elimina la variabile e quindi verifica che il separatore sia uno spazio.
PS> Remove-Variable OFS # Delete $OFS
PS>
PS> [string]$array # Repeat the command
1 2 3 # Spaces separate the elements
$OutputEncoding
---------------
Determina il metodo di codifica dei caratteri usato da Windows PowerShell quando invia testo ad altre applicazioni.
Ad esempio, se un'applicazione restituisce stringhe Unicode a Windows PowerShell, potrebbe essere necessario modificare il valore in UnicodeEncoding per inviare correttamente i caratteri.
Valid values: Objects derived from an Encoding class, such as
ASCIIEncoding, SBCSCodePageEncoding, UTF7Encoding,
UTF8Encoding, UTF32Encoding, and UnicodeEncoding.
Default: ASCIIEncoding object (System.Text.ASCIIEncoding)
ESEMPI
Questo esempio mostra come far funzionare il comando FINDSTR di Windows in Windows PowerShell in un computer localizzato per una lingua che usa i caratteri Unicode, ad esempio il cinese. Il primo comando trova il valore di $OutputEncoding. Dato che il valore è un oggetto di codifica, visualizzare solo la proprietà EncodingName.
PS> $OutputEncoding.EncodingName # Find the current value
US-ASCII
In questo esempio viene usato un comando FINDSTR per cercare due caratteri cinesi presenti nel file Test.txt. Quando viene eseguito al prompt dei comandi di Windows (Cmd.exe), questo comando FINDSTR trova i caratteri nel file di testo. Quando invece si esegue lo stesso comando FINDSTR in Windows PowerShell, i caratteri non vengono trovati perché Windows PowerShell li invia a FINDSTR in testo ASCII anziché Unicode.
PS> findstr <Unicode-characters> # Use findstr to search.
PS> # None found.
Per fare in modo che il comando funzioni in Windows PowerShell, impostare il valore di $OutputEncoding sul valore della proprietà OutputEncoding della console, che è basato sulle impostazioni locali selezionate per Windows. Poiché OutputEncoding è una proprietà statica della console, usare un doppio segno di due punti (::) nel comando.
PS> $OutputEncoding = [console]::outputencoding
PS> # Set the value equal to the
OutputEncoding property of the
console.
PS> $OutputEncoding.EncodingName
OEM United States
# Find the resulting value.
A seguito di questa modifica, il comando FINDSTR trova i caratteri.
PS> findstr <Unicode-characters>
test.txt: <Unicode-characters>
# Use findstr to search. It find the
characters in the text file.
$ProgressPreference
-------------------
Determina la risposta di Windows PowerShell agli aggiornamenti di stato generati da uno script, cmdlet o provider, come gli indicatori di stato generati dal cmdlet Write-Progress. Il cmdlet Write-Progress crea indicatori di stato che descrivono lo stato di un comando.
Valori validi:
Stop: non visualizza l'indicatore di stato. Visualizza invece un messaggio di errore e arresta l'esecuzione.
Inquire: non visualizza l'indicatore di stato. Chiede l'autorizzazione per continuare. Se si risponde con Y o A, visualizza l'indicatore di stato.
Continue (impostazione predefinita): visualizza l'indicatore di stato e continua l'esecuzione.
SilentlyContinue: esegue il comando ma non visualizza l'indicatore di stato.
$PSEmailServer
--------------
Specifica il server di posta elettronica predefinito che viene usato per inviare messaggi di posta elettronica. Questa variabile di preferenza viene usata dai cmdlet che inviano messaggi di posta elettronica, ad esempio il cmdlet Send-MailMessage.
$PSDefaultParameterValues
-------------------------
Specifica i valori predefiniti personalizzati per i parametri di cmdlet e funzioni avanzate. Il valore di $PSDefaultParameterValues è una tabella hash nella quale la chiave consiste nel nome del cmdlet e nel nome del parametro separati da due punti (:), mentre il valore è un valore predefinito personalizzato che viene specificato.
Questa variabile è stata introdotta in Windows PowerShell 3.0.
Per altre informazioni su questa variabile di preferenza, vedere about_Parameters_Default_Values.
$PSModuleAutoloadingPreference
------------------------------
Abilita e disabilita l'importazione automatica dei moduli nella sessione. Il valore predefinito è "All". Indipendentemente dal valore di questa variabile, è possibile usare il cmdlet Import-Module per importare un modulo.
I valori validi sono i seguenti:
All I moduli vengono importati automaticamente al primo utilizzo. Per importare un modulo, ottenere (Get-Command) o usare qualsiasi comando nel modulo.
ModuleQualified
I moduli vengono importati automaticamente solo quando un utente usa il nome di un comando qualificato dal modulo nel modulo. Ad esempio, se l'utente digita "MyModule\MyCommand", Windows PowerShell importa il modulo MyModule.
None L'importazione automatica dei moduli è disabilitata nella sessione. Per importare un modulo, usare il cmdlet Import-Module.
Per altre informazioni sull'importazione automatica di moduli, vedere about_Modules (https://go.microsoft.com/fwlink/?LinkID=144311).
$PSSessionApplicationName
---------------------------
Specifica il nome dell'applicazione predefinito per un comando remoto che usa la tecnologia WS-Management.
Il nome dell'applicazione predefinito di sistema è WSMAN, ma si può usare questa variabile di preferenza per modificare l'impostazione predefinita.
Il nome dell'applicazione è l'ultimo nodo in un URI di connessione. Ad esempio, il nome dell'applicazione nel seguente URI di esempio è WSMAN.
http://Server01:8080/WSMAN
Il nome dell'applicazione predefinito viene usato quando il comando remoto non specifica un URI di connessione o un nome di applicazione.
Il servizio Gestione remota Windows usa il nome dell'applicazione per selezionare un listener per soddisfare la richiesta di connessione. Il valore di questo parametro deve corrispondere al valore della proprietà URLPrefix di un listener nel computer remoto.
Per eseguire l'override dell'impostazione predefinita di sistema e del valore di questa variabile e selezionare un nome di applicazione diverso per una determinata sessione, usare i parametri ConnectionURI o ApplicationName del cmdlet New-PSSession, Enter-PSSession o Invoke-Command.
Questa variabile di preferenza viene impostata sul computer locale, ma specifica un listener nel computer remoto. Se il nome dell'applicazione specificato non esiste nel computer remoto, il comando che prova a stabilire la sessione non riesce.
$PSSessionConfigurationName
---------------------------
Specifica la configurazione di sessione predefinita usata per le sessioni PSSession create nella sessione corrente.
Questa variabile di preferenza viene impostata sul computer locale, ma specifica una configurazione di sessione presente nel computer remoto.
Il valore della variabile $PSSessionConfigurationName è un URI di risorsa completo.
Il valore predefinito:
https://schemas.microsoft.com/PowerShell/microsoft.PowerShell
indica la configurazione di sessione Microsoft.PowerShell nel computer remoto.
Se si specifica solo un nome di configurazione, viene anteposto l'URI di schema seguente:
https://schemas.microsoft.com/PowerShell/
È possibile eseguire l'override dell'impostazione predefinita e selezionare una configurazione di sessione diversa per una particolare sessione usando il parametro ConfigurationName del cmdlet New-PSSession, Enter-PSSession o Invoke-Command.
Il valore di questa variabile può essere modificato in qualsiasi momento. Quando si esegue questa operazione, tenere presente che la configurazione di sessione selezionata deve esistere nel computer remoto. In caso contrario, il comando per la creazione di una sessione che usa la configurazione di sessione ha esito negativo.
Questa variabile di preferenza non determina quali configurazioni di sessione locale vengono usate quando gli utenti remoti creano una sessione che si connette al computer. Si possono comunque usare le autorizzazioni per le configurazioni della sessione locale per stabilire quali utenti possono usarle.
$PSSessionOption
----------------
Definisce i valori predefiniti per le opzioni utente avanzate in una sessione remota. Queste preferenze di opzione sostituiscono i valori predefiniti di sistema per le opzioni della sessione.
La variabile $PSSessionOption contiene un oggetto PSSessionOption (System.Management.Automation.Remoting.PSSessionObject). Ogni proprietà dell'oggetto rappresenta un'opzione di sessione. Ad esempio, la proprietà NoCompression disattiva la compressione dei dati durante la sessione.
Per impostazione predefinita, la variabile $PSSessionOption contene un oggetto PSSessionOption con i valori predefiniti per tutte le opzioni, come illustrato di seguito.
MaximumConnectionRedirectionCo For descriptions of these options, see the help topic for the unt : 5
NoCompression : False
NoMachineProfile : False
ProxyAccessType : None
ProxyAuthentication : Negotiate
ProxyCredential :
SkipCACheck : False
SkipCNCheck : False
SkipRevocationCheck : False
OperationTimeout : 00:03:00
NoEncryption : False
UseUTF16 : False
IncludePortInSPN : False
OutputBufferingMode : None
Culture :
UICulture :
MaximumReceivedDataSizePerCommand :
MaximumReceivedObjectSize : 209715200
ApplicationArguments :
OpenTimeout : 00:03:00
CancelTimeout : 00:01:00
IdleTimeout : -00:00:00.0010000
Per le descrizioni di queste opzioni, vedere l'argomento della Guida relativo al cmdlet New-PSSessionOption.
Per modificare il valore della variabile di preferenza $PSSessionOption, usare il cmdlet New-PSSessionOption per creare un oggetto PSSessionOption con i valori delle opzioni che si preferiscono. Salvare l'output in una variabile denominata $PSSessionOption.
Ad esempio:
$PSSessionOption = New-PSSessionOption -NoCompression
Per usare la variabile di preferenza $PSSessionOption in ogni sessione di Windows PowerShell, aggiungere un comando New-PSSessionOption che crea la variabile $PSSessionOption al proprio profilo di Windows PowerShell.
Si possono anche impostare opzioni personalizzate per una particolare sessione remota. Le opzioni impostate hanno la precedenza sulle impostazioni predefinite di sistema e sul valore della variabile di preferenza $PSSessionOption.
Per impostare opzioni di sessione personalizzate, usare il cmdlet New-PSSessionOption per creare un oggetto PSSessionOption. Usare quindi l'oggetto PSSessionOption come valore del parametro SessionOption nei cmdlet che creano una sessione, come New-PSSession, Enter-PSSession e Invoke-Command.
Per altre informazioni sul cmdlet New-PSSessionOption, vedere l'argomento della guida relativo a New-PSSessionOption. Per altre informazioni sui comandi remoti e sulle sessioni, vedere about_Remote e about_PSSessions. Per altre informazioni sull'uso di un profilo, vedere about_Profiles.
$VerbosePreference
------------------
Determina la risposta di Windows PowerShell ai messaggi dettagliati generati da uno script, cmdlet o provider, come i messaggi generati dal cmdlet Write-Verbose. In genere, i messaggi dettagliati descrivono le azioni eseguite per eseguire un comando.
Per impostazione predefinita, i messaggi dettagliati non vengono visualizzati, ma è possibile modificare questo comportamento cambiando il valore di $VerbosePreference.
Si può usare anche il parametro comune Verbose di un cmdlet per visualizzare o nascondere i messaggi dettagliati per un comando specifico. Per altre informazioni, digitare: "get-help about_commonparameters".
Valori validi:
Stop: visualizza il messaggio dettagliato e un messaggio di errore, quindi arresta l'esecuzione.
Inquire: visualizza il messaggio dettagliato e quindi un messaggio che chiede se si vuole continuare.
Continue: visualizza il messaggio dettagliato e continua l'esecuzione.
SilentlyContinue (impostazione predefinita): non visualizza il messaggio dettagliato. Continua l'esecuzione.
ESEMPI
Questi esempi illustrano l'effetto dei diversi valori di $VerbosePreference e l'uso del parametro comune Verbose per eseguire l'override del valore di preferenza.
Questo esempio mostra l'effetto del valore predefinito SilentlyContinue.
PS> $VerbosePreference # Find the current value.
SilentlyContinue
PS> Write-Verbose "Verbose message test."
PS> # Write a verbose message.
# Message is not displayed.
PS> Write-Verbose "Verbose message test." -verbose
VERBOSE: Verbose message test.
# Use the Verbose parameter.
Questo esempio mostra l'effetto del valore Continue.
PS> $VerbosePreference = "Continue"
# Change the value to Continue.
PS> Write-Verbose "Verbose message test."
# Write a verbose message.
VERBOSE: Verbose message test.
# Message is displayed.
PS> Write-Verbose "Verbose message test." -verbose:$false
# Use the Verbose parameter with
a value of $false.
PS>
# Message is not displayed.
Questo esempio mostra l'effetto del valore Stop.
PS> $VerbosePreference = "Stop"
# Change the value to Stop.
PS> Write-Verbose "Verbose message test."
# Write a verbose message.
VERBOSE: Verbose message test.
Write-Verbose : Command execution stopped because the shell variable "VerbosePreference"
is set to Stop.
At line:1 char:14
+ Write-Verbose <<<< "Verbose message test."
PS> Write-Verbose "Verbose message test." -verbose:$false
# Use the Verbose parameter with
a value of $false
PS>
# Message is not displayed.
Questo esempio mostra l'effetto del valore Inquire.
PS> $VerbosePreference = "Inquire"
# Change the value to Inquire.
PS> Write-Verbose "Verbose message test."
VERBOSE: Verbose message test.
# Write a verbose message.
Confirm
Continue with this operation?
[Y] Yes [A] Yes to All [H] Halt Command [S] Suspend [?] Help (default is "Y"): y
PS>
PS> Write-Verbose "Verbose message test." -verbose:$false
# Use the Verbose parameter.
PS>
# Message is not displayed.
$WarningPreference
------------------
Determina la risposta di Windows PowerShell ai messaggi di avviso generati da uno script, cmdlet o provider, come i messaggi generati dal cmdlet Write-Warning.
Per impostazione predefinita, i messaggi di avviso non vengono visualizzati e l'esecuzione prosegue, ma è possibile modificare questo comportamento cambiando il valore di $WarningPreference.
Si può anche usare il parametro comune WarningAction di un cmdlet per determinare la risposta di Windows PowerShell agli avvisi da un determinato comando. Per altre informazioni, digitare: "get-help about_commonparameters".
Valori validi:
Stop: visualizza il messaggio di avviso e un messaggio di errore, quindi arresta l'esecuzione.
Inquire: Visualizza il messaggio di avviso e chiede all'utente l'autorizzazione per proseguire.
Continue (impostazione predefinita): visualizza il messaggio di avviso e prosegue con l'esecuzione.
SilentlyContinue: non visualizza il messaggio di avviso. Continua l'esecuzione.
ESEMPI
Questi esempi illustrano l'effetto dei diversi valori di $WarningPreference e l'uso del parametro comune WarningAction per eseguire l'override del valore di preferenza.
Questo esempio mostra l'effetto del valore predefinito Continue.
PS> $WarningPreference # Find the current value.
Continue
# Write a warning message.
PS> Write-Warning "This action can delete data."
WARNING: This action can delete data.
# Use the WarningAction parameter to
# suppress the warning for this command
PS> Write-Warning "This action can delete data." -warningaction silentlycontinue
Questo esempio mostra l'effetto del valore SilentlyContinue.
PS> $WarningPreference = "SilentlyContinue"
# Change the value to SilentlyContinue.
PS> Write-Warning "This action can delete data."
PS> # Write a warning message.
PS> Write-Warning "This action can delete data." -warningaction stop
# Use the WarningAction parameter to stop
# processing when this command generates a
# warning.
WARNING: This action can delete data.
Write-Warning : Command execution stopped because the shell variable
"WarningPreference" is set to Stop.
At line:1 char:14
+ Write-Warning <<<< "This action can delete data." -warningaction stop
Questo esempio mostra l'effetto del valore Inquire.
PS> $WarningPreference = "Inquire"
# Change the value to Inquire.
PS> Write-Warning "This action can delete data."
# Write a warning message.
WARNING: This action can delete data.
Confirm
Continue with this operation?
[Y] Yes [A] Yes to All [H] Halt Command [S] Suspend [?] Help (default is "Y"): y
PS>
PS> Write-Warning "This action can delete data." -warningaction silentlycontinue
PS> # Use the WarningAction parameter to change the
# response to a warning for the current command.
Questo esempio mostra l'effetto del valore Stop.
PS> $WarningPreference = "Stop"
# Change the value to Stop.
PS> Write-Warning "This action can delete data."
# Write a warning message.
WARNING: This action can delete data.
Write-Warning : Command execution stopped because the shell variable
"WarningPreference" is set to Stop.
At line:1 char:14
+ Write-Warning <<<< "This action can delete data."
PS> Write-Warning "This action can delete data." -warningaction inquire
WARNING: This action can delete data.
Confirm
Continue with this operation?
[Y] Yes [A] Yes to All [H] Halt Command [S] Suspend [?] Help (default is "Y"):
# Use the WarningAction parameter to change the
# response to a warning for the current command.
$WhatIfPreference
------------------
Determina se WhatIf è abilitato automaticamente per ogni comando che lo supporta. Quando WhatIf è abilitato, il cmdlet segnala l'effetto previsto del comando, ma non esegue il comando.
Valori validi:
0 (impostazione predefinita): WhatIf non è abilitato automaticamente. Per abilitarlo manualmente, usare il parametro WhatIf del comando.
1: WhatIf è abilitato automaticamente per ogni comando che lo supporta. Gli utenti possono usare il comando WhatIf con valore False per disabilitarlo manualmente (WhatIf:$false).
SPIEGAZIONE DETTAGLIATA
Quando un cmdlet supporta WhatIf, il cmdlet segnala l'effetto previsto del comando, invece di eseguire il comando. Ad esempio, invece di eliminare il file test.txt in risposta a un comando Remove-Item, Windows PowerShell segnala ciò che eliminerebbe. Un successivo comando Get-Childitem conferma che il file non è stato eliminato.
PS> remove-item test.txt
What if: Performing operation "Remove-Item" on Target "Item:
C:\test.txt
PS> get-childitem test.txt
Directory: Microsoft.PowerShell.Core\FileSystem::C:
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a--- 7/29/2006 7:15 PM 84 test.txt
ESEMPI
Questi esempi mostrano l'effetto dei valori di $WhatIfPreference. Mostrano anche come usare il parametro del cmdlet WhatIf per eseguire l'override del valore di preferenza per un determinato comando.
Questo esempio mostra l'effetto del valore predefinito 0 (non abilitato).
PS> $whatifpreference
0 # Check the current value.
PS> get-childitem test.txt | format-list FullName
FullName : C:\test.txt
# Verify that the file exists.
PS> remove-item test.txt
PS> # Delete the file.
PS> get-childitem test.txt | format-list -property FullName
# Verify that the file is deleted.
Get-ChildItem : Cannot find path 'C:\test.txt' because it does not exist.
At line:1 char:14
+ get-childitem <<<< test.txt | format-list fullname
Questo esempio mostra l'effetto dell'uso del parametro WhatIf quando il valore di $WhatIfPreference è 0.
PS> get-childitem test2.txt | format-list -property FullName
FullName : C:\test2.txt
# Verify that the file exists.
PS> remove-item test2.txt -whatif
What if: Performing operation "Remove File" on Target "C:\test2.txt".
# Use the WhatIf parameter
PS> get-childitem test2.txt | format-list -property FullName
FullName : C:\test2.txt
# Verify that the file was not deleted
Questo esempio mostra l'effetto del valore 1 (WhatIf abilitato). Quando si usa Remove-Item per eliminare un cmdlet, Remove-Item visualizza il percorso del file che eliminerebbe, ma non elimina il file.
PS> $whatifpreference = 1
PS> $whatifpreference
1 # Change the value.
PS> remove-item test.txt
What if: Performing operation "Remove File" on Target "C:\test.txt".
# Try to delete a file.
PS> get-childitem test.txt | format-list FullName
FullName : C:\test.txt
# Verify that the file exists.
Questo esempio mostra come eliminare un file quando il valore di $WhatIfPreference è 1. Usa il parametro WhatIf con valore $false.
PS> remove-item test.txt -whatif:$false
# Use the WhatIf parameter with $false.
Questo esempio dimostra che alcuni cmdlet supportano il comportamento WhatIf e altri no. In questo esempio, in cui il valore di $WhatIfPreference è 1 (abilitato), viene eseguito un comando Get-Process che non supporta WhatIf, ma il comportamento di WhatIf viene eseguito da un comando Stop-Process. È possibile eseguire l'override del comportamento WhatIf del comando Stop-Process usando il parametro WhatIf con valore $false.
PS> $whatifpreference = 1
# Change the value to 1.
PS> get-process winword
# A Get-Process command completes.
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
234 8 6324 15060 154 0.36 2312 WINWORD
PS> stop-process -name winword
What if: Performing operation "Stop-Process" on Target "WINWORD (2312)".
# A Stop-Process command uses WhatIf.
PS> stop-process -name winword -whatif:$false
PS> # WhatIf:$false overrides the preference.
PS> get-process winword
Get-Process : Cannot find a process with the name 'winword'. Verify the process name
and call the cmdlet again.
At line:1 char:12
+ get-process <<<< winword
# Verify that the process is stopped.
VEDERE ANCHE
about_Automatic_Variables
about_CommonParameters
about_Environment_Variables
about_Profiles
about_Remote about_Scopes