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

Definición

Obtiene una colección de pares clave-valor que proporcionan más información definida por el usuario sobre la excepción.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

Valor de propiedad

Objeto que implementa la interfaz de IDictionary y contiene una colección de pares clave-valor definidos por el usuario.An object that implements the IDictionary interface and contains a collection of user-defined key/value pairs. El valor predeterminado es una colección vacía.The default is an empty collection.

Ejemplos

En el ejemplo siguiente se muestra cómo agregar y recuperar información mediante el Data propiedad.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. 

Comentarios

Use la System.Collections.IDictionary objeto devuelto por la Data propiedad para almacenar y recuperar información adicional relativa a la excepción.Use the System.Collections.IDictionary object returned by the Data property to store and retrieve supplementary information relevant to the exception. La información está en forma de un número arbitrario de pares clave/valor definidos por el usuario.The information is in the form of an arbitrary number of user-defined key/value pairs. El componente clave de cada par clave/valor normalmente es una cadena de identificación, mientras que el componente de valor del par puede ser cualquier tipo de objeto.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.

Seguridad de par clave/valorKey/Value Pair Security

Los pares clave/valor almacenados en la colección devuelta por la Data propiedad no son seguras.The key/value pairs stored in the collection returned by the Data property are not secure. Si la aplicación llama a una serie de rutinas anidadas y cada rutina contiene controladores de excepciones, la pila de llamadas resultante contiene una jerarquía de esos controladores de excepciones.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. Si una rutina de nivel inferior, produce una excepción, cualquier controlador de excepciones de nivel superior en la jerarquía de la pila de llamadas puede leer o modificar los pares clave/valor almacenados en la colección por cualquier otro controlador de excepción.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. Esto significa que debe garantizar que la información de los pares clave/valor no es confidencial y que la aplicación funcionará correctamente si se daña la información de los pares clave/valor.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.

Conflictos de claveKey Conflicts

Se produce un conflicto de clave cuando los controladores de excepciones diferentes especifican la misma clave para tener acceso a un par clave/valor.A key conflict occurs when different exception handlers specify the same key to access a key/value pair. Tenga cuidado al desarrollar la aplicación porque la consecuencia de un conflicto de clave es que los controladores de excepciones de nivel inferior pueden comunicarse sin darse cuenta con controladores de excepciones de nivel superior, y esta comunicación podría provocar errores sutiles del programa.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. Sin embargo, si está presente conflictos de clave puede usar para mejorar su aplicación.However, if you are cautious you can use key conflicts to enhance your application.

Evitar conflictos de claveAvoiding Key Conflicts

Evitar conflictos de clave al adoptar una convención de nomenclatura para generar claves únicas para los pares clave/valor.Avoid key conflicts by adopting a naming convention to generate unique keys for key/value pairs. Por ejemplo, podría producir una convención de nomenclatura una clave que consta del nombre de la aplicación delimitados, el método que proporciona información complementaria para el par y un identificador único.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.

Supongamos que dos aplicaciones, denominadas productos y proveedores, cada uno tiene un método denominado ventas.Suppose two applications, named Products and Suppliers, each has a method named Sales. El método de ventas de la aplicación productos proporciona el número de identificación (las existencias o SKU) de un producto.The Sales method in the Products application provides the identification number (the stock keeping unit or SKU) of a product. El método de ventas en la aplicación de proveedores proporciona el número de identificación o SID de un proveedor.The Sales method in the Suppliers application provides the identification number, or SID, of a supplier. Por lo tanto, la convención de nomenclatura para este ejemplo produce las claves "Productos.ventas.SKU" y "Proveedores.ventas.SID".Consequently, the naming convention for this example yields the keys, "Products.Sales.SKU" and "Suppliers.Sales.SID".

Aprovechamiento de conflictos de claveExploiting Key Conflicts

Aprovechar los conflictos de clave mediante el uso de la presencia de una o más teclas especiales, concertados de antemano para controlar el procesamiento.Exploit key conflicts by using the presence of one or more special, prearranged keys to control processing. Supongamos que, en un escenario, el controlador de excepciones de nivel más alto en la jerarquía de la pila de llamadas detecta todas las excepciones producidas por controladores de excepciones de nivel inferior.Suppose, in one scenario, the highest level exception handler in the call stack hierarchy catches all exceptions thrown by lower-level exception handlers. Si existe un par clave/valor con una clave especial, el controlador de excepciones de alto nivel da formato a los pares clave/valor restantes en el IDictionary objeto de algún modo no estándar; de lo contrario, se da formato a los pares clave/valor restante de alguna manera normal.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.

Ahora supongamos, en otro escenario, que el controlador de excepciones en cada nivel de la jerarquía de la pila de llamadas detecta la excepción producida por el siguiente controlador de excepciones de nivel inferior.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. Además, cada controlador de excepciones sabe la colección devuelta por la Data propiedad contiene un conjunto de pares clave/valor que se puede acceder con un conjunto de claves predeterminado.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.

Cada controlador de excepción usa el conjunto de claves concertados de antemano para actualizar el componente de valor del par clave/valor correspondiente con información única para ese controlador de excepciones.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. Una vez completado el proceso de actualización, el controlador de excepciones inicia la excepción en el siguiente controlador de excepciones de nivel superior.After the update process is complete, the exception handler throws the exception to the next higher-level exception handler. Por último, el controlador de excepciones de nivel más alto obtiene acceso a los pares clave/valor y muestra la información de actualización consolidado de todos los controladores de excepciones de nivel inferior.Finally, the highest level exception handler accesses the key/value pairs and displays the consolidated update information from all the lower-level exception handlers.

Se aplica a

Consulte también: