Exception.Data Właściwość

Definicja

Pobiera kolekcję par klucz/wartość, które zawierają dodatkowe informacje zdefiniowane przez użytkownika dotyczące wyjątku.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

Wartość właściwości

Obiekt, który implementuje IDictionary interfejs i zawiera kolekcję par klucz/wartość zdefiniowanych przez użytkownika.An object that implements the IDictionary interface and contains a collection of user-defined key/value pairs. Wartością domyślną jest pusta kolekcja.The default is an empty collection.

Przykłady

Poniższy przykład ilustruje sposób dodawania i pobierania informacji przy użyciu Data właściwości.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. 

Uwagi

Użyj obiektu zwróconego przez właściwość w celu przechowywania i pobierania informacji dodatkowych dotyczących wyjątku. Data System.Collections.IDictionaryUse the System.Collections.IDictionary object returned by the Data property to store and retrieve supplementary information relevant to the exception. Informacje są w postaci dowolnej liczby par klucz-wartość zdefiniowanych przez użytkownika.The information is in the form of an arbitrary number of user-defined key/value pairs. Najważniejszym składnikiem pary klucz/wartość jest zazwyczaj ciąg identyfikacyjny, natomiast składnik wartości pary może być dowolnym typem obiektu.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.

Zabezpieczenia pary klucz/wartośćKey/Value Pair Security

Pary klucz/wartość przechowywane w kolekcji zwróconej przez Data właściwość nie są bezpieczne.The key/value pairs stored in the collection returned by the Data property are not secure. Jeśli aplikacja wywołuje zagnieżdżoną serię procedur, a każda procedura zawiera obsługę wyjątków, powstaje stos wywołań zawiera hierarchię programów obsługi wyjątków.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. Jeśli procedura niższego poziomu zgłasza wyjątek, każdy program obsługi wyjątków najwyższego poziomu w hierarchii stosu wywołań może odczytać i/lub zmodyfikować pary klucz/wartość przechowywane w kolekcji przez dowolną inną procedurę obsługi wyjątków.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. Oznacza to, że należy zagwarantować, że informacje w parach klucz/wartość nie są poufne i że aplikacja będzie działać prawidłowo, jeśli informacje w parach klucz/wartość są uszkodzone.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.

Konflikty kluczaKey Conflicts

Konflikt klucza występuje, gdy różne programy obsługi wyjątków określają ten sam klucz, aby uzyskać dostęp do pary klucz/wartość.A key conflict occurs when different exception handlers specify the same key to access a key/value pair. Należy zachować ostrożność podczas opracowywania aplikacji, ponieważ występuje konflikt klucza, że programy obsługi wyjątków niższego poziomu mogą przypadkowo komunikować się z obsługą wyjątków wyższego poziomu, a ta komunikacja może spowodować drobne błędy programu.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. Jednak jeśli jest to ostrożne, można użyć konfliktów kluczy do udoskonalenia aplikacji.However, if you are cautious you can use key conflicts to enhance your application.

Unikanie konfliktów kluczaAvoiding Key Conflicts

Unikaj konfliktów kluczowych przez przyjęcie konwencji nazewnictwa w celu wygenerowania unikatowych kluczy dla par klucz/wartość.Avoid key conflicts by adopting a naming convention to generate unique keys for key/value pairs. Na przykład Konwencja nazewnictwa może dać klucz, który składa się z rozdzielanej kropką nazwy aplikacji, metody, która zawiera dodatkowe informacje dla pary i unikatowy identyfikator.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.

Załóżmy, że dwie aplikacje, nazwane produkty i dostawcy, mają metodę o nazwie Sales.Suppose two applications, named Products and Suppliers, each has a method named Sales. Metoda Sales w aplikacji Products zawiera numer identyfikacyjny (jednostka magazynowa lub SKU) produktu.The Sales method in the Products application provides the identification number (the stock keeping unit or SKU) of a product. Metoda Sales w aplikacji dostawcy udostępnia numer identyfikacyjny lub identyfikator SID dostawcy.The Sales method in the Suppliers application provides the identification number, or SID, of a supplier. W związku z tym, Konwencja nazewnictwa dla tego przykładu daje klucze "Products. Sales. SKU" i "dostawcy. Sales. SID".Consequently, the naming convention for this example yields the keys, "Products.Sales.SKU" and "Suppliers.Sales.SID".

Wykorzystanie konfliktów kluczaExploiting Key Conflicts

Luki w zabezpieczeniach z wykorzystaniem klucza wykorzystującego jeden lub więcej specjalnych, nastawianych kluczy do sterowania przetwarzaniem.Exploit key conflicts by using the presence of one or more special, prearranged keys to control processing. Załóżmy, że w jednym scenariuszu program obsługi wyjątków najwyższego poziomu w hierarchii stosu wywołań przechwytuje wszystkie wyjątki zgłoszone przez programy obsługi wyjątków niższego poziomu.Suppose, in one scenario, the highest level exception handler in the call stack hierarchy catches all exceptions thrown by lower-level exception handlers. Jeśli istnieje para klucz/wartość z kluczem specjalnym, program obsługi wyjątków wysokiego poziomu formatuje pozostałe pary klucz/wartość w IDictionary obiekcie w niestandardowym trybie; w przeciwnym razie pozostałe pary klucz/wartość są sformatowane w zwykły sposób.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.

Teraz Załóżmy, że w innym scenariuszu program obsługi wyjątków na każdym poziomie hierarchii stosu wywołań przechwytuje wyjątek zgłoszony przez następną procedurę obsługi wyjątków niższego poziomu.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. Ponadto każdy program obsługi wyjątków wie, że Kolekcja zwracana przez Data Właściwość zawiera zestaw par klucz/wartość, do których można uzyskać dostęp przy użyciu premieszczonego zestawu kluczy.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.

Każdy program obsługi wyjątków używa wstępnie utworzonego zestawu kluczy, aby zaktualizować składnik wartości odpowiedniej pary klucz/wartość z informacjami unikatowymi dla tego programu obsługi wyjątków.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. Po zakończeniu procesu aktualizacji procedura obsługi wyjątków zgłasza wyjątek do następnego programu obsługi wyjątków wyższego poziomu.After the update process is complete, the exception handler throws the exception to the next higher-level exception handler. Na koniec program obsługi wyjątków najwyższego poziomu uzyskuje dostęp do par klucz/wartość i wyświetla skonsolidowane informacje o aktualizacji ze wszystkich programów obsługi wyjątków niższego poziomu.Finally, the highest level exception handler accesses the key/value pairs and displays the consolidated update information from all the lower-level exception handlers.

Dotyczy

Zobacz też