Exception.Data Proprietà

Definizione

Ottiene una raccolta di coppie chiave/valore che forniscono informazioni definite dall'utente aggiuntive sull'eccezione.

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à

IDictionary

Oggetto che implementa l'interfaccia IDictionary e contiene una raccolta di coppie chiave/valore definite dall'utente. Il valore predefinito è una raccolta vuota.

Esempio

Nell'esempio seguente viene illustrato come aggiungere e recuperare informazioni utilizzando la Data proprietà .

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

Utilizzare System.Collections.IDictionary l'oggetto restituito dalla Data proprietà per archiviare e recuperare le informazioni supplementari relative all'eccezione. Le informazioni sono sotto forma di un numero arbitrario di coppie chiave/valore definite dall'utente. Il componente chiave di ogni coppia chiave/valore è in genere una stringa di identificazione, mentre il componente valore della coppia può essere qualsiasi tipo di oggetto.

Sicurezza coppia chiave/valore

Le coppie chiave/valore archiviate nella raccolta restituita dalla Data proprietà non sono sicure. Se l'applicazione chiama una serie annidata di routine e ogni routine contiene gestori di eccezioni, lo stack di chiamate risultante contiene una gerarchia di tali gestori di eccezioni. Se una routine di livello inferiore genera un'eccezione, qualsiasi gestore di eccezioni di livello superiore nella gerarchia dello stack di chiamate può leggere e/o modificare le coppie chiave/valore archiviate nella raccolta da qualsiasi altro gestore di eccezioni. Ciò significa che è necessario garantire che le informazioni nelle coppie chiave/valore non siano riservate e che l'applicazione funzionerà correttamente se le informazioni nelle coppie chiave/valore sono danneggiate.

Conflitti di chiave

Si verifica un conflitto di chiave quando gestori di eccezioni diversi specificano la stessa chiave per accedere a una coppia chiave/valore. Prestare attenzione quando si sviluppa l'applicazione perché la conseguenza di un conflitto di chiavi è che i gestori di eccezioni di livello inferiore possono comunicare inavvertitamente con i gestori di eccezioni di livello superiore e questa comunicazione potrebbe causare piccoli errori di programma. Tuttavia, se si è cauti, è possibile usare i conflitti di chiave per migliorare l'applicazione.

Evitare conflitti di chiave

Evitare conflitti di chiave adottando una convenzione di denominazione per generare chiavi univoche per coppie chiave/valore. Ad esempio, una convenzione di denominazione potrebbe produrre una chiave costituita dal nome delimitato da punti dell'applicazione, dal metodo che fornisce informazioni supplementari per la coppia e da un identificatore univoco.

Si supponga che due applicazioni, denominate Products e Suppliers, ognuna abbia un metodo denominato Sales. Il metodo Sales nell'applicazione Products fornisce il numero di identificazione (unità di mantenimento delle scorte o SKU) di un prodotto. Il metodo Sales nell'applicazione Suppliers fornisce il numero di identificazione, o SID, di un fornitore. Di conseguenza, la convenzione di denominazione per questo esempio restituisce le chiavi "Products.Sales.SKU" e "Suppliers.Sales.SID".

Exploit dei conflitti di chiave

Sfruttare i conflitti di chiave usando la presenza di una o più chiavi speciali e preastazionate per controllare l'elaborazione. Si supponga, in uno scenario, che il gestore eccezioni di livello più alto nella gerarchia dello stack di chiamate intercetti tutte le eccezioni generate dai gestori di eccezioni di livello inferiore. Se esiste una coppia chiave/valore con una chiave speciale, il gestore eccezioni di alto livello formatta le coppie chiave/valore rimanenti nell'oggetto in modo non standard; in caso contrario, le coppie chiave/valore rimanenti vengono formattate in modo IDictionary normale.

Si supponga ora che, in un altro scenario, il gestore di eccezioni a ogni livello della gerarchia dello stack di chiamate intercetti l'eccezione generata dal gestore di eccezioni di livello inferiore successivo. Inoltre, ogni gestore di eccezioni sa che la raccolta restituita dalla proprietà contiene un set di coppie chiave/valore a cui è possibile accedere con un set pre-predefinito Data di chiavi.

Ogni gestore di eccezioni usa il set prearranged di chiavi per aggiornare il componente valore della coppia chiave/valore corrispondente con informazioni univoche per tale gestore di eccezioni. Al termine del processo di aggiornamento, il gestore di eccezioni genera l'eccezione al gestore di eccezioni di livello superiore successivo. Infine, il gestore di eccezioni di livello superiore accede alle coppie chiave/valore e visualizza le informazioni di aggiornamento consolidate da tutti i gestori di eccezioni di livello inferiore.

Si applica a

Vedi anche