Attraper PLEIN de Message d'Exception

les erreurs et les exceptions dans PowerShell sont des objets structurés. Le message d'erreur que vous voyez imprimé sur la console est en fait un message formaté contenant des informations provenant de plusieurs éléments de l'objet erreur/exception. Vous pouvez (re-)construire vous-même comme ceci:

$formatstring = "{0} : {1}`n{2}`n" +
                "    + CategoryInfo          : {3}`n" +
                "    + FullyQualifiedErrorId : {4}`n"
$fields = $_.InvocationInfo.MyCommand.Name,
          $_.ErrorDetails.Message,
          $_.InvocationInfo.PositionMessage,
          $_.CategoryInfo.ToString(),
          $_.FullyQualifiedErrorId

$formatstring -f $fields

si vous voulez juste que le message d'erreur s'affiche dans votre catch bloc, vous pouvez simplement l'écho de l'objet courant variable qui contient l'erreur à l'instant):

try {
  ...
} catch {
  $_
}

si vous avez besoin la sortie colorée utiliser Write-Host avec une chaîne formatée, comme décrit ci-dessus:

try {
  ...
} catch {
  ...
  Write-Host -Foreground Red -Background Black ($formatstring -f $fields)
}

cela dit, habituellement vous ne voulez pas simplement afficher le message d'erreur comme-est dans un gestionnaire d'exception (sinon le -ErrorAction Stop serait inutile). Les objets erreur structurée/exception vous fournissent des informations supplémentaires que vous pouvez utiliser pour un meilleur contrôle des erreurs. Par exemple, vous avez $_.Exception.HResult avec le numéro d'erreur. $_.ScriptStackTrace et $_.Exception.StackTrace, de sorte que vous pouvez afficher stacktraces quand débogage. $_.Exception.InnerException vous donne accès à des exceptions imbriquées qui contiennent souvent des informations supplémentaires sur l'erreur (les erreurs de PowerShell de haut niveau peuvent être quelque peu génériques). Vous pouvez dérouler ces exceptions imbriquées avec quelque chose comme ceci:

$e = $_.Exception
$msg = $e.Message
while ($e.InnerException) {
  $e = $e.InnerException
  $msg += "`n" + $e.Message
}
$msg

dans votre cas, l'information que vous voulez extraire semble être en $_.ErrorDetails.Message. Il n'est pas tout à fait clair pour moi si vous avez un objet ou une chaîne JSON là, mais vous devriez être en mesure d'obtenir des informations sur les types et les valeurs des membres $_.ErrorDetails en cours d'exécution

$_.ErrorDetails | Get-Member
$_.ErrorDetails | Format-List *

Si $_.ErrorDetails.Message est un objet, vous devriez être en mesure d'obtenir la chaîne de message comme ceci:

$_.ErrorDetails.Message.message

sinon vous devez convertir la chaîne JSON en objet en premier:

$_.ErrorDetails.Message | ConvertFrom-Json | Select-Object -Expand message

selon le type d'erreur que vous manipulez, les exceptions de types particuliers peuvent aussi inclure des informations plus spécifiques sur le problème en question. Dans votre cas, par exemple, vous avez un WebException qui, en plus du message d'erreur ($_.Exception.Message) contient la réponse actuelle du serveur:

PS C:\> $e.Exception | Get-Member

   TypeName: System.Net.WebException

Name             MemberType Definition
----             ---------- ----------
Equals           Method     bool Equals(System.Object obj), bool _Exception.E...
GetBaseException Method     System.Exception GetBaseException(), System.Excep...
GetHashCode      Method     int GetHashCode(), int _Exception.GetHashCode()
GetObjectData    Method     void GetObjectData(System.Runtime.Serialization.S...
GetType          Method     type GetType(), type _Exception.GetType()
ToString         Method     string ToString(), string _Exception.ToString()
Data             Property   System.Collections.IDictionary Data {get;}
HelpLink         Property   string HelpLink {get;set;}
HResult          Property   int HResult {get;}
InnerException   Property   System.Exception InnerException {get;}
Message          Property   string Message {get;}
Response         Property   System.Net.WebResponse Response {get;}
Source           Property   string Source {get;set;}
StackTrace       Property   string StackTrace {get;}
Status           Property   System.Net.WebExceptionStatus Status {get;}
TargetSite       Property   System.Reflection.MethodBase TargetSite {get;}

qui vous offre avec des informations comme ceci:

PS C:\> $e.Exception.Response

IsMutuallyAuthenticated : False
Cookies                 : {}
Headers                 : {Keep-Alive, Connection, Content-Length, Content-T...}
SupportsHeaders         : True
ContentLength           : 198
ContentEncoding         :
ContentType             : text/html; charset=iso-8859-1
CharacterSet            : iso-8859-1
Server                  : Apache/2.4.10
LastModified            : 17.07.2016 14:39:29
StatusCode              : NotFound
StatusDescription       : Not Found
ProtocolVersion         : 1.1
ResponseUri             : http://www.example.com/
Method                  : POST
IsFromCache             : False

puisque toutes les exceptions n'ont pas exactement le même ensemble de propriétés, Vous pouvez utiliser des gestionnaires spécifiques pour les exceptions particulières:

try {
  ...
} catch [System.ArgumentException] {
  # handle argument exceptions
} catch [System.Net.WebException] {
  # handle web exceptions
} catch {
  # handle all other exceptions
}

si vous avez des opérations qui doivent être effectuées indépendamment du fait qu'une erreur se soit produite ou non (tâches de nettoyage comme la fermeture d'une connexion socket ou d'une base de données), vous pouvez les mettre dans un finally bloc après le traitement d'exception:

try {
  ...
} catch {
  ...
} finally {
  # cleanup operations go here
}