Kapitel 9: Funktionen

PowerShell-Einzeiler und Skripte, die oft geändert werden müssen, sind gute Kandidaten, um sie in wiederverwendbare Funktionen umzuwandeln.

Schreiben Sie nach Möglichkeit Funktionen, da sie werkzeugorientiert sind. Sie können die Funktionen einem Skriptmodul hinzufügen, dieses Modul an einem im $env:PSModulePath definierten Speicherort ablegen und die Funktionen aufrufen, ohne nach ihrem Speicherort suchen zu müssen. Mithilfe des PowerShellGet-Moduls können Sie Ihre PowerShell-Module ganz einfach in einem NuGet-Repository freigeben. PowerShellGet ist im Lieferumfang von PowerShell Version 5.0 und höher enthalten. Das Modul steht auch als separater Download für PowerShell Version 3.0 und höher zur Verfügung.

Machen Sie die Dinge nicht komplizierter als nötig. Halten Sie es unkompliziert, und verwenden Sie die einfachste Methode zum Ausführen einer Aufgabe. Vermeiden Sie Aliase und Positionsparameter in Code, den Sie wiederverwenden möchten. Formatieren Sie Ihren Code für bessere Lesbarkeit. Keine Hartcodierung von Parametern, verwenden Sie Parameter und Variablen. Schreiben Sie keinen unnötigen Code, auch wenn es keinen Schaden anrichtet. Es erhöht die Komplexität unnötigerweise. Details sind beim Schreiben von PowerShell-Code von großer Bedeutung.

Benennung

Wenn Sie Ihre Funktionen in PowerShell benennen, verwenden Sie einen Namen in Pascal-Schreibweise mit einem genehmigten Verb und einem Nomen im Singular. Führen Sie Get-Verb aus, um in PowerShell eine Liste der genehmigten Verben abzurufen. Im folgenden Beispiel werden die Ergebnisse von Get-Verb nach der Verb-Eigenschaft sortiert.

Get-Verb | Sort-Object -Property Verb

Die Group Eigenschaft gibt Ihnen eine Vorstellung davon, wie die Verben verwendet werden sollen.

Verb        Group
----        -----
Add         Common
Approve     Lifecycle
Assert      Lifecycle
Backup      Data
Block       Security
Checkpoint  Data
Clear       Common
Close       Common
Compare     Data
Complete    Lifecycle
Compress    Data
Confirm     Lifecycle
Connect     Communications
Convert     Data
ConvertFrom Data
ConvertTo   Data
Copy        Common
Debug       Diagnostic
Deny        Lifecycle
Disable     Lifecycle
Disconnect  Communications
Dismount    Data
Edit        Data
Enable      Lifecycle
Enter       Common
Exit        Common
Expand      Data
Export      Data
Find        Common
Format      Common
Get         Common
Grant       Security
Group       Data
Hide        Common
Import      Data
Initialize  Data
Install     Lifecycle
Invoke      Lifecycle
Join        Common
Limit       Data
Lock        Common
Measure     Diagnostic
Merge       Data
Mount       Data
Move        Common
New         Common
Open        Common
Optimize    Common
Out         Data
Ping        Diagnostic
Pop         Common
Protect     Security
Publish     Data
Push        Common
Read        Communications
Receive     Communications
Redo        Common
Register    Lifecycle
Remove      Common
Rename      Common
Repair      Diagnostic
Request     Lifecycle
Reset       Common
Resize      Common
Resolve     Diagnostic
Restart     Lifecycle
Restore     Data
Resume      Lifecycle
Revoke      Security
Save        Data
Search      Common
Select      Common
Send        Communications
Set         Common
Show        Common
Skip        Common
Split       Common
Start       Lifecycle
Step        Common
Stop        Lifecycle
Submit      Lifecycle
Suspend     Lifecycle
Switch      Common
Sync        Data
Test        Diagnostic
Trace       Diagnostic
Unblock     Security
Undo        Common
Uninstall   Lifecycle
Unlock      Common
Unprotect   Security
Unpublish   Data
Unregister  Lifecycle
Update      Data
Use         Other
Wait        Lifecycle
Watch       Common
Write       Communications

Es ist wichtig, dass Ihre PowerShell-Funktionen ein genehmigtes Verb verwenden. Module, die Funktionen mit nicht genehmigten Verben enthalten, generieren eine Warnmeldung, wenn sie in eine PowerShell-Sitzung importiert werden. Eine solche Warnmeldung lässt ihre Funktionen unprofessionell aussehen. Nicht genehmigte Verben schränken außerdem die Auffindbarkeit ihrer Funktionen ein.

Eine einfache Funktion

Eine Funktion in PowerShell wird mit dem Schlüsselwort „function“ gefolgt vom Funktionsnamen deklariert sowie mit einer anschließenden öffnenden und einer schließenden geschweiften Klammer ({ }). Der von der Funktion ausgeführte Code steht in diesen geschweiften Klammern.

function Get-Version {
    $PSVersionTable.PSVersion
}

Die im folgenden Beispiel gezeigte Funktion ist ein einfaches Beispiel, das die PowerShell-Version zurückgibt.

Get-Version

Major  Minor  Build  Revision
-----  -----  -----  --------
5      1      14393  693

Wenn Sie einen generischen Namen für Ihre Funktionen verwenden (z. B. Get-Version) kann dies zu Namenskonflikten führen. Es kann ein Konflikt mit Standardbefehlen auftreten, die im Laufe der Zeit hinzugefügt werden, oder mit Befehlen, die andere Personen schreiben. Präfixen Sie den Substantivteil Ihrer Funktionsnamen, um Namenskonflikte zu vermeiden. Beispiel: <ApprovedVerb>-<Prefix><SingularNoun>.

Im folgenden Beispiel wird das Präfixelement PS verwendet.

function Get-PSVersion {
    $PSVersionTable.PSVersion
}

Mit Ausnahme des Namens ist diese Funktion mit der vorherigen identisch.

Get-PSVersion

Major  Minor  Build  Revision
-----  -----  -----  --------
5      1      14393  693

Ein Namenskonflikt kann jedoch auch dann auftreten, wenn Sie dem Nomen ein Präfix hinzufügen. Ich stelle meinen Funktionsnomen gerne meine Initialen als Präfix voran. Entwickeln Sie einen Standard, und halten Sie ihn ein.

function Get-MrPSVersion {
    $PSVersionTable.PSVersion
}

Diese Funktion unterscheidet sich nur darin von den beiden vorherigen Funktionen, dass sie einen eindeutigeren Namen verwendet, um Namenskonflikte mit anderen PowerShell-Befehlen zu vermeiden.

Get-MrPSVersion

Major  Minor  Build  Revision
-----  -----  -----  --------
5      1      14393  693

Nachdem Sie in den Arbeitsspeicher geladen wurde, können Sie Funktionen auf dem PSDrive Function sehen.

Get-ChildItem -Path Function:\Get-*Version

CommandType     Name                                               Version
-----------     ----                                               -------
Function        Get-Version
Function        Get-PSVersion
Function        Get-MrPSVersion

Wenn Sie diese Funktionen aus Ihrer aktuellen Sitzung entfernen möchten, müssen Sie sie aus dem PSDrive Function entfernen oder PowerShell schließen und erneut öffnen.

Get-ChildItem -Path Function:\Get-*Version | Remove-Item

Vergewissern Sie sich, dass die Funktionen tatsächlich entfernt wurden.

Get-ChildItem -Path Function:\Get-*Version

Wenn die Funktionen als Teil eines Moduls geladen wurden, können Sie das Modul entladen, um sie zu entfernen.

Remove-Module -Name <ModuleName>

Das Cmdlet Remove-Module entfernt PowerShell-Module in Ihrer aktuellen PowerShell-Sitzung aus dem Arbeitsspeicher. Es entfernt sie nicht aus Ihrem System oder von Ihrem Datenträger.

Parameter

Weisen Sie Werte nicht statisch zu. Verwenden Sie stattdessen Parameter und Variablen. Verwenden Sie beim Benennen der Parameter nach Möglichkeit dieselben Namen wie die Standard-Cmdlets für die Parameter.

In der folgenden Funktion habe ich ComputerName als Parameternamen verwendet und nicht Computer, ServerName oder Host. Mit ComputerName wird der Parametername standardisiert, sodass Name und Schreibweise den Standard-Cmdlets entsprechen.

function Test-MrParameter {

    param (
        $ComputerName
    )

    Write-Output $ComputerName

}

Die folgende Funktion fragt alle Befehle in Ihrem System ab und gibt die Anzahl mit den spezifischen Parameternamen zurück.

function Get-MrParameterCount {
    param (
        [string[]]$ParameterName
    )

    foreach ($Parameter in $ParameterName) {
        $Results = Get-Command -ParameterName $Parameter -ErrorAction SilentlyContinue

        [pscustomobject]@{
            ParameterName   = $Parameter
            NumberOfCmdlets = $Results.Count
        }
    }
}

Wie Sie in den folgenden Ergebnissen sehen können, gibt es 39 Befehle mit einem Parameter ComputerName. Es gibt keine Befehle mit Parametern wie Computer, ServerName, Host oder Machine.

Get-MrParameterCount -ParameterName ComputerName, Computer, ServerName,
    Host, Machine

ParameterName NumberOfCmdlets
------------- ---------------
ComputerName               39
Computer                    0
ServerName                  0
Host                        0
Machine                     0

Verwenden Sie die gleiche Groß-/Kleinschreibung für Ihre Parameternamen wie bei den Standard-Cmdlets. Verwenden Sie beispielsweise ComputerName, nicht computername. Dieses Benennungsschema hilft Personen, die mit PowerShell vertraut sind, Ihre Funktionen zu entdecken und diese in Aussehen und Verhalten den Standard-Cmdlets ähneln zu lassen.

Mithilfe der param-Anweisung können Sie einen oder mehrere Parameter definieren. Die Parameterdefinitionen werden durch ein Komma (,) getrennt. Weitere Informationen finden Sie unter about_Functions_Advanced_Parameters.

Erweiterte Funktionen

Das Umwandeln einer Funktion in eine erweiterte Funktion in PowerShell ist einfach. Einer der Unterschiede zwischen einer Funktion und einer erweiterten Funktion besteht darin, dass erweiterte Funktionen über allgemeine Parameter verfügen, die automatisch hinzugefügt werden. Zu den allgemeinen Parametern zählen Parameter wie Verbose und Debug.

Beginnen Sie mit der Test-MrParameter-Funktion, die im vorherigen Abschnitt verwendet wurde.

function Test-MrParameter {

    param (
        $ComputerName
    )

    Write-Output $ComputerName

}

Es gibt eine Reihe unterschiedlicher Möglichkeiten, um die allgemeinen Parameter anzuzeigen. Eine Möglichkeit besteht darin, die Syntax mit Get-Commandanzuzeigen.

Get-Command -Name Test-MrParameter -Syntax

Beachten Sie, dass die Test-MrParameter-Funktion keine allgemeinen Parameter aufweist.

Test-MrParameter [[-ComputerName] <Object>]

Eine weitere Möglichkeit besteht darin, mit Get-Command Detailinformationen zu den Parametereigenschaften anzuzeigen.

(Get-Command -Name Test-MrParameter).Parameters.Keys

ComputerName

Fügen Sie das CmdletBinding-Attribut hinzu, um die Funktion in eine erweiterte Funktion umzuwandeln.

function Test-MrCmdletBinding {

    [CmdletBinding()] # Turns a regular function into an advanced function
    param (
        $ComputerName
    )

    Write-Output $ComputerName

}

Wenn Sie CmdletBinding angeben, werden die allgemeinen Parameter automatisch hinzugefügt. CmdletBinding erfordert einen param-Block, dieser param-Block kann jedoch leer sein.

Get-Command -Name Test-MrCmdletBinding -Syntax

Test-MrCmdletBinding [[-ComputerName] <Object>] [<CommonParameters>]

Durch das genaue Untersuchen der Parametereigenschaft von Get-Command werden die tatsächlichen Parameternamen angezeigt, einschließlich der häufig verwendeten.

(Get-Command -Name Test-MrCmdletBinding).Parameters.Keys

ComputerName
Verbose
Debug
ErrorAction
WarningAction
InformationAction
ErrorVariable
WarningVariable
InformationVariable
OutVariable
OutBuffer
PipelineVariable

SupportsShouldProcess

Das Attribut SupportsShouldProcess fügt die Parameter WhatIf und Confirm zur Risikominderung hinzu. Diese Parameter sind nur für Befehle erforderlich, die Änderungen vornehmen.

function Test-MrSupportsShouldProcess {

    [CmdletBinding(SupportsShouldProcess)]
    param (
        $ComputerName
    )

    Write-Output $ComputerName

}

Beachten Sie, dass nun die Parameter WhatIf und Confirm vorhanden sind.

Get-Command -Name Test-MrSupportsShouldProcess -Syntax

Test-MrSupportsShouldProcess [[-ComputerName] <Object>] [-WhatIf] [-Confirm]
[<CommonParameters>]

Auch hier können Sie mit Get-Command eine Liste der tatsächlichen Parameternamen zurückgeben, einschließlich der allgemeinen Parameternamen sowie WhatIf und Confirm.

(Get-Command -Name Test-MrSupportsShouldProcess).Parameters.Keys

ComputerName
Verbose
Debug
ErrorAction
WarningAction
InformationAction
ErrorVariable
WarningVariable
InformationVariable
OutVariable
OutBuffer
PipelineVariable
WhatIf
Confirm

-Parametervalidierung

Überprüfen Sie Eingaben frühzeitig. Lassen Sie die Fortsetzung Ihres Codes auf einem Pfad nicht zu, wenn er nicht ohne gültige Eingabe abgeschlossen werden kann.

Geben Sie für die Variablen, die für Parameter verwendet werden, immer einen Datentyp an. Im folgenden Beispiel wird String als Datentyp für den Parameter ComputerName angegeben. Aufgrund dieser Überprüfung kann für den Parameter ComputerName nur ein einzelner Computername angegeben werden.

function Test-MrParameterValidation {

    [CmdletBinding()]
    param (
        [string]$ComputerName
    )

    Write-Output $ComputerName

}

Werden mehrere Computernamen angegeben, wird ein Fehler generiert.

Test-MrParameterValidation -ComputerName Server01, Server02

Test-MrParameterValidation : Cannot process argument transformation on
parameter 'ComputerName'. Cannot convert value to type System.String.
At line:1 char:42
+ Test-MrParameterValidation -ComputerName Server01, Server02
+                                          ~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidData: (:) [Test-MrParameterValidation]
   , ParameterBindingArgumentTransformationException
    + FullyQualifiedErrorId : ParameterArgumentTransformationError,Test-MrP
   arameterValidation

Das Problem bei der aktuellen Definition besteht darin, dass es zulässig ist, den Wert des Parameters ComputerName auszulassen, wobei aber ein Wert erforderlich ist, damit die Funktion erfolgreich abgeschlossen werden kann. In diesem Szenario ist das Parameterattribut Mandatory nützlich.

Die im folgenden Beispiel verwendete Syntax ist kompatibel mit PowerShell Version 3.0 und höher. [Parameter(Mandatory=$true)] könnte angegeben werden, damit die Funktion mit PowerShell Version 2.0 und höher kompatibel ist.

function Test-MrParameterValidation {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory)]
        [string]$ComputerName
    )

    Write-Output $ComputerName

}

Da der ComputerName jetzt erforderlich ist, fordert die Funktion einen solchen an, wenn keiner angegeben ist.

Test-MrParameterValidation

cmdlet Test-MrParameterValidation at command pipeline position 1
Supply values for the following parameters:
ComputerName:

Wenn Sie mehr als einen Wert für den Parameter ComputerName zulassen möchten, verwenden Sie den Datentyp String, aber fügen Sie dem Datentyp eckige Klammern ([]) hinzu, um die Angabe eines Arrays von Zeichenfolgen zu ermöglichen.

function Test-MrParameterValidation {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory)]
        [string[]]$ComputerName
    )

    Write-Output $ComputerName

}

Möglicherweise möchten Sie einen Standardwert für den Parameter ComputerName angeben, wenn kein Wert angegeben wird. Das Problem hierbei ist, dass Standardwerte nicht mit obligatorischen Parametern verwendet werden können. Verwenden Sie stattdessen das Parameterüberprüfungsattribut ValidateNotNullOrEmpty mit einem Standardwert.

Selbst wenn Sie einen Standardwert festlegen, versuchen Sie, keine statischen Werte zu verwenden. Im folgenden Beispiel wird $env:COMPUTERNAME als Standardwert verwendet, der automatisch in den Namen des lokalen Computers übersetzt wird, wenn kein Wert angegeben ist.

function Test-MrParameterValidation {

    [CmdletBinding()]
    param (
        [ValidateNotNullOrEmpty()]
        [string[]]$ComputerName = $env:COMPUTERNAME
    )

    Write-Output $ComputerName

}

Ausführliche Ausgabe

Inlinekommentare sind nützlich, wenn Sie komplexen Code schreiben, die Benutzer sehen sie jedoch nur dann, wenn sie sich den Code ansehen.

Die Funktion im folgenden Beispiel hat einen Inlinekommentar in der foreach-Schleife. Dieser spezielle Kommentar ist nicht schwer zu finden, aber stellen Sie sich vor, die Funktion würde Hunderte von Codezeilen enthalten.

function Test-MrVerboseOutput {

    [CmdletBinding()]
    param (
        [ValidateNotNullOrEmpty()]
        [string[]]$ComputerName = $env:COMPUTERNAME
    )

    foreach ($Computer in $ComputerName) {
        #Attempting to perform an action on $Computer <<-- Don't use
        #inline comments like this, use write verbose instead.
        Write-Output $Computer
    }

}

Eine bessere Option ist die Verwendung von Write-Verbose anstelle von Inlinekommentaren.

function Test-MrVerboseOutput {

    [CmdletBinding()]
    param (
        [ValidateNotNullOrEmpty()]
        [string[]]$ComputerName = $env:COMPUTERNAME
    )

    foreach ($Computer in $ComputerName) {
        Write-Verbose -Message "Attempting to perform an action on $Computer"
        Write-Output $Computer
    }

}

Die ausführliche Ausgabe wird beim Aufruf der Funktion ohne Verbose-Parameter nicht angezeigt.

Test-MrVerboseOutput -ComputerName Server01, Server02

Die ausführliche Ausgabe wird angezeigt, wenn die Funktion mit dem Verbose-Parameter aufgerufen wird.

Test-MrVerboseOutput -ComputerName Server01, Server02 -Verbose

Pipelineeingabe

Wenn Ihre Funktion Pipelineeingaben akzeptieren soll, ist zusätzlicher Code erforderlich. Wie bereits in diesem Buch erwähnt, können Befehle Pipelineeingaben als Wert (als Typ) oder als Eigenschaftsname akzeptieren. Sie können Ihre Funktionen wie die nativen Befehle schreiben, sodass sie entweder einen oder beide dieser Eingabetypen akzeptieren.

Um die Pipelineeingabe als Wert zu akzeptieren, geben Sie das ValueFromPipeline-Parameterattribut für diesen bestimmten Parameter an. Sie können Pipelineeingaben als Wert nur von einem Parameter jedes Datentyps akzeptieren. Bei zwei Parametern, die Zeichenfolgeneingaben akzeptieren, kann nur einer von beiden Pipelineeingaben als Wert akzeptieren. Wenn Sie beide Zeichenfolgenparameter als Wert angegeben hätten, wäre nicht klar, an welchen Parameter die Eingabe gebunden ist. Dieses Szenario ist ein weiterer Grund, warum ich diese Art der Pipelineeingabe nach Typ anstelle von nach Wertnenne.

Pipelineeingaben gehen jeweils einzeln ein, etwa so wie Elemente in einer foreach-Schleife behandelt werden. Wenn Ihre Funktion ein Array als Eingabe akzeptiert, ist ein process-Block erforderlich, um jedes Element zu verarbeiten. Falls Ihre Funktion nur einen einzelnen Wert als Eingabe akzeptiert, ist ein process-Block nicht notwendig, wird aber aus Konsistenzgründen empfohlen.

function Test-MrPipelineInput {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipeline)]
        [string[]]$ComputerName
    )

    process {
        Write-Output $ComputerName
    }

}

Das Akzeptieren von Pipelineeingaben als Eigenschaftsname erfolgt auf ähnliche Weise, außer dass Sie dazu noch das ValueFromPipelineByPropertyName-Parameterattribut angeben und dass die Angabe unabhängig vom Datentyp für eine beliebige Anzahl von Parametern möglich ist. Der entscheidende Punkt ist, dass die Ausgabe des weitergeleiteten Befehls über einen Eigenschaftsnamen verfügen muss, der dem Namen des Parameters oder einem Parameteralias Ihrer Funktion entspricht.

function Test-MrPipelineInput {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipelineByPropertyName)]
        [string[]]$ComputerName
    )

    process {
            Write-Output $ComputerName
    }

}

begin- und end-Blöcke sind optional. begin wird vor dem process-Block angegeben und wird verwendet, um anfängliche Arbeiten durchzuführen, bevor die Elemente von der Pipeline empfangen werden. Auf Werte, die als Eingabe weitergereicht werden, kann im begin-Block nicht zugegriffen werden. Der end-Block wird nach dem process-Block angegeben und wird für die Bereinigung verwendet, nachdem alle eingeleiteten Elemente verarbeitet wurden.

Fehlerbehandlung

Die im folgenden Beispiel gezeigte Funktion generiert eine nicht behandelte Ausnahme, wenn ein Computer nicht kontaktiert werden kann.

function Test-MrErrorHandling {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipeline,
                   ValueFromPipelineByPropertyName)]
        [string[]]$ComputerName
    )

    process {
        foreach ($Computer in $ComputerName) {
            Test-WSMan -ComputerName $Computer
        }
    }

}

Es gibt eine Reihe unterschiedlicher Methoden, um Fehler in PowerShell zu behandeln. Try/Catch ist die modernere Methode zum Behandeln von Fehlern.

function Test-MrErrorHandling {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipeline,
                   ValueFromPipelineByPropertyName)]
        [string[]]$ComputerName
    )

    process {
        foreach ($Computer in $ComputerName) {
            try {
                Test-WSMan -ComputerName $Computer
            }
            catch {
                Write-Warning -Message "Unable to connect to Computer: $Computer"
            }
        }
    }

}

Obwohl die im vorherigen Beispiel gezeigte Funktion eine Fehlerbehandlung verwendet, generiert sie einen Ausnahmefehler, weil der Befehl keinen Fehler mit Abbruch generiert. Nur Fehler mit Abbruch können abgefangen werden. Geben Sie den ErrorAction Parameter mit Stop als Wert an, um einen nicht-terminierenden Fehler in einen terminierenden Fehler umzuwandeln.

function Test-MrErrorHandling {

    [CmdletBinding()]
    param (
        [Parameter(Mandatory,
                   ValueFromPipeline,
                   ValueFromPipelineByPropertyName)]
        [string[]]$ComputerName
    )

    process {
        foreach ($Computer in $ComputerName) {
            try {
                Test-WSMan -ComputerName $Computer -ErrorAction Stop
            }
            catch {
                Write-Warning -Message "Unable to connect to Computer: $Computer"
            }
        }
    }

}

Ändern Sie die globale Variable $ErrorActionPreference nur, wenn dies unbedingt erforderlich ist. Wenn Sie sie in einem lokalen Bereich ändern, wird sie auf den vorherigen Wert zurückgesetzt, wenn Sie diesen Bereich verlassen.

Wenn Sie Tools wie .NET direkt in Ihrer PowerShell-Funktion verwenden, können Sie den Parameter ErrorAction nicht mit dem Befehl selbst angeben. Sie können die $ErrorActionPreference-Variable direkt vor dem Aufrufen der .NET-Methode ändern.

Kommentarbasierte Hilfe

Das Hinzufügen einer Hilfe zu den Funktionen gilt als bewährte Methode. In der Hilfe erfahren Benutzer, mit denen Sie Ihre Funktionen teilen, wie sie diese verwenden können.

function Get-MrAutoStoppedService {

<#
.SYNOPSIS
    Returns a list of services that are set to start automatically, are not
    currently running, excluding the services that are set to delayed start.

.DESCRIPTION
    Get-MrAutoStoppedService is a function that returns a list of services
    from the specified remote computer(s) that are set to start
    automatically, are not currently running, and it excludes the services
    that are set to start automatically with a delayed startup.

.PARAMETER ComputerName
    The remote computer(s) to check the status of the services on.

.PARAMETER Credential
    Specifies a user account that has permission to perform this action. The
    default is the current user.

.EXAMPLE
     Get-MrAutoStoppedService -ComputerName 'Server1', 'Server2'

.EXAMPLE
     'Server1', 'Server2' | Get-MrAutoStoppedService

.EXAMPLE
     Get-MrAutoStoppedService -ComputerName 'Server1' -Credential (Get-Credential)

.INPUTS
    String

.OUTPUTS
    PSCustomObject

.NOTES
    Author:  Mike F. Robbins
    Website: https://mikefrobbins.com
    Twitter: @mikefrobbins
#>

    [CmdletBinding()]
    param (

    )

    #Function Body

}

Wenn Sie Ihren Funktionen kommentarbasierte Hilfe hinzufügen, können Sie Hilfe dafür wie bei den standardmäßigen integrierten Befehlen abrufen.

Die gesamte Syntax zum Schreiben einer Funktion in PowerShell kann für jemanden, der gerade anfängt, überwältigend erscheinen. Wenn Sie sich die Syntax für etwas nicht merken können, öffnen Sie auf einem anderen Monitor eine zweite Instanz der PowerShell Integrated Scripting Environment (ISE), und zeigen Sie das Codeschnipsel „Cmdlet (erweiterte Funktion) - Complete“ an, während Sie den Code für Ihre Funktionen eingeben. Auf Codeschnipsel können Sie in der PowerShell ISE mithilfe der Tastenkombination STRG + J zugreifen.

Zusammenfassung

In diesem Kapitel haben Sie die Grundlagen des Schreibens von Funktionen in PowerShell kennengelernt, darunter:

• Erstellen erweiterter Funktionen
• Verwenden der Parameterüberprüfung
• Verwendung der ausführlichen Ausgabe
• Unterstützung der Pipelineeingabe
• Behandeln von Fehlern
• Kommentarbasierten Hilfe erstellen

Überprüfung

1. Wie erhalten Sie eine Liste der genehmigten Verben in PowerShell?
2. Wie wandeln Sie eine PowerShell-Funktion in eine erweiterte Funktion um?
3. Wann sollten die Parameter WhatIf und Confirm zu Ihren PowerShell-Funktionen hinzugefügt werden?
4. Wie wandeln Sie einen Fehler ohne Abbruch in einen Fehler mit Abbruch um?
5. Warum sollten Sie Ihren Funktionen eine kommentarbasierte Hilfe hinzufügen?

Verweise

• about_Functions
• über_Funktionen_Erweiterte_Parameter
• über_GemeinsameParameter
• about_Functions_CmdletBindingAttribute (Informationen zu Funktionen und dem CmdletBinding-Attribut)
• about_Functions_Advanced
• über_Versuchen_Fangen_Finale
• Über kommentarbasierte Hilfe
• Video: PowerShell Toolmaking with Advanced Functions and Script Modules (PowerShell-Toolerstellung mit erweiterten Funktionen und Skriptmodulen)