Exception.Data Propriété

Définition

Obtient une collection de paires clé/valeur qui fournissent des informations définies par l'utilisateur supplémentaires sur l'exception.

public:
 virtual property System::Collections::IDictionary ^ Data { System::Collections::IDictionary ^ get(); };
public virtual System.Collections.IDictionary Data { get; }
member this.Data : System.Collections.IDictionary
Public Overridable ReadOnly Property Data As IDictionary

Valeur de propriété

IDictionary

Objet qui implémente l'interface IDictionary et contient une collection de paires clé/valeur définies par l'utilisateur. La valeur par défaut est une collection vide.

Exemples

L’exemple suivant montre comment ajouter et récupérer des informations à l’aide de la Data propriété.

using namespace System;
using namespace System::Collections;

void NestedRunTest( bool displayDetails ); // forward declarations
void NestedRoutine1( bool displayDetails );
void NestedRoutine2( bool displayDetails );
void RunTest( bool displayDetails );

int main()
{
   Console::WriteLine("\nException with some extra information..." );
   RunTest(false);
   Console::WriteLine("\nException with all extra information..." );
   RunTest(true);
}

void RunTest( bool displayDetails )
{
   try
   {
      NestedRoutine1( displayDetails );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "An exception was thrown." );
      Console::WriteLine( e->Message );
      if ( e->Data != nullptr )
      {
         Console::WriteLine( "  Extra details:" );

         for each (DictionaryEntry de in e->Data)
            Console::WriteLine("    Key: {0,-20}      Value: {1}", 
                               "'" + de.Key->ToString() + "'", de.Value);
      }
   }
}

void NestedRoutine1( bool displayDetails )
{
   try
   {
      NestedRoutine2( displayDetails );
   }
   catch ( Exception^ e ) 
   {
      e->Data[ "ExtraInfo" ] = "Information from NestedRoutine1.";
      e->Data->Add( "MoreExtraInfo", "More information from NestedRoutine1." );
      throw;
   }
}

void NestedRoutine2( bool displayDetails )
{
   Exception^ e = gcnew Exception( "This statement is the original exception message." );
   if ( displayDetails )
   {
      String^ s = "Information from NestedRoutine2.";
      int i = -903;
      DateTime dt = DateTime::Now;
      e->Data->Add( "stringInfo", s );
      e->Data[ "IntInfo" ] = i;
      e->Data[ "DateTimeInfo" ] = dt;
   }

   throw e;
}

/*
This example produces the following results:

Exception with some extra information...
An exception was thrown.
This statement is the original exception message.
  Extra details:
    The key is 'ExtraInfo' and the value is: Information from NestedRoutine1.
    The key is 'MoreExtraInfo' and the value is: More information from NestedRoutine1.

Exception with all extra information...
An exception was thrown.
This statement is the original exception message.
  Extra details:
    The key is 'stringInfo' and the value is: Information from NestedRoutine2.
    The key is 'IntInfo' and the value is: -903
    The key is 'DateTimeInfo' and the value is: 11/26/2002 2:12:58 PM
    The key is 'ExtraInfo' and the value is: Information from NestedRoutine1.
    The key is 'MoreExtraInfo' and the value is: More information from NestedRoutine1.
*/
// This example demonstrates the Exception.Data property.
using System;
using System.Collections;

class Sample
{
   public static void Main()
   {
      Console.WriteLine("\nException with some extra information...");
      RunTest(false);
      Console.WriteLine("\nException with all extra information...");
      RunTest(true);
   }

   public static void RunTest(bool displayDetails)
   {
      try {
         NestedRoutine1(displayDetails);
      }
      catch (Exception e) {
         Console.WriteLine("An exception was thrown.");
         Console.WriteLine(e.Message);
         if (e.Data.Count > 0) {
            Console.WriteLine("  Extra details:");
            foreach (DictionaryEntry de in e.Data)
               Console.WriteLine("    Key: {0,-20}      Value: {1}",
                                 "'" + de.Key.ToString() + "'", de.Value);
         }
      }
   }

   public static void NestedRoutine1(bool displayDetails)
   {
      try {
         NestedRoutine2(displayDetails);
      }
      catch (Exception e) {
         e.Data["ExtraInfo"] = "Information from NestedRoutine1.";
         e.Data.Add("MoreExtraInfo", "More information from NestedRoutine1.");
         throw;
      }
   }

   public static void NestedRoutine2(bool displayDetails)
   {
      Exception e = new Exception("This statement is the original exception message.");
      if (displayDetails) {
         string s = "Information from NestedRoutine2.";
         int i = -903;
         DateTime dt = DateTime.Now;
         e.Data.Add("stringInfo", s);
         e.Data["IntInfo"] = i;
         e.Data["DateTimeInfo"] = dt;
      }
      throw e;
   }
}
// The example displays the following output:
//    Exception with some extra information...
//    An exception was thrown.
//    This statement is the original exception message.
//      Extra details:
//        Key: 'ExtraInfo'               Value: Information from NestedRoutine1.
//        Key: 'MoreExtraInfo'           Value: More information from NestedRoutine1.
//
//    Exception with all extra information...
//    An exception was thrown.
//    This statement is the original exception message.
//      Extra details:
//        Key: 'stringInfo'              Value: Information from NestedRoutine2.
//        Key: 'IntInfo'                 Value: -903
//        Key: 'DateTimeInfo'            Value: 7/29/2013 10:50:13 AM
//        Key: 'ExtraInfo'               Value: Information from NestedRoutine1.
//        Key: 'MoreExtraInfo'           Value: More information from NestedRoutine1.
// This example demonstrates the Exception.Data property.
open System
open System.Collections

let nestedRoutine2 displayDetails =
    let e = Exception "This statement is the original exception message."
    if displayDetails then
        let s = "Information from nestedRoutine2."
        let i = -903
        let dt = DateTime.Now
        e.Data.Add("stringInfo", s)
        e.Data["IntInfo"] <- i
        e.Data["DateTimeInfo"] <- dt
    raise e

let nestedRoutine1 displayDetails =
    try
        nestedRoutine2 displayDetails
    with e ->
        e.Data["ExtraInfo"] <- "Information from nestedRoutine1."
        e.Data.Add("MoreExtraInfo", "More information from nestedRoutine1.")
        reraise ()

let runTest displayDetails =
    try
        nestedRoutine1 displayDetails
    with e ->
        printfn "An exception was thrown."
        printfn $"{e.Message}"
        if e.Data.Count > 0 then
            printfn "  Extra details:"
            for de in e.Data do
                let de = de :?> DictionaryEntry
                printfn $"""    Key: {"'" + de.Key.ToString() + "'",-20}      Value: {de.Value}"""

printfn "\nException with some extra information..."
runTest false
printfn "\nException with all extra information..."
runTest true

   
// The example displays the following output:
//    Exception with some extra information...
//    An exception was thrown.
//    This statement is the original exception message.
//      Extra details:
//        Key: 'ExtraInfo'               Value: Information from NestedRoutine1.
//        Key: 'MoreExtraInfo'           Value: More information from NestedRoutine1.
//
//    Exception with all extra information...
//    An exception was thrown.
//    This statement is the original exception message.
//      Extra details:
//        Key: 'stringInfo'              Value: Information from NestedRoutine2.
//        Key: 'IntInfo'                 Value: -903
//        Key: 'DateTimeInfo'            Value: 7/29/2013 10:50:13 AM
//        Key: 'ExtraInfo'               Value: Information from NestedRoutine1.
//        Key: 'MoreExtraInfo'           Value: More information from NestedRoutine1.
Imports System.Collections

Module Example
   Public Sub Main()
      Console.WriteLine()
      Console.WriteLine("Exception with some extra information...")
      RunTest(False)
      Console.WriteLine()
      Console.WriteLine("Exception with all extra information...")
      RunTest(True)
   End Sub

   Public Sub RunTest(displayDetails As Boolean)
      Try
         NestedRoutine1(displayDetails)
      Catch e As Exception
         Console.WriteLine("An exception was thrown.")
         Console.WriteLine(e.Message)
         If e.Data.Count > 0 Then
            Console.WriteLine("  Extra details:")
            For Each de As DictionaryEntry In e.Data
               Console.WriteLine("    Key: {0,-20}      Value: {1}",
                                 "'" + de.Key.ToString() + "'", de.Value)
            Next
         End If 
      End Try 
   End Sub 

   Public Sub NestedRoutine1(displayDetails As Boolean)
      Try
         NestedRoutine2(displayDetails)
      Catch e As Exception
         e.Data("ExtraInfo") = "Information from NestedRoutine1."
         e.Data.Add("MoreExtraInfo", "More information from NestedRoutine1.")
         Throw e
      End Try 
   End Sub

   Public Sub NestedRoutine2(displayDetails As Boolean)
      Dim e As New Exception("This statement is the original exception message.")
      If displayDetails Then 
         Dim s As String = "Information from NestedRoutine2." 
         Dim i As Integer = -903
         Dim dt As DateTime = DateTime.Now
         e.Data.Add("stringInfo", s)
         e.Data("IntInfo") = i
         e.Data("DateTimeInfo") = dt
      End If 
      Throw e
   End Sub 
End Module
' This example displays the following output: 
'    Exception with some extra information...
'    An exception was thrown.
'    This statement is the original exception message.
'      Extra details:
'        Key: 'ExtraInfo'               Value: Information from NestedRoutine1.
'        Key: 'MoreExtraInfo'           Value: More information from NestedRoutine1.
'    
'    Exception with all extra information...
'    An exception was thrown.
'    This statement is the original exception message.
'      Extra details:
'        Key: 'stringInfo'              Value: Information from NestedRoutine2.
'        Key: 'IntInfo'                 Value: -903
'        Key: 'DateTimeInfo'            Value: 7/29/2013 10:50:13 AM
'        Key: 'ExtraInfo'               Value: Information from NestedRoutine1.
'        Key: 'MoreExtraInfo'           Value: More information from NestedRoutine1.

Remarques

Utilisez l’objet System.Collections.IDictionary retourné par la Data propriété pour stocker et récupérer des informations supplémentaires pertinentes pour l’exception. Les informations sont sous la forme d’un nombre arbitraire de paires clé/valeur définies par l’utilisateur. Le composant clé de chaque paire clé/valeur est généralement une chaîne d’identification, tandis que le composant valeur de la paire peut être n’importe quel type d’objet.

Sécurité de la paire clé/valeur

Les paires clé/valeur stockées dans la collection retournée par la Data propriété ne sont pas sécurisées. Si votre application appelle une série imbriquée de routines et que chaque routine contient des gestionnaires d’exceptions, la pile d’appels résultante contient une hiérarchie de ces gestionnaires d’exceptions. Si une routine de niveau inférieur lève une exception, tout gestionnaire d’exceptions de niveau supérieur de la hiérarchie de pile d’appels peut lire et/ou modifier les paires clé/valeur stockées dans la collection par tout autre gestionnaire d’exceptions. Cela signifie que vous devez garantir que les informations des paires clé/valeur ne sont pas confidentielles et que votre application fonctionne correctement si les informations des paires clé/valeur sont endommagées.

Conflits clés

Un conflit de clés se produit lorsque différents gestionnaires d’exceptions spécifient la même clé pour accéder à une paire clé/valeur. Utilisez la prudence lors du développement de votre application, car la conséquence d’un conflit clé est que les gestionnaires d’exceptions de niveau inférieur peuvent communiquer par inadvertance avec des gestionnaires d’exceptions de niveau supérieur, et cette communication peut entraîner des erreurs de programme subtiles. Toutefois, si vous êtes prudent, vous pouvez utiliser des conflits clés pour améliorer votre application.

Éviter les conflits de clés

Évitez les conflits de clés en adoptant une convention d’affectation de noms pour générer des clés uniques pour les paires clé/valeur. Par exemple, une convention d’affectation de noms peut générer une clé qui se compose du nom délimité par la période de votre application, de la méthode qui fournit des informations supplémentaires pour la paire et un identificateur unique.

Supposons que deux applications, nommées Produits et Fournisseurs, ont chacune une méthode nommée Sales. La méthode Sales dans l’application Products fournit le numéro d’identification (unité de conservation des stocks ou référence SKU) d’un produit. La méthode sales de l’application Fournisseurs fournit le numéro d’identification ou le SID d’un fournisseur. Par conséquent, la convention d’affectation de noms pour cet exemple génère les clés , « Products.Sales.SKU » et « Suppliers.Sales.SID ».

Exploitation des conflits de clés

Exploitez les conflits de clés à l’aide de la présence d’une ou plusieurs clés spéciales et préarrangées pour contrôler le traitement. Supposons que, dans un scénario, le gestionnaire d’exceptions de niveau le plus élevé de la hiérarchie de pile d’appels intercepte toutes les exceptions levées par des gestionnaires d’exceptions de niveau inférieur. Si une paire clé/valeur avec une clé spéciale existe, le gestionnaire d’exceptions de haut niveau met en forme les paires clé/valeur restantes dans l’objet IDictionary de manière non standard ; sinon, les paires clé/valeur restantes sont mises en forme de manière normale.

Supposons maintenant que, dans un autre scénario, le gestionnaire d’exceptions à chaque niveau de la hiérarchie de pile d’appels intercepte l’exception levée par le gestionnaire d’exceptions de niveau inférieur suivant. De plus, chaque gestionnaire d’exceptions sait que la collection retournée par la Data propriété contient un ensemble de paires clé/valeur accessibles avec un ensemble préarrangé de clés.

Chaque gestionnaire d’exceptions utilise l’ensemble préarrangé de clés pour mettre à jour le composant valeur de la paire clé/valeur correspondante avec des informations uniques à ce gestionnaire d’exceptions. Une fois le processus de mise à jour terminé, le gestionnaire d’exceptions lève l’exception au gestionnaire d’exceptions de niveau supérieur suivant. Enfin, le gestionnaire d’exceptions de niveau le plus élevé accède aux paires clé/valeur et affiche les informations de mise à jour consolidées de tous les gestionnaires d’exceptions de niveau inférieur.

S’applique à

Voir aussi