Wie man das CmdletBinding-Attribut in PowerShell verwendet

1. CmdletBinding Attribut in PowerShell
2. Verwenden Sie das CmdletBinding-Attribut mit dem Verbose-Parameter
3. Verwenden Sie das CmdletBinding-Attribut mit dem $PSCmdlet-Objekt und SupportsShouldProcess
4. Verwenden Sie das CmdletBinding-Attribut mit dem Parameter-Attribut, um die Funktionsparameter zu steuern

Das cmdlet ist ein leichtgewichtiges Skript, das eine einzelne Funktion innerhalb der PowerShell-Umgebung ausführt. Die cmdlets können in jeder .Net-Sprache geschrieben werden.

In der Regel wird ein cmdlet als Verb-Nomen-Paar ausgedrückt, um einen Befehl auszuführen. Der Befehl ist ein Auftrag an das zugrunde liegende Betriebssystem, einen bestimmten Dienst für den Endbenutzer auszuführen.

Die PowerShell-Umgebung umfasst mehr als 200 grundlegende cmdlets wie New-Item, Move-Item, Set-Location und Get-Location. Die cmdlet teilen sich einen gemeinsamen Satz von Funktionen, die in einfachen PowerShell-Funktionen nicht verfügbar sind.

1. Unterstützt allgemeine Parameter wie -WhatIf, ErrorAction, Verbose usw.
2. Fordert Bestätigungen an
3. Unterstützung für Pflichtparameter

CmdletBinding Attribut in PowerShell

Die einfache PowerShell-Funktion kann als erweiterte Funktion geschrieben werden, indem die oben diskutierten grundlegenden cmdlet-Funktionen vererbt werden. Das CmdletBinding-Attribut ermöglicht den Zugriff auf diese grundlegenden cmdlet-Funktionen.

Das folgende zeigt die CmdletBinding-Attribut-Syntax mit allen möglichen Argumenten.

{
    [CmdletBinding(ConfirmImpact = <String>,
        DefaultParameterSetName = <String>,
        HelpURI = <URI>,
        SupportsPaging = <Boolean>,
        SupportsShouldProcess = <Boolean>,
        PositionalBinding = <Boolean>)]

    Param ($myparam)
    Begin {}
    Process {}
    End {}
}

Angenommen, wir haben eine einfache PowerShell-Funktion namens Helloworld-To-UpperCase.

Function Helloworld-To-UpperCase {
    "helloworld".ToUpper();
}

Es sind keine Parameter an diese Funktion angehängt. Daher bezeichnet man dies als einfache PowerShell-Funktion.

Aber wir können das CmdletBinding-Attribut verwenden, um diese Funktion in eine erweiterte zu konvertieren und auf die grundlegenden cmdlet-Funktionen und Parameter zuzugreifen, wie im Folgenden dargestellt.

Function Helloworld-To-UpperCase {
    [CmdletBinding()]Param()
    "helloworld".ToUpper();
}

Wenn wir die obige Funktion mit dem -verbose-Parameter aufrufen, werden alle Write-Verbose-Strings im PowerShell-Fenster gedruckt.

HelloWorld-To-UpperCase -Verbose

Ausgabe:

Verwenden Sie das CmdletBinding-Attribut mit dem $PSCmdlet-Objekt und SupportsShouldProcess

Da wir das CmdletBinding-Attribut verwendet haben, kann unsere erweiterte Funktion problemlos auf das $PSCmdlet-Objekt zugreifen. Dieses Objekt enthält mehrere Methoden wie ShouldContinue, ShouldProcess, ToString, WriteDebug usw.

Verwenden Sie das CmdletBinding-Attribut mit der ShouldContinue-Methode

Diese Methode ermöglicht es den Benutzern, die Bestätigungsanforderungen zu bearbeiten. In der Zwischenzeit ist es zwingend erforderlich, das Argument SupportsShouldProcess auf $True zu setzen.

Die ShouldContinue-Methode hat mehrere überladene Methoden, und wir werden diejenige mit zwei Parametern verwenden.

Function Helloworld-To-UpperCase {
    [CmdletBinding(SupportsShouldProcess = $True)]Param()

    Write-Verbose "This is the common parameter usage -Version within our Helloworld-To-UpperCase function"

    if ($PSCmdlet.ShouldContinue("Are you sure on making the helloworld all caps?", "Making uppercase with ToUpper")) {
        "helloworld".ToUpper();
    }
    Else {
        "helloworld kept in lowercase."
    }
}

Wir können die Funktion mit dem -Confirm-Parameter aufrufen, und sie zeigt ein Bestätigungsfeld an, wie im Folgenden dargestellt.

HelloWorld-To-UpperCase -Confirm

Ausgabe:

Wenn der Benutzer auf Ja klickt, sollte die Methode im if-Block implementiert werden und den helloworld-String in Großbuchstaben drucken.

Andernfalls sollte die Nachricht helloworld in Kleinbuchstaben beibehalten angezeigt werden.

Verwenden Sie das CmdletBinding-Attribut mit dem Parameter-Attribut, um die Funktionsparameter zu steuern

Lassen Sie uns unsere erweiterte Funktion so gestalten, dass sie einen Parameter als String annimmt.

Function Helloworld-To-UpperCase {
    [CmdletBinding(SupportsShouldProcess = $True)]
    Param([string]$word)

    Write-Verbose "This is the common parameter usage -Version within our Helloworld-To-UpperCase function"

    if ($PSCmdlet.ShouldContinue("Are you sure on making the helloworld all caps?", "Making uppercase with ToUpper")) {
        $word.ToUpper();
    }
    Else {
        "helloworld kept in lowercase."
    }
}

Wir haben die Funktion Helloworld-To-UpperCase geändert, damit sie einen Parameter vom Typ String namens $word annimmt. Wenn die Funktion aufgerufen wird, müssen wir einen String als Argument bereitstellen.

Der bereitgestellte Text wird in Großbuchstaben umgewandelt. Wenn der Benutzer kein Textargument bereitgestellt hat, gibt die Funktion eine leere Ausgabe zurück.

Wir können dies steuern, indem wir den Parameter $word obligatorisch machen und die Parameterposition auf 0 setzen.

Function Helloworld-To-UpperCase {
    [CmdletBinding(SupportsShouldProcess = $True)]
    Param(
        [Parameter(
            Mandatory = $True, Position = 0
        ) ]
        [string]$word
    )

    #Verbose
    Write-Verbose "This is the common parameter usage -Version within our Helloworld-To-UpperCase function"

    #If/Else block for request processing
    if ($PSCmdlet.ShouldContinue("Are you sure on making the helloworld all caps?", "Making uppercase with ToUpper")) {
        $word.ToUpper();
    }
    Else {
        "helloworld kept in lowercase."
    }
}

Wir haben einige Flags hinzugefügt, um das Verhalten des $word-Parameters zu steuern. Da es obligatorisch ist, müssen wir einen String-Wert angeben, wenn die Funktion ausgeführt wird.

HelloWorld-To-UpperCase -Confirm "stringtouppercase"

PowerShell fragt weiterhin danach, wenn wir das Textargument nicht angeben.

Sie können mehrere Flags verwenden, um die Parameter in Ihren Funktionen zu steuern, wie in der folgenden Parameter-Attribut-Syntax gezeigt.

Param
(
    [Parameter(
        Mandatory = <Boolean>,
        Position = <Integer>,
        ParameterSetName = <String>,
        ValueFromPipeline = <Boolean>,
        ValueFromPipelineByPropertyName = <Boolean>,
        ValueFromRemainingArguments = <Boolean>,
        HelpMessage = <String>,
    )]
    [string[]]
    $Parameter1
)