Quand dois-je utiliser Write-Error ou Throw ? Erreurs terminales ou non terminales

Question

Je regarde un Get-WebFile script sur PoshCode, http://poshcode.org/3226 j'ai remarqué cet engin étrange pour moi :

$URL_Format_Error = [string]"..."
Write-Error $URL_Format_Error
return

Quelle en est la raison par rapport à ce qui suit ?

$URL_Format_Error = [string]"..."
Throw $URL_Format_Error

Ou encore mieux :

$URL_Format_Error = New-Object System.FormatException "..."
Throw $URL_Format_Error

Si j'ai bien compris, vous devez utiliser Write-Error pour les erreurs qui ne se terminent pas, et Throw pour les erreurs qui se terminent. Il me semble donc que vous ne devez pas utiliser Write-Error suivi de Return. Y a-t-il une différence ?

Answer 1

Write-Error doit être utilisé si vous souhaitez informer l'utilisateur d'une erreur non critique. Par défaut, il ne fait qu'imprimer un message d'erreur en rouge sur la console. Elle n'empêche pas un pipeline ou une boucle de continuer. Throw d'autre part, produit ce que l'on appelle une erreur de terminaison. Si vous utilisez throw, le pipeline et/ou la boucle en cours seront terminés. En fait, toute l'exécution sera interrompue, à moins que vous n'utilisiez un paramètre de type trap ou un try/catch pour gérer l'erreur de terminaison.

Il y a une chose à noter, si vous définissez $ErrorActionPreference a "Stop" et utiliser Write-Error elle le fera produire une erreur de terminaison .

Dans le script que vous avez lié, nous trouvons ceci :

if ($url.Contains("http")) {
       $request = [System.Net.HttpWebRequest]::Create($url)
}
else {
       $URL_Format_Error = [string]"Connection protocol not specified. Recommended action: Try again using protocol (for example 'http://" + $url + "') instead. Function aborting..."
       Write-Error $URL_Format_Error
    return
   }

Il semble que l'auteur de cette fonction voulait arrêter l'exécution de cette fonction et afficher un message d'erreur à l'écran mais ne voulait pas que l'ensemble du script arrête de s'exécuter. L'auteur du script aurait pu utiliser throw cependant, cela signifierait que vous devriez utiliser une try/catch lors de l'appel de la fonction.

return quittera la portée actuelle qui peut être une fonction, un script, ou un bloc script. Ceci est mieux illustré avec du code :

# A foreach loop.
foreach ( $i in  (1..10) ) { Write-Host $i ; if ($i -eq 5) { return } }

# A for loop.
for ($i = 1; $i -le 10; $i++) { Write-Host $i ; if ($i -eq 5) { return } }

Sortie pour les deux :

1
2
3
4
5

Un problème ici est d'utiliser return con ForEach-Object . Il ne brisera pas la transformation comme on pourrait s'y attendre.

Plus d'informations :

• $ErrorActionPreference : Variables_de_préférence
• try/catch : à propos de_Try_Catch_Finally
• trap : about_Trap
• throw : about_Throw
• return : about_Return

Answer 2

La principale différence entre les Erreur d'écriture et le lancez dans PowerShell est que le premier est tout simplement imprime du texte à la flux d'erreur standard (stderr) alors que ce dernier est en fait met fin à le traitement de la commande ou de la fonction en cours, qui est puis gérée par PowerShell en envoyant des informations sur l'erreur à la console.

Vous pouvez observer le comportement différent des deux dans les exemples que vous avez fournis :

$URL_Format_Error = [string]"..."
Write-Error $URL_Format_Error
return

Dans cet exemple, le return Le mot-clé a été ajouté à explicitement arrêter l'exécution du script après l'envoi du message d'erreur à la console. Dans le deuxième exemple, par contre, le script return n'est pas nécessaire puisque la terminaison est implicitement effectuée par la fonction throw :

$URL_Format_Error = New-Object System.FormatException "..."
Throw $URL_Format_Error

Answer 3

Ajout à La réponse d'Andy Arismendi :

Si Erreur d'écriture met fin ou non au processus dépend de la $ErrorActionPreference réglage.

Pour les scripts non triviaux, $ErrorActionPreference = "Stop" est un réglage recommandé pour échouer rapidement.

"Le comportement par défaut de PowerShell en ce qui concerne les erreurs, qui est de continuer sur l'erreur ... semble très VB6 "On Error Resume Next"-ish".

(de http://codebetter.com/jameskovacs/2010/02/25/the-exec-problem/ )

Cependant, il fait Write-Error appels terminés.

Pour utiliser Erreur d'écriture comme une commande non terminale indépendamment des autres paramètres d'environnement, vous pouvez utiliser paramètre commun -ErrorAction avec valeur Continue :

 Write-Error "Error Message" -ErrorAction:Continue

Answer 4

Write-Error permet au consommateur de la fonction de supprimer le message d'erreur avec -ErrorAction SilentlyContinue (alternativement -ea 0 ). Alors que throw nécessite un try{...} catch {..}

Pour utiliser un try...catch avec Write-Error :

try {
    SomeFunction -ErrorAction Stop
}
catch {
    DoSomething
}

Answer 5

Si votre lecture du code est correcte, alors vous avez raison. Les erreurs de terminaison doivent utiliser throw Et si vous avez affaire à des types .NET, il est utile de suivre également les conventions d'exception .NET.