about_Methods

  • Articolo

Descrizione breve

Descrive come usare i metodi per eseguire azioni sugli oggetti in PowerShell.

Descrizione lunga

PowerShell usa oggetti per rappresentare gli elementi negli archivi dati o lo stato del computer. Ad esempio, gli oggetti FileInfo rappresentano i file nelle unità del file system e gli oggetti ProcessInfo rappresentano i processi nel computer.

Gli oggetti hanno proprietà, che archivia i dati relativi all'oggetto e i metodi che consentono di modificare l'oggetto.

Un "metodo" è un set di istruzioni che specificano un'azione che è possibile eseguire sull'oggetto. Ad esempio, l'oggetto FileInfo include il CopyTo metodo che copia il file rappresentato dall'oggetto FileInfo .

Per ottenere i metodi di qualsiasi oggetto, usare il Get-Member cmdlet . Utilizzare la proprietà MemberType con il valore "Method". Il comando seguente ottiene i metodi degli oggetti di elaborazione.

Get-Process | Get-Member -MemberType Method

TypeName: System.Diagnostics.Process

Name                      MemberType Definition
----                      ---------- ----------
BeginErrorReadLine        Method     System.Void BeginErrorReadLine()
BeginOutputReadLine       Method     System.Void BeginOutputReadLine()
...
Kill                      Method     System.Void Kill()
Refresh                   Method     System.Void Refresh()
Start                     Method     bool Start()
ToString                  Method     string ToString()
WaitForExit               Method     bool WaitForExit(int milliseconds), ...
WaitForInputIdle          Method     bool WaitForInputIdle(int millisecon...

Per eseguire o "richiamare" un metodo di un oggetto, digitare un punto (.), il nome del metodo e un set di parentesi "()". Se il metodo contiene argomenti, inserire i valori dell'argomento tra parentesi. Le parentesi sono necessarie per ogni chiamata al metodo, anche se non sono presenti argomenti. Se il metodo accetta più argomenti, devono essere separati da virgole.

Ad esempio, il comando seguente richiama il metodo Kill dei processi per terminare il processo di Blocco note nel computer.

$notepad = Get-Process notepad
$notepad.Kill()

Questo esempio può essere abbreviato combinando le istruzioni precedenti.

(Get-Process Notepad).Kill()

Il Get-Process comando è racchiuso tra parentesi per assicurarsi che venga eseguito prima che venga richiamato il metodo Kill. Il Kill metodo viene quindi richiamato sull'oggetto restituito Process .

Un altro metodo molto utile è il Replace metodo delle stringhe. Il Replace metodo sostituisce il testo all'interno di una stringa. Nell'esempio seguente, il punto (.) può essere posizionato immediatamente dopo la citazione finale della stringa.

'this is rocket science'.Replace('rocket', 'rock')

this is rock science

Come illustrato negli esempi precedenti, è possibile richiamare un metodo su un oggetto che si ottiene usando un comando, un oggetto in una variabile o qualsiasi elemento che restituisce un oggetto ,ad esempio una stringa tra virgolette.

A partire da PowerShell 4.0, la chiamata al metodo tramite nomi di metodo dinamici è supportata.

Informazioni sui metodi

Per trovare le definizioni dei metodi di un oggetto, passare all'argomento della Guida per il tipo di oggetto e cercare la relativa pagina dei metodi. Nella pagina seguente, ad esempio, vengono descritti i metodi degli oggetti process System.Diagnostics.Process.

Per determinare gli argomenti di un metodo, esaminare la definizione del metodo, simile al diagramma della sintassi di un cmdlet di PowerShell.

Una definizione di metodo può avere una o più firme di metodo, come i set di parametri dei cmdlet di PowerShell. Le firme mostrano tutti i formati validi dei comandi per richiamare il metodo .

Ad esempio, il CopyTo metodo della FileInfo classe contiene le due firme del metodo seguenti:

    CopyTo(String destFileName)
    CopyTo(String destFileName, Boolean overwrite)

La prima firma del metodo accetta il nome del file di destinazione (e un percorso). Nell'esempio seguente viene utilizzato il primo CopyTo metodo per copiare il Final.txt file nella C:\Bin directory .

(Get-ChildItem c:\final.txt).CopyTo("c:\bin\final.txt")

Nota

A differenza della modalità argomento di PowerShell, i metodi oggetto vengono eseguiti in modalità di espressione, ovvero un pass-through al framework .NET basato su PowerShell. In modalità espressione gli argomenti bareword (stringhe senza virgolette) non sono consentiti. È possibile osservare questa differenza quando si usa un percorso come parametro, rispetto al percorso come argomento. Altre informazioni sulle modalità di analisi sono disponibili in about_Parsing

La seconda firma del metodo accetta un nome di file di destinazione e un valore booleano che determina se il file di destinazione deve essere sovrascritto, se esiste già.

Nell'esempio seguente viene utilizzato il secondo CopyTo metodo per copiare il Final.txt file nella C:\Bin directory e per sovrascrivere i file esistenti.

(Get-ChildItem c:\final.txt).CopyTo("c:\bin\final.txt", $true)

Enumerazione member-access

A partire da PowerShell 3.0, quando si usa l'operatore di accesso ai membri (.) per accedere a un metodo che non esiste in una raccolta di elenchi, PowerShell enumera automaticamente gli elementi nella raccolta e richiama il metodo su ogni elemento. Per altre informazioni, vedere about_Member-Access_Enumeration.

Esempi

Nell'esempio seguente viene eseguito il metodo Kill di singoli oggetti processo in una raccolta di oggetti .

Il primo comando avvia tre istanze del processo di Blocco note. Get-Processottiene tutte e tre le istanze del processo di Blocco note e le salva nella $p variabile .

Notepad; Notepad; Notepad
$p = Get-Process Notepad
$p.Count

3

Il comando successivo esegue il metodo Kill in tutti e tre i processi nella $p variabile. Questo comando funziona anche se una raccolta di processi non dispone di un Kill metodo.

$p.Kill()
Get-Process Notepad

Il Get-Process comando conferma che il Kill metodo ha funzionato.

Get-Process : Cannot find a process with the name "notepad". Verify the proc
ess name and call the cmdlet again.
At line:1 char:12
+ Get-Process <<<<  notepad
    + CategoryInfo          : ObjectNotFound: (notepad:String) [Get-Process]
, ProcessCommandException
    + FullyQualifiedErrorId : NoProcessFoundForGivenName,Microsoft.PowerShel
l.Commands.GetProcessCommand

Questo esempio equivale funzionalmente all'uso del Foreach-Object cmdlet per eseguire il metodo su ogni oggetto dell'insieme.

$p | ForEach-Object {$_.Kill()}

Metodi ForEach e Where

A partire da PowerShell 4.0, è supportato il filtro delle raccolte usando una sintassi del metodo. Ciò consente l'uso di due nuovi metodi quando si gestiscono raccolte ForEach e Where.

Sono disponibili altre informazioni su questi metodi in about_arrays

Chiamata di un metodo specifico quando esistono più overload

Si consideri lo scenario seguente quando si chiamano i metodi .NET. Se un metodo accetta un oggetto ma ha un overload tramite un'interfaccia che accetta un tipo più specifico, PowerShell sceglie il metodo che accetta l'oggetto a meno che non venga eseguito in modo esplicito il cast a tale interfaccia.

Add-Type -TypeDefinition @'

   // Interface
   public interface IFoo {
     string Bar(int p);
   }

   // Type that implements the interface
   public class Foo : IFoo {

   // Direct member method named 'Bar'
   public string Bar(object p) { return $"object: {p}"; }

   // *Explicit* implementation of IFoo's 'Bar' method().
   string IFoo.Bar(int p) {
       return $"int: {p}";
   }

}
'@

In questo esempio è stato scelto l'overload meno specifico object del metodo Bar .

[Foo]::new().Bar(1)

object: 1

In questo esempio viene eseguito il cast del metodo all'interfaccia IFoo per selezionare l'overload più specifico del metodo Bar .

([IFoo] [Foo]::new()).Bar(1)

int: 1

Uso di metodi .NET che accettano percorsi del file system

PowerShell supporta più spazi di esecuzione per processo. Ogni spazio di esecuzione ha la propria directory corrente. Non corrisponde alla directory di lavoro del processo corrente: [System.Environment]::CurrentDirectory.

I metodi .NET usano la directory di lavoro del processo. I cmdlet di PowerShell usano il percorso runspace. Inoltre, i metodi .NET funzionano solo con i percorsi del file system nativo, non con gli oggetti Percorso di PowerShell. Per usare i percorsi di PowerShell con i metodi .NET, è necessario risolvere il percorso di un percorso nativo del file system prima di passarlo al metodo .NET.

Vedi anche