Comment utiliser correctement les paramètres -verbose et -debug dans cmdlet personnalisé

Question

Par défaut, une fonction nommée qui a l'attribut [CmdletBinding ()] accepte -debug et -verbose (et quelques autres) et des paramètres prédéfinis a $ debug et les variables $ verbeux. Ce que je veux essayer de comprendre comment les transmettre à d'autres cmdlet de ce qui s'appelle dans la fonction.

Le mot Let j'ai une applet de commande comme ceci:

function DoStuff() {
   [CmdletBinding()]

   PROCESS {
      new-item Test -type Directory 
   }
}

si -debug ou -verbose a été passé dans ma fonction que je veux transmettre ce drapeau dans la cmdlet new-item. Quel est le bon modèle pour ce faire?

Answer 1

Peut-être que cela semble étrange, mais il n'y a aucun moyen facile pour une cmdlet de connaître son mode bavard ou débogage. Jetez un oeil à la question connexe:

Comment un cmdlet savoir quand il devrait vraiment appeler WriteVerbose ()?

Un pas parfait, mais l'option pratiquement raisonnable est d'introduire vos propres paramètres de l'applet de commande (par exemple $MyVerbose, $MyDebug) et de les utiliser dans le code explicitement.

function DoStuff {
    [CmdletBinding()]
    param
    (
        # unfortunately, we cannot use Verbose name with CmdletBinding
        [switch]$MyVerbose
    )

    process {

        if ($MyVerbose) {
            # do verbose stuff
        }

        # pass $MyVerbose in the cmdlet explicitly
        New-Item Test -Type Directory -Verbose:$MyVerbose
    }
}

DoStuff -MyVerbose 

UPDATE

Lorsque nous avons besoin que d'un interrupteur (non, par exemple, la valeur de niveau de verbosité), alors l'approche avec $PSBoundParameters est peut-être mieux que proposé ci-dessus des paramètres supplémentaires:

function DoStuff {
    [CmdletBinding()]
    param()

    process {
        if ($PSBoundParameters['Verbose']) {
            # do verbose stuff
        }

        New-Item Test -Type Directory -Verbose:($PSBoundParameters['Verbose'] -eq $true)
    }
}

DoStuff -Verbose

Il est tout pas parfait de toute façon. S'il y a de meilleures solutions alors je voudrais vraiment les connaître moi-même.

Answer 2

$PSBoundParameters est pas ce que vous cherchez. L'utilisation de l'attribut [CmdletBinding()] permet l'utilisation de $PSCmdlet dans un script, en plus de fournir un drapeau verbeux. Il est en fait ce même verbeux que vous êtes censé utiliser.

Par [CmdletBinding()], vous pouvez accéder aux paramètres liés par $PSCmdlet.MyInvocation.BoundParameters. Voici une fonction qui utilise CmdletBinding et pénètre simplement une invite imbriquée immédiatement afin d'examiner les variables disponibles à l'intérieur du périmètre de la fonction.

PS D:\> function hi { [CmdletBinding()]param([string] $Salutation) $host.EnterNestedPrompt() }; hi -Salutation Yo -Verbose

PS D:\>>> $PSBoundParameters

____________________________________________________________________________________________________
PS D:\>>> $PSCmdlet.MyInvocation.BoundParameters

Key Value                                                                                                                                                                                                           
--- -----                                                                                                                                                                                                           
Salutation Yo                                                                                                                                                                                                              
Verbose   True                                                                                       

---

Dans votre exemple, vous voulez ce qui suit:

function DoStuff `
{
    [CmdletBinding()]
    param ()
    process
    {
      new-item Test -type Directory `
        -Verbose:($PSCmdlet.MyInvocation.BoundParameters["Verbose"].IsPresent -eq $true)
    }
}

Cette couverture -Verbose, -Verbose: faux $, -Verbose:. $ True, et le cas où le commutateur est absent du tout

Answer 3

Il n'y a pas besoin. PowerShell fait déjà que le code ci-dessous prouve.

function f { [cmdletbinding()]Param()    
    "f is called"
    Write-Debug Debug
    Write-Verbose Verbose
}
function g { [cmdletbinding()]Param() 
    "g is called"
    f 
}
g -Debug -Verbose

La sortie est

g is called
f is called
DEBUG: Debug
VERBOSE: Verbose

Il ne se fait pas aussi direct que le passage -Debug à l'applet de commande suivante cependant. Il se fait par les variables DebugPreference $ et VerbrosePreference $. Write-debug et Write-Verbose agissent comme on peut s'y attendre, mais si vous voulez faire quelque chose de différent avec débogage ou bavard, vous pouvez lire ici comment vérifier vous-même.

Answer 4

Avec un risque de faire revivre et vieux fil. Voici ma solution.

function DoStuff {
    [CmdletBinding()]
    param ()

    BEGIN
    {
    $CMDOUT=@{
        Verbose=If ($PSBoundParameters.Verbose -eq $true) { $true } else { $false };
        Debug=If ($PSBoundParameters.Debug -eq $true) { $true } else { $false }
    }
    } # BEGIN ENDS

    PROCESS
    {
    New-Item Example -ItemType Directory @CMDOUT
    } # PROCESS ENDS

    END
    {
    } #END ENDS
}

Ce que cela fait différent des autres exemples est qu'il repsect « -Verbose: $ false » ou « -Debug: faux $ ». Il établira seulement -Verbose / -Debug $ true si vous utilisez ce qui suit:

DoStuff -Verbose
DoStuff -Verbose:$true
DoStuff -Debug
DoStuff -Debug:$true

Answer 5

Vous pouvez construire une nouvelle table de hachage sur la base du débogage lié ou verbeux paramètres et splat ensuite à la commande interne. Si vous êtes juste en spécifiant les commutateurs (et ne sont pas le passage d'un commutateur faux, comme $ debug: faux $), vous pouvez simplement vérifier l'existence de debug ou verbeux:

function DoStuff() { 
   [CmdletBinding()] 

   PROCESS { 
        $HT=@{Verbose=$PSBoundParameters.ContainsKey'Verbose');Debug=$PSBoundParameters.ContainsKey('Debug')}
      new-item Test -type Directory @HT
   } 
} 

Si vous voulez passer la valeur du paramètre il est plus compliqué, mais peut être fait avec:

function DoStuff {  
   [CmdletBinding()]  
   param()
   PROCESS {  
   $v,$d = $null
   if(!$PSBoundParameters.TryGetValue('Verbose',[ref]$v)){$v=$false}
   if(!$PSBoundParameters.TryGetValue('Debug',[ref]$d)){$d=$false}
   $HT=@{Verbose=$v;Debug=$d} 
   new-item Test -type Directory @HT 
   }  
}  

Answer 6

La meilleure façon de le faire est en réglant le $VerbosePreference. Cela permettra au niveau de verbosité pour le script entier. Ne pas oublier de le désactiver à la fin du script.

Function test
{
  [CmdletBinding()]
   param( $param1)


  if($psBoundParameters['verbose'])
  {
     $VerbosePreference = "Continue"
     Write-verbose " Verbose mode is on"
   }
  else
   {
     $VerbosePreference = "SilentlyContinue"
     Write-verbose " Verbose mode is Off"
    }
   <<your code>>
   }

Answer 7

Vous pouvez définir la VerbosePreference comme une variable globale sur le démarrage de votre script, puis vérifiez la variable globale dans votre applet de commande personnalisée.

Script:

$global:VerbosePreference = $VerbosePreference
Your-CmdLet

Votre-CmdLet:

if ($global:VerbosePreference -eq 'Continue') {
   # verbose code
}

Vérifier explicitement « Continuer » permet au script d'être égal à -verbose:$false lorsque vous appelez l'applet de commande à partir d'un script qui ne définit pas la variable globale (auquel cas, il est $null)

Answer 8

Je pense que c'est la meilleure façon:

Function Test {
    [CmdletBinding()]
    Param (
        [parameter(Mandatory=$False)]
        [String]$Message
    )

    Write-Host "This is INFO message"

    if ($PSBoundParameters.debug) {
        Write-Host -fore cyan "This is DEBUG message"
    }

    if ($PSBoundParameters.verbose) {
        Write-Host -fore green "This is VERBOSE message"
    }

    ""
}
Test -Verbose -Debug