Powershell: Cómo obtener -whatif para propagar a cmdlets en otro módulo

Question

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 ejecutar de verdad

Sin embargo, me he encontrado con un pequeño inconveniente. Si invoco una secuencia de comandos con -whatif como argumento, $ pscmdlet.ShouldProcess devolverá falso. 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á true. El contexto -whatif no parece pasar a llamadas en el otro módulo.

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

Este tema parece relacionado con esto question. Sin embargo, no están hablando del problema de módulos cruzados.

Ejemplo Guión:

#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 

Answer 1

Para ello, puede utilizar una técnica que llamo "CallStack asomándose". Use Get-PSCallStack para buscar lo que llame la función. Cada elemento tendrá una InvocationInfo, y un interior de eso será una propiedad llamada "BoundParameters". Esto tiene los parámetros @ cada nivel. Si -Qué pasó a cualquiera de ellos, puede actuar como -Qué pasó a su función.

Esperanza esto ayuda