He intentado escribir código seguro que admita -whatif con el método ShouldProcess para que mis usuarios tengan una idea de lo que se supone que debe hacer un cmdlet antes de ejecutarlo de verdad.

Sin embargo, me he encontrado con un pequeño inconveniente. Si llamo a un script con -whatif como argumento, $ pscmdlet.ShouldProcess devolverá false. Todo bien y bien. Si llamo a un cmdlet definido en el mismo archivo (que tiene SupportsShouldProcess = $ true), también devolverá falso.

Sin embargo, si estoy llamando a un cmdlet definido en otro módulo que he cargado usando Import-Module, devolverá verdadero. El contexto -whatif no parece pasar a las llamadas en el otro módulo.

No quiero tener que pasar manualmente una bandera a cada cmdlet. ¿Alguien tiene una solución mejor

ste problema parece estar relacionado con estepregunt. Sin embargo, no están hablando del problema entre módulos.

Script de ejemplo:

#whatiftest.ps1
[CmdletBinding(SupportsShouldProcess=$true)]
param()

Import-Module  -name .\whatiftest_module  -Force

function Outer
{
    [CmdletBinding(SupportsShouldProcess=$true)]
    param()
    if( $pscmdlet.ShouldProcess("Outer"))
    {
        Write-Host "Outer ShouldProcess"
    }
    else
    {
        Write-Host "Outer Should not Process"
    }

    Write-Host "Calling Inner"
    Inner
    Write-Host "Calling InnerModule"
    InnerModule
}

function Inner
{
    [CmdletBinding(SupportsShouldProcess=$true)]
    param()

    if( $pscmdlet.ShouldProcess("Inner"))
    {
        Write-Host "Inner ShouldProcess"
    }
    else
    {
        Write-Host "Inner Should not Process"
    }
}

    Write-Host "--Normal--"
    Outer

    Write-Host "--WhatIf--"
    Outer -WhatIf

El módulo

#whatiftest_module.psm1
 function InnerModule
 {
    [CmdletBinding(SupportsShouldProcess=$true)]
    param()    

    if( $pscmdlet.ShouldProcess("InnerModule"))
    {
        Write-Host "InnerModule ShouldProcess"
    }
    else
    {
        Write-Host "InnerModule Should not Process"
    }
 }

Salida

F:\temp> .\whatiftest.ps1
--Normal--
Outer ShouldProcess
Calling Inner
Inner ShouldProcess
Calling InnerModule
InnerModule ShouldProcess
--WhatIf--
What if: Performing operation "Outer" on Target "Outer".
Outer Should not Process
Calling Inner
What if: Performing operation "Inner" on Target "Inner".
Inner Should not Process
Calling InnerModule
InnerModule ShouldProcess