Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Exception.SerializeObjectState-Ereignis

.NET Framework (current version)
 

Veröffentlicht: Oktober 2016

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt zu erstellen, das serialisierte Daten für die Ausnahme enthält.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

protected event EventHandler<SafeSerializationEventArgs> SerializeObjectState

Die Ausnahmezustandsobjekt implementiert die ISafeSerializationData Schnittstelle.

Wenn die SerializeObjectState Ereignis abonniert ist, wird die Ausnahme deserialisiert und als leere Ausnahme erstellt. Der Konstruktor der Ausnahme nicht ausgeführt wird, und Ausnahmezustand auch deserialisiert wird. Die CompleteDeserialization Rückrufmethode des Ausnahmeobjekts Zustand wird dann benachrichtigt, damit es deserialisierte Daten in die leere Ausnahme per Push übertragen kann.

Die SerializeObjectState -Ereignis können transparente Ausnahmetypen zum Serialisieren und Deserialisieren der Ausnahmedaten. Transparenter Code kann Ausführungsbefehle innerhalb der Grenzen des Berechtigungssatzes, in denen sie innerhalb dieser ausgeführt wird, aber kann nicht ausgeführt, aufzurufen, abgeleitet oder kritischen Code enthalten.

Wenn die SerializeObjectState Ereignis nicht abonniert ist, tritt die Deserialisierung wie gewohnt mithilfe der Exception Konstruktor.

In der Regel einen Handler für das SerializeObjectState Ereignis im Konstruktor bereit, die Serialisierung der Ausnahme hinzugefügt wird. Weil der Konstruktor, nicht ist jedoch ausgeführt wird, wenn die SerializeObjectState -Ereignishandler ausgeführt wird, serialisieren eine deserialisierte Ausnahme auslösen kann eine SerializationException -Ausnahme aus, wenn Sie versuchen, die Ausnahme zu deserialisieren. Um dies zu vermeiden, sollten Sie auch den Handler für Hinzufügen der SerializeObjectState Ereignis in der ISafeSerializationData.CompleteDeserialization Methode. Finden Sie im Abschnitt Beispiele veranschaulicht.

Hinweise für Implementierer:

Wenn dieses Ereignis abonniert und verwendet wird, müssen alle abgeleitete Typen, die in der Vererbungshierarchie folgen denselben Serialisierungsmechanismus implementieren.

Das folgende Beispiel definiert eine BadDivisionException , verarbeitet die SerializeObjectState Ereignis. Es enthält auch ein Zustandsobjekt, also eine geschachtelte Struktur mit dem Namen BadDivisionExceptionState , implementiert die ISafeSerializationData Schnittstelle.

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class Example
{
   public static void Main()
   {
      bool serialized = false;
      var formatter = new BinaryFormatter();
      Double[] values = { 3, 2, 1 };
      Double divisor = 0;
      foreach (var value in values) {
         try {
            BadDivisionException ex = null;
            if (divisor == 0) { 
               if (! serialized) {
                  // Instantiate the exception object.
                  ex = new BadDivisionException(0);
                  // Serialize the exception object.
                  var fs = new FileStream("BadDivision1.dat", 
                                           FileMode.Create);
                  formatter.Serialize(fs, ex);
                  fs.Close();
                  Console.WriteLine("Serialized the exception...");
               }
               else {
                  // Deserialize the exception.
                  var fs = new FileStream("BadDivision1.dat",
                                           FileMode.Open);
                  ex = (BadDivisionException) formatter.Deserialize(fs);
                  // Reserialize the exception.
                  fs.Position = 0;
                  formatter.Serialize(fs, ex);
                  fs.Close();
                  Console.WriteLine("Reserialized the exception...");                                            
               }   
              throw ex; 
            } 
            Console.WriteLine("{0} / {1} = {1}", value, divisor, value/divisor);
         }   
         catch (BadDivisionException e) {
            Console.WriteLine("Bad divisor from a {0} exception: {1}",
                              serialized ? "deserialized" : "new", e.Divisor);             
            serialized = true;
         }   
      }
   }
}

[Serializable] public class BadDivisionException : Exception
{
   // Maintain an internal BadDivisionException state object.
   [NonSerialized] private BadDivisionExceptionState state = new BadDivisionExceptionState();

   public BadDivisionException(Double divisor)
   {
      state.Divisor = divisor;
      HandleSerialization();      
   }

   private void HandleSerialization()
   {
      SerializeObjectState += delegate(object exception, SafeSerializationEventArgs eventArgs) 
                                      { 
                                          eventArgs.AddSerializedState(state);
                                      };
   }

   public Double Divisor
   { get { return state.Divisor; } }

   [Serializable] private struct BadDivisionExceptionState : ISafeSerializationData 
   {
      private Double badDivisor;

      public Double Divisor
      { get { return badDivisor; } 
        set { badDivisor = value; } }

      void ISafeSerializationData.CompleteDeserialization(object deserialized)
      { 
         var ex = deserialized as BadDivisionException;
         ex.HandleSerialization();
         ex.state = this; 
      }
   }
}
// The example displays the following output:
//       Serialized the exception...
//       Bad divisor from a new exception: 0
//       Reserialized the exception...
//       Bad divisor from a deserialized exception: 0
//       Reserialized the exception...
//       Bad divisor from a deserialized exception: 0

The BadDivisionException exception is thrown when a floating-point division by zero occurs. During the first division by zero, the example instantiates a BadDivisionException object, serializes it, and throws the exception. When subsequent divisions by zero occur, the example deserializes the previously serialized object, reserializes it, and throws the exception. To provide for object serialization, deserialization, reserialization, and deserialization, the example adds the E:System.Exception.SerializeObjectState event handler both in the BadDivisionException class constructor and in the M:System.Runtime.Serialization.ISafeSerializationData.CompleteDeserialization(System.Object) implementation.

.NET Framework
Verfügbar seit 4.0
Zurück zum Anfang
Anzeigen: