Exception.Data Eigenschaft

Definition

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen über die Ausnahme bereitstellen.Gets a collection of key/value pairs that provide additional user-defined information about the 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

Eigenschaftswert

Ein Objekt, das die IDictionary-Schnittstelle implementiert und eine Auflistung benutzerdefinierter Schlüssel-Wert-Paare enthält.An object that implements the IDictionary interface and contains a collection of user-defined key/value pairs. Der Standard ist eine leere Auflistung.The default is an empty collection.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Informationen mithilfe der Data -Eigenschaft hinzugefügt und abgerufen werden.The following example demonstrates how to add and retrieve information using the Data property.

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. 
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. 

Hinweise

Verwenden Sie System.Collections.IDictionary das-Objekt, Data das von der-Eigenschaft zurückgegeben wird, um ergänzende, relevante Informationen zu speichern und abzurufen.Use the System.Collections.IDictionary object returned by the Data property to store and retrieve supplementary information relevant to the exception. Die Informationen werden in Form einer beliebigen Anzahl benutzerdefinierter Schlüssel-Wert-Paare angegeben.The information is in the form of an arbitrary number of user-defined key/value pairs. Die Schlüsselkomponente jedes Schlüssel-Wert-Paars ist in der Regel eine identifizierende Zeichenfolge, während die Wert Komponente des Paars einen beliebigen Objekttyp aufweisen kann.The key component of each key/value pair is typically an identifying string, whereas the value component of the pair can be any type of object.

Schlüssel-Wert-Paar-SicherheitKey/Value Pair Security

Die in der Auflistung gespeicherten Schlüssel-Wert-Paare, die Data von der-Eigenschaft zurückgegeben werden, sind nicht sicher.The key/value pairs stored in the collection returned by the Data property are not secure. Wenn Ihre Anwendung eine schalte Reihe von Routinen aufruft und jede Routine Ausnahmehandler enthält, enthält die resultierende Aufruf Liste eine Hierarchie dieser Ausnahmehandler.If your application calls a nested series of routines, and each routine contains exception handlers, the resulting call stack contains a hierarchy of those exception handlers. Wenn eine Routine auf niedrigerer Ebene eine Ausnahme auslöst, kann jeder Ausnahmehandler auf der obersten Ebene in der Hierarchie der Auflistungs Stapel die in der Auflistung gespeicherten Schlüssel-Wert-Paare von einem beliebigen anderen Ausnahmehandler lesen und/oder ändern.If a lower-level routine throws an exception, any upper-level exception handler in the call stack hierarchy can read and/or modify the key/value pairs stored in the collection by any other exception handler. Dies bedeutet, dass Sie sicherstellen müssen, dass die Informationen in den Schlüssel-Wert-Paaren nicht vertraulich sind und dass Ihre Anwendung ordnungsgemäß ausgeführt wird, wenn die Informationen in den Schlüssel-Wert-Paaren beschädigt sind.This means you must guarantee that the information in the key/value pairs is not confidential and that your application will operate correctly if the information in the key/value pairs is corrupted.

Schlüssel KonflikteKey Conflicts

Ein Schlüssel Konflikt tritt auf, wenn verschiedene Ausnahmehandler denselben Schlüssel für den Zugriff auf ein Schlüssel-Wert-Paar angeben.A key conflict occurs when different exception handlers specify the same key to access a key/value pair. Seien Sie vorsichtig, wenn Sie Ihre Anwendung entwickeln, da die Folge eines Schlüssel Konflikts darin besteht, dass Ausnahmehandler auf niedrigerer Ebene versehentlich mit Ausnahme Handlern auf höherer Ebene kommunizieren können. diese Kommunikation kann zu geringfügigen Programmfehlern führen.Use caution when developing your application because the consequence of a key conflict is that lower-level exception handlers can inadvertently communicate with higher-level exception handlers, and this communication might cause subtle program errors. Wenn Sie jedoch vorsichtig sind, können Sie Schlüssel Konflikte verwenden, um Ihre Anwendung zu verbessern.However, if you are cautious you can use key conflicts to enhance your application.

Vermeiden von Schlüssel KonfliktenAvoiding Key Conflicts

Vermeiden Sie Schlüssel Konflikte, indem Sie eine Benennungs Konvention anwenden, um eindeutige Schlüssel für Schlüssel-Wert-Paare zu generieren.Avoid key conflicts by adopting a naming convention to generate unique keys for key/value pairs. Eine Benennungs Konvention kann z. b. einen Schlüssel erzeugen, der aus dem durch Punkte getrennten Namen Ihrer Anwendung, der Methode, die zusätzliche Informationen für das Paar bereitstellt, und einem eindeutigen Bezeichner besteht.For example, a naming convention might yield a key that consists of the period-delimited name of your application, the method that provides supplementary information for the pair, and a unique identifier.

Angenommen, zwei Anwendungen, mit dem Namen Products und Suppliers, verfügen jeweils über eine Methode mit dem Namen Sales.Suppose two applications, named Products and Suppliers, each has a method named Sales. Die Sales-Methode in der Products-Anwendung stellt die Identifikationsnummer (die Stock Keeping Unit oder SKU) eines Produkts bereit.The Sales method in the Products application provides the identification number (the stock keeping unit or SKU) of a product. Die Sales-Methode in der Suppliers-Anwendung gibt die Identifikationsnummer (SID) eines Lieferanten an.The Sales method in the Suppliers application provides the identification number, or SID, of a supplier. Folglich ergibt die Benennungs Konvention für dieses Beispiel die Schlüssel "Products. Sales. SKU" und "Suppliers. Sales. sid".Consequently, the naming convention for this example yields the keys, "Products.Sales.SKU" and "Suppliers.Sales.SID".

Ausnutzen von Schlüssel KonfliktenExploiting Key Conflicts

Exploitschlüsselkonflikte durch die Verwendung eines oder mehrerer spezieller, vorab angeordneter Schlüssel zur Steuerung der Verarbeitung.Exploit key conflicts by using the presence of one or more special, prearranged keys to control processing. Angenommen, in einem Szenario fängt der Ausnahmehandler der höchsten Ebene in der Hierarchie der aufrufsstapel alle Ausnahmen ab, die von Ausnahme Handlern auf niedrigerer Ebene ausgelöst werden.Suppose, in one scenario, the highest level exception handler in the call stack hierarchy catches all exceptions thrown by lower-level exception handlers. Wenn ein Schlüssel-Wert-Paar mit einem speziellen Schlüssel vorhanden ist, formatiert der Ausnahmehandler auf hoher Ebene die verbleibenden Schlüssel- IDictionary Wert-Paare im Objekt auf eine nicht standardmäßige Weise. andernfalls werden die verbleibenden Schlüssel-Wert-Paare auf normale Weise formatiert.If a key/value pair with a special key exists, the high-level exception handler formats the remaining key/value pairs in the IDictionary object in some nonstandard way; otherwise, the remaining key/value pairs are formatted in some normal manner.

Angenommen, in einem anderen Szenario fängt der Ausnahmehandler auf jeder Ebene der Hierarchie der aufrufsstapel die vom nächsten Ausnahmehandler auf niedrigerer Ebene ausgelöste Ausnahme ab.Now suppose, in another scenario, the exception handler at each level of the call stack hierarchy catches the exception thrown by the next lower-level exception handler. Außerdem weiß jeder Ausnahmehandler, dass die Auflistung, die von Data der-Eigenschaft zurückgegeben wird, einen Satz von Schlüssel-Wert-Paaren enthält, auf die mit einem vordefinierten Satz von Schlüsseln zugegriffen werden kann.In addition, each exception handler knows the collection returned by the Data property contains a set of key/value pairs that can be accessed with a prearranged set of keys.

Jeder Ausnahmehandler verwendet den vordefinierten Satz von Schlüsseln, um die Wert Komponente des entsprechenden Schlüssel-Wert-Paars mit Informationen zu aktualisieren, die für diesen Ausnahmehandler eindeutig sind.Each exception handler uses the prearranged set of keys to update the value component of the corresponding key/value pair with information unique to that exception handler. Nach Abschluss des Aktualisierungs Vorgangs löst der Ausnahmehandler die Ausnahme für den nächsten Ausnahmehandler auf höherer Ebene aus.After the update process is complete, the exception handler throws the exception to the next higher-level exception handler. Schließlich greift der Ausnahmehandler auf der höchsten Ebene auf die Schlüssel-Wert-Paare zu und zeigt die konsolidierten Update Informationen aus allen Ausnahme Handlern auf niedrigerer Ebene an.Finally, the highest level exception handler accesses the key/value pairs and displays the consolidated update information from all the lower-level exception handlers.

Gilt für:

Siehe auch