Exception.Data Exception.Data Exception.Data Exception.Data Property

Definizione

Ottiene una raccolta di coppie chiave-valore che fornisce informazioni aggiuntive definite dall'utente relative all'eccezione. 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

Valore della proprietà

Oggetto che implementa l'interfaccia IDictionary e contiene una raccolta di coppie chiave/valore definite dall'utente. An object that implements the IDictionary interface and contains a collection of user-defined key/value pairs. Il valore predefinito è una raccolta vuota. The default is an empty collection.

Esempi

Nell'esempio seguente viene illustrato come aggiungere e recuperare informazioni usando il Data proprietà.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. 

Commenti

Usare la System.Collections.IDictionary oggetto restituito dal Data proprietà per archiviare e recuperare informazioni supplementari relative all'eccezione.Use the System.Collections.IDictionary object returned by the Data property to store and retrieve supplementary information relevant to the exception. Le informazioni sono sotto forma di un numero arbitrario di coppie chiave/valore definite dall'utente.The information is in the form of an arbitrary number of user-defined key/value pairs. Il componente principale di ogni coppia chiave/valore è in genere una stringa di identificazione, mentre il componente valore della coppia può essere qualsiasi tipo di oggetto.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.

Sicurezza della coppia chiave/valoreKey/Value Pair Security

Le coppie chiave/valore archiviate nella raccolta restituita dal Data proprietà non sono sicure.The key/value pairs stored in the collection returned by the Data property are not secure. Se l'applicazione chiama una serie di routine annidata e ogni routine contiene i gestori di eccezioni, lo stack di chiamate risultante contiene una gerarchia di tali gestori di eccezioni.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. Se una routine di basso livello genera un'eccezione, qualsiasi gestore di eccezioni di livello superiore nella gerarchia di stack di chiamate possa leggere e/o modificare le coppie chiave/valore archiviate nella raccolta da qualsiasi altro gestore di eccezioni.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. Ciò significa che è necessario garantire che le informazioni contenute in coppie chiave/valore non sono riservate e che l'applicazione funzionerà correttamente se le informazioni nelle coppie chiave/valore sono danneggiate.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.

Conflitti di chiaveKey Conflicts

Quando i gestori di eccezioni diverse specificano la stessa chiave per accedere a una coppia chiave/valore, si verifica un conflitto di chiave.A key conflict occurs when different exception handlers specify the same key to access a key/value pair. Prestare attenzione quando si sviluppa l'applicazione perché la conseguenza di un conflitto di chiave è che i gestori di eccezioni di livello inferiore inavvertitamente possono comunicare con gestori di eccezioni di livello superiore, mentre questa comunicazione può causare errori di programma sottili.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. Tuttavia, se si ha la massima attenzione è possibile utilizzare i conflitti di chiave per migliorare l'applicazione.However, if you are cautious you can use key conflicts to enhance your application.

Come evitare conflitti di chiaviAvoiding Key Conflicts

Per evitare conflitti principali, adottare una convenzione di denominazione per generare le chiavi univoche per le coppie chiave/valore.Avoid key conflicts by adopting a naming convention to generate unique keys for key/value pairs. Ad esempio, una convenzione di denominazione potrebbe generare una chiave costituita dal nome separati da punti dell'applicazione, il metodo che fornisce informazioni aggiuntive per la coppia e un identificatore univoco.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.

Si supponga che due applicazioni, denominate prodotti e fornitori, ognuno ha un metodo denominato Sales.Suppose two applications, named Products and Suppliers, each has a method named Sales. Il metodo di vendite nell'applicazione prodotti fornisce il numero di identificazione (stock keeping unit o SKU) di un prodotto.The Sales method in the Products application provides the identification number (the stock keeping unit or SKU) of a product. Il metodo di vendite nell'applicazione Suppliers fornisce il numero di identificazione o SID, di un fornitore.The Sales method in the Suppliers application provides the identification number, or SID, of a supplier. Di conseguenza, la convenzione di denominazione per questo esempio restituisce le chiavi, "Prodotti.vendite.SKU" e "Fornitori.vendite.SID".Consequently, the naming convention for this example yields the keys, "Products.Sales.SKU" and "Suppliers.Sales.SID".

Sfruttamento delle chiavi è in conflittoExploiting Key Conflicts

Sfruttare i conflitti di chiave utilizzando la presenza di uno o più tasti speciali, preordinate per controllare l'elaborazione.Exploit key conflicts by using the presence of one or more special, prearranged keys to control processing. Si supponga che, in uno scenario, il gestore di eccezioni di livello più alto nella gerarchia di stack di chiamate intercetta tutte le eccezioni generate da gestori di eccezioni di livello inferiore.Suppose, in one scenario, the highest level exception handler in the call stack hierarchy catches all exceptions thrown by lower-level exception handlers. Se è presente una coppia chiave/valore con una chiave speciale, il gestore di eccezioni di alto livello formatta le coppie chiave/valore rimanenti nel IDictionary oggetto in qualche modo conforme allo standard; in caso contrario, le coppie chiave/valore rimanenti vengono formattate in modo normale.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.

Ora si supponga che, in un altro scenario, il gestore di eccezioni a ogni livello della gerarchia dello stack di chiamate intercetta l'eccezione generata dal gestore di eccezioni di livello inferiore successivo.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. Inoltre, ogni gestore eccezioni conosce la raccolta restituita dal Data proprietà contiene un set di coppie chiave/valore che è possibile accedere con un set di chiavi preordinato.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.

Ogni gestore eccezioni utilizza il set di chiavi preordinato per aggiornare il componente valore della coppia chiave/valore corrispondente con informazioni univoche per il gestore di eccezioni.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. Al termine del processo di aggiornamento, il gestore di eccezioni genera l'eccezione per il gestore di eccezioni di livello superiore successivo.After the update process is complete, the exception handler throws the exception to the next higher-level exception handler. Infine, il gestore di eccezioni di livello più alto accede le coppie chiave/valore e visualizza le informazioni sugli aggiornamenti consolidati da tutti i gestori di eccezioni di livello inferiore.Finally, the highest level exception handler accesses the key/value pairs and displays the consolidated update information from all the lower-level exception handlers.

Si applica a

Vedi anche