Exception.Data Özellik

Tanım

Özel durum hakkında ek kullanıcı tanımlı bilgiler sağlayan anahtar/değer çiftleri koleksiyonunu alır.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

Özellik Değeri

IDictionary arabirimini uygulayan ve Kullanıcı tanımlı anahtar/değer çiftleri koleksiyonu içeren bir nesne.An object that implements the IDictionary interface and contains a collection of user-defined key/value pairs. Varsayılan değer boş bir topluluktur.The default is an empty collection.

Örnekler

Aşağıdaki örnek, Data özelliğini kullanarak bilgilerin nasıl ekleneceğini ve alınacağını gösterir.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. 

Açıklamalar

Özel durumla ilgili ek bilgileri depolamak ve almak için Data özelliği tarafından döndürülen System.Collections.IDictionary nesnesini kullanın.Use the System.Collections.IDictionary object returned by the Data property to store and retrieve supplementary information relevant to the exception. Bilgiler, Kullanıcı tanımlı rastgele anahtar/değer çiftleri biçiminde olur.The information is in the form of an arbitrary number of user-defined key/value pairs. Her anahtar/değer çiftinin anahtar bileşeni genellikle tanımlayan bir dizedir, ancak çiftin değer bileşeni herhangi bir nesne türü olabilir.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.

Anahtar/Değer Çifti GüvenliğiKey/Value Pair Security

Data özelliği tarafından döndürülen koleksiyonda depolanan anahtar/değer çiftleri güvenli değildir.The key/value pairs stored in the collection returned by the Data property are not secure. Uygulamanız iç içe geçmiş bir yordam dizisini çağırırsa ve her bir yordam özel durum işleyicileri içeriyorsa, sonuçta elde edilen çağrı yığını bu özel durum işleyicilerinin hiyerarşisini içerir.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. Alt düzey bir yordam bir özel durum oluşturursa, çağrı yığını hiyerarşisindeki herhangi bir üst düzey özel durum işleyicisi, başka bir özel durum işleyicisi tarafından koleksiyonda depolanan anahtar/değer çiftlerini okuyabilir ve/veya değiştirebilir.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. Bu, anahtar/değer çiftlerinde bulunan bilgilerin gizli olmadığını ve anahtar/değer çiftindeki bilgiler bozuksa uygulamanızın doğru şekilde çalışacağını garanti etmeniz gerektiği anlamına gelir.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.

Anahtar ÇakışmalarıKey Conflicts

Farklı özel durum işleyicileri bir anahtar/değer çiftine erişmek için aynı anahtarı belirtmediğinde, anahtar çakışması oluşur.A key conflict occurs when different exception handlers specify the same key to access a key/value pair. Uygulamanızı geliştirirken dikkatli olun, çünkü bir anahtar çakışmasının sonucu alt düzey özel durum işleyicilerinin daha yüksek düzey özel durum işleyicileriyle yanlışlıkla iletişim kurabildiğinden ve bu iletişim, hafif program hatalarına neden olabilir.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. Ancak, dikkatli değilseniz uygulamanızı geliştirmek için anahtar çakışmalarını kullanabilirsiniz.However, if you are cautious you can use key conflicts to enhance your application.

Anahtar Çakışmalarını ÖnlemeAvoiding Key Conflicts

Anahtar/değer çiftleri için benzersiz anahtarlar oluşturmak üzere bir adlandırma kuralı benimseerek anahtar çakışmalarını önleyin.Avoid key conflicts by adopting a naming convention to generate unique keys for key/value pairs. Örneğin, bir adlandırma kuralı, uygulamanızın noktayla ayrılmış adından, çift için ek bilgiler sağlayan yönteme ve benzersiz bir tanımlayıcıya sahip bir anahtar sağlayabilir.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.

Ürünler ve tedarikçiler adlı iki uygulamanın Sales adlı bir yöntemi olduğunu varsayalım.Suppose two applications, named Products and Suppliers, each has a method named Sales. Products uygulamasındaki Sales yöntemi, bir ürünün kimlik numarasını (stok tutma birimi veya SKU 'SU) sağlar.The Sales method in the Products application provides the identification number (the stock keeping unit or SKU) of a product. Suppliers uygulamasındaki Sales yöntemi, bir tedarikçinin kimlik numarasını veya SID 'sini sağlar.The Sales method in the Suppliers application provides the identification number, or SID, of a supplier. Sonuç olarak, bu örneğe ilişkin adlandırma kuralı, "Products. Sales. SKU" ve "Suppliers. Sales. SID" anahtarlarını verir.Consequently, the naming convention for this example yields the keys, "Products.Sales.SKU" and "Suppliers.Sales.SID".

Anahtar Çakışması Açığından YararlanmaExploiting Key Conflicts

İşlemeyi denetlemek için bir veya daha fazla özel, önceden düzenlenmiş anahtarlar varlığını kullanarak anahtar çakışmalarını yararlanma.Exploit key conflicts by using the presence of one or more special, prearranged keys to control processing. Tek bir senaryoda, çağrı yığını hiyerarşisindeki en yüksek düzey özel durum işleyicisinin alt düzey özel durum işleyicileri tarafından oluşturulan tüm özel durumları yakalar olduğunu varsayalım.Suppose, in one scenario, the highest level exception handler in the call stack hierarchy catches all exceptions thrown by lower-level exception handlers. Özel bir anahtara sahip bir anahtar/değer çifti varsa, üst düzey özel durum işleyicisi IDictionary nesnesindeki kalan anahtar/değer çiftlerini bazı standart olmayan yollardan biçimlendirir; Aksi takdirde, kalan anahtar/değer çiftleri normal şekilde biçimlendirilir.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.

Artık başka bir senaryoda, çağrı yığını hiyerarşisinin her düzeyindeki özel durum işleyicisinin, sonraki alt düzey özel durum işleyicisi tarafından oluşturulan özel durumu yakalar.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. Ayrıca, her bir özel durum işleyicisi Data özelliği tarafından döndürülen koleksiyonun, önceden düzenlenmiş anahtarlar kümesiyle erişilebilen bir anahtar/değer çiftleri kümesi içerdiğini bilir.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.

Her özel durum işleyicisi, ilgili anahtar/değer çiftinin değer bileşenini bu özel durum işleyicisine özgü bilgilerle güncelleştirmek için önceden düzenlenmiş anahtar kümesini kullanır.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. Güncelleştirme işlemi tamamlandıktan sonra, özel durum işleyicisi bir sonraki üst düzey özel durum işleyicisine özel durumu atar.After the update process is complete, the exception handler throws the exception to the next higher-level exception handler. Son olarak, en yüksek düzey özel durum işleyicisi anahtar/değer çiftlerine erişir ve tüm alt düzey özel durum işleyicilerinden birleştirilmiş güncelleştirme bilgilerini görüntüler.Finally, the highest level exception handler accesses the key/value pairs and displays the consolidated update information from all the lower-level exception handlers.

Şunlara uygulanır

Ayrıca bkz.