Verwenden des CmdletBinding-Attributs in PowerShell

1. CmdletBinding-Attribut in PowerShell
2. Verwendung von das Attribut CmdletBinding mit dem Parameter Verbose
3. Verwendung von das Attribut CmdletBinding mit dem Objekt $PSCmdlet und SupportsShouldProcess
4. Verwenden Sie das Attribut CmdletBinding mit dem Attribut Parameter, um 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.

Üblicherweise wird ein cmdlet als Verb-Substantiv-Paar ausgedrückt, um einen Befehl auszuführen. Der Befehl ist eine Anweisung an das zugrunde liegende Betriebssystem, einen bestimmten Dienst durch den Endbenutzer auszuführen.

Die PowerShell-Umgebung umfasst mehr als 200 grundlegende cmdlets wie New-Item, Move-Item, Set-Location und Get-Location. Das cmdlet teilt 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. Fordern Sie Bestätigungen an
3. Obligatorische Parameterunterstützung

CmdletBinding-Attribut in PowerShell

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

Das Folgende zeigt die Syntax des Attributs CmdletBinding mit allen möglichen Argumenten.

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

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

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

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

Dieser Funktion sind keine Parameter zugeordnet. Dies wird also als einfache PowerShell-Funktion bezeichnet.

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

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

Die Helloworld-To-UpperCase-Funktion wurde in eine erweiterte Funktion umgewandelt, die alle grundlegenden cmdlet-Funktionen erbt. Dieser Funktion stehen die grundlegenden cmdlet-Parameter zur Verfügung.

Wenn Sie diese Funktion im PowerShell-Fenster mit - aufrufen, sollte sie alle allgemeinen Parameter auflisten, die vom cmdlet kommen.

helloworld-to-uppercase -

Ausgabe:

Die gemeinsamen cmdlet-Parameter und -Features können innerhalb unserer erweiterten Funktionen verwendet werden, um die Funktionalität zu erweitern.

Verwendung von das Attribut CmdletBinding mit dem Parameter Verbose

Das -verbose ist einer der wertvollen allgemeinen Parameter, der eine Nachricht anzeigen kann, wenn die erweiterte Funktion ausgeführt wird.

Function Helloworld-To-UpperCase {
    [CmdletBinding()]Param()

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

    "helloworld".ToUpper();
}

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

HelloWorld-To-UpperCase -Verbose

Ausgabe:

Verwendung von das Attribut CmdletBinding mit dem Objekt $PSCmdlet und SupportsShouldProcess

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

Verwendung von das Attribut CmdletBinding mit der Methode ShouldContinue

Diese Methode ermöglicht es Benutzern, die Bestätigungsanforderungen zu verarbeiten. In der Zwischenzeit muss das Argument SupportsShouldProcess zwingend auf $True gesetzt werden.

Die Methode ShouldContinue hat mehrere überladene Methoden, und wir werden die 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 Parameter -Confirm aufrufen, und es wird ein Bestätigungsfeld angezeigt, wie im Folgenden gezeigt.

HelloWorld-To-UpperCase -Confirm

Ausgabe:

Wenn der Benutzer auf Ja klickt, soll er die Methode im if-Block implementieren und den helloworld-String in Grossbuchstaben ausgeben.

Wenn nicht, sollte die Nachricht helloworld kept in lowercase angezeigt werden.

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

Lassen Sie unsere erweiterte Funktion einen Parameter als Zeichenfolge annehmen.

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 so geändert, dass sie einen Parameter vom Typ String namens $word verwendet. Wenn die Funktion aufgerufen wurde, müssen wir einen String als Argument angeben.

Der bereitgestellte Text wird in Großbuchstaben umgewandelt. Wenn der Benutzer kein Textargument angegeben hat, gibt die Funktion eine leere Ausgabe aus.

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

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 Parameters $word zu steuern. Da dies obligatorisch ist, müssen wir beim Ausführen der Funktion einen Zeichenfolgenwert angeben.

HelloWorld-To-UpperCase -Confirm "stringtouppercase"

PowerShell fragt immer wieder 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-Attributsyntax gezeigt.

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