Wie unterstützen Sie PowerShells -WhatIf & amp; -Konfirmieren Sie Parameter in einem Cmdlet, das andere Cmdlets aufruft?

Habe ich ein PowerShell-script-cmdlet unterstützt die -WhatIf & -Confirm Parameter.

Dies geschieht durch den Aufruf der $PSCmdlet.ShouldProcess() - Methode vor der Durchführung der änderung.
Dies funktioniert wie erwartet.

Das problem ist, dass ich meine Cmdlet implementiert ist, durch aufrufen von anderen Cmdlets und der -WhatIf oder -Confirm Parameter werden nicht weitergegeben, auf die Cmdlets haben, die ich aufrufen.

Wie kann ich das weitergeben der Werte von -WhatIf und -Confirm auf die Cmdlets haben, ich rufe von meinem Cmdlet?

Zum Beispiel, wenn mein Cmdlet Stop-CompanyXyzServices und es nutzt Stop-Service zur Umsetzung Ihrer Aktion.

Wenn -WhatIf übergeben Stop-CompanyXyzServices ich will es auch weitergegeben werden, um Stop-Service.

Ist das möglich?

InformationsquelleAutor der Frage Dan Finucane | 2011-08-24

14

Übergabe von Parametern explizit

Übergeben Sie den -WhatIf und -Confirm Parameter mit der $WhatIfPreference und $ConfirmPreference Variablen. Im folgenden Beispiel gelingt dies mit parameter splatting:
```
if($ConfirmPreference -eq 'Low') {$conf = @{Confirm = $true}}

StopService MyService -WhatIf:([bool]$WhatIfPreference.IsPresent) @conf
```
$WhatIfPreference.IsPresent wird True wenn die -WhatIf Schalter wird verwendet, auf der die Funktion. Mit der -Confirm einschalten, die Funktion vorübergehend setzt $ConfirmPreference zu low.

Parameterübergabe implizit

Da die -Confirm und -WhatIf vorübergehend die $ConfirmPreference und $WhatIfPreference Variablen automatisch, ist es sogar notwendig, Sie zu übergeben?

Betrachten Sie das Beispiel:
```
function ShouldTestCallee {
    [cmdletBinding(SupportsShouldProcess=$true,ConfirmImpact='Medium')] 
    param($test)

    $PSCmdlet.ShouldProcess($env:COMPUTERNAME,"Confirm?")
}


function ShouldTestCaller {
    [cmdletBinding(SupportsShouldProcess=$true)]
    param($test)

    ShouldTestCallee
}

$ConfirmPreference = 'High'
ShouldTestCaller
ShouldTestCaller -Confirm
```
ShouldTestCaller Ergebnisse in True aus ShouldProcess()

ShouldTestCaller -Confirm Ergebnisse in ein bestätigen Sie die Eingabeaufforderung, obwohl ich mich gar nicht über die Schalter.

Bearbeiten

@manojlds Antwort machte mir klar, dass meine Lösung war immer die Einstellung $ConfirmPreference auf 'Low' oder 'High'. Ich habe aktualisiert mein code nur die -Confirm wechseln, wenn die bestätigen-Voreinstellung ist 'Low'.

InformationsquelleAutor der Antwort Rynant
6

Nach etwas googlen kam ich auf eine gute Lösung für die übergabe von common-Parameter, genannt Befehle. Sie können die @ splatting Betreiber zu übergeben alle Parameter, die übergeben wurden, zu Ihrem Befehl. Zum Beispiel, wenn

Start-Service-Name ServiceAbc @PSBoundParameters

ist in den Körper Ihrer powershell-Skript übergeben wird, werden alle Parameter an ein Skript übergeben, um den Start-Service-Befehl. Das problem ist nur, dass, wenn Ihr Skript enthält sagen -Name-parameter wird übergeben werden, auch und PowerShell beschweren sich, dass Sie enthalten die parameter-Name zweimal. Ich schrieb die folgende Funktion kopiert die common-Parameter, um ein neues Wörterbuch und dann habe ich splat.
```
function Select-BoundCommonParameters
{
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        $BoundParameters
    )
    begin
    {
        $boundCommonParameters = New-Object -TypeName 'System.Collections.Generic.Dictionary[string, [Object]]'
    }
    process
    {
        $BoundParameters.GetEnumerator() |
            Where-Object { $_.Key -match 'Debug|ErrorAction|ErrorVariable|WarningAction|WarningVariable|Verbose' } |
            ForEach-Object { $boundCommonParameters.Add($_.Key, $_.Value) }

        $boundCommonParameters
    }
}
```
Das Ergebnis ist, übergeben Sie Parameter wie-Verbose entlang der Befehle aufgerufen, in Ihrem Skript, und Sie Ehren die Anrufer Absicht.

InformationsquelleAutor der Antwort Dan Finucane

Hier ist eine komplette Lösung basierend auf dem @Rynant und @Shay Levy Antworten:

function Stop-CompanyXyzServices
{
    [CmdletBinding(SupportsShouldProcess=$true,ConfirmImpact='Medium')]

    Param(
        [Parameter(
            Position=0,
            ValueFromPipeline=$true,
            ValueFromPipelineByPropertyName=$true
        )]      
        [string]$Name
    )

    process
    {
        if($PSCmdlet.ShouldProcess($env:COMPUTERNAME,"Stop XYZ services '$Name'")){  
            ActualCmdletProcess
        }
        if([bool]$WhatIfPreference.IsPresent){
            ActualCmdletProcess
        }
    }
}

function ActualCmdletProcess{
# add here the actual logic of your cmdlet, and any call to other cmdlets
Stop-Service $name -WhatIf:([bool]$WhatIfPreference.IsPresent) -Confirm:("Low","Medium" -contains $ConfirmPreference)
}

Wir haben, um zu sehen, wenn -WhatIf übergeben wird, getrennt, so dass die Parameter whatif können weitergegeben werden zu den einzelnen cmdlets. ActualCmdletProcess ist im Grunde eine Umgestaltung, so dass Sie rufen Sie nicht die gleichen Befehle wieder nur für die WhatIf. Hoffe, das jemand hilft.

InformationsquelleAutor der Antwort manojlds

Aktualisiert pro @manojlds Kommentar

Cast $WhatIf und $Confirm Boolean und übergeben Sie die Werte, die das zugrunde liegende cmdlet:

function Stop-CompanyXyzServices
{
    [CmdletBinding(SupportsShouldProcess=$true,ConfirmImpact='High')]

    Param(
        [Parameter(
            Position=0,
            ValueFromPipeline=$true,
            ValueFromPipelineByPropertyName=$true
        )]      
        [string]$Name
    )


    process
    {
        if($PSCmdlet.ShouldProcess($env:COMPUTERNAME,"Stop service '$Name'"))
        {                   
            Stop-Service $name -WhatIf:([bool]$WhatIf) -Confirm:([bool]$confirm)
        }                       
    }
}

InformationsquelleAutor der Antwort Shay Levy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.