Exception.SerializeObjectState Olay

Tanım

Dikkat

BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.

Bir özel durum, özel durum hakkında serileştirilmiş veriler içeren bir özel durum nesnesi oluşturmak üzere seri hale getirildiğinde gerçekleşir.

protected:
 event EventHandler<System::Runtime::Serialization::SafeSerializationEventArgs ^> ^ SerializeObjectState;
protected event EventHandler<System.Runtime.Serialization.SafeSerializationEventArgs>? SerializeObjectState;
[System.Obsolete("BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.", DiagnosticId="SYSLIB0011", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected event EventHandler<System.Runtime.Serialization.SafeSerializationEventArgs>? SerializeObjectState;
protected event EventHandler<System.Runtime.Serialization.SafeSerializationEventArgs> SerializeObjectState;
member this.SerializeObjectState : EventHandler<System.Runtime.Serialization.SafeSerializationEventArgs> 
[<System.Obsolete("BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.", DiagnosticId="SYSLIB0011", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
member this.SerializeObjectState : EventHandler<System.Runtime.Serialization.SafeSerializationEventArgs> 
Protected Custom Event SerializeObjectState As EventHandler(Of SafeSerializationEventArgs) 

Olay Türü

EventHandler<SafeSerializationEventArgs>
Öznitelikler

Örnekler

Aşağıdaki örnek, olayı işleyen SerializeObjectState bir BadDivisionException tanımlar. Ayrıca, arabirimini uygulayan ISafeSerializationData adlı BadDivisionExceptionState iç içe bir yapı olan bir durum nesnesi içerir.

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
Imports System.IO
Imports System.Runtime.Serialization
Imports System.Runtime.Serialization.Formatters.Binary
           
Module Example
   Public Sub Main()
      Dim serialized As Boolean = False
      Dim formatter As New BinaryFormatter()
      Dim values() As Double = { 3, 2, 1 }
      Dim divisor As Double = 0
      For Each value In values
         Try
            Dim ex As BadDivisionException = Nothing
            If divisor = 0 Then 
               If Not serialized Then
                  ' Instantiate the exception object.
                  ex = New BadDivisionException(0)
                  ' Serialize the exception object.
                  Dim fs As New FileStream("BadDivision1.dat", 
                                           FileMode.Create)
                  formatter.Serialize(fs, ex)
                  fs.Close()
                  Console.WriteLine("Serialized the exception...")
               Else
                  ' Deserialize the exception.
                  Dim fs As New FileStream("BadDivision1.dat",
                                           FileMode.Open)
                  ex = CType(formatter.Deserialize(fs), BadDivisionException)
                  ' Reserialize the exception.
                  fs.Position = 0
                  formatter.Serialize(fs, ex)
                  fs.Close()
                  Console.WriteLine("Reserialized the exception...")                                            
               End If   
              Throw ex 
            End If 
            Console.WriteLine("{0} / {1} = {1}", value, divisor, value/divisor)
         Catch e As BadDivisionException
            Console.WriteLine("Bad divisor from a {0} exception: {1}",
                              If(serialized, "deserialized", "new"), e.Divisor)             
            serialized = True
         End Try   
      Next
   End Sub
End Module

<Serializable> Public Class BadDivisionException : Inherits Exception
   ' Maintain an internal BadDivisionException state object.
   <NonSerialized> Private state As New BadDivisionExceptionState()

   Public Sub New(divisor As Double)
      state.Divisor = divisor
      HandleSerialization()      
   End Sub
   
   Private Sub HandleSerialization()
      AddHandler SerializeObjectState, 
                 Sub(exception As Object, eventArgs As SafeSerializationEventArgs)
                    eventArgs.AddSerializedState(state)
                 End Sub
   End Sub
   
   Public ReadOnly Property Divisor As Double
      Get
         Return state.Divisor
      End Get      
   End Property

   <Serializable> Private Structure BadDivisionExceptionState 
                                    Implements ISafeSerializationData
      private badDivisor As Double
      
      Public Property Divisor As Double
         Get
            Return badDivisor
         End Get
         Set
            badDivisor = value
         End Set
      End Property 

      Sub CompleteDeserialization(deserialized As Object) _
            Implements ISafeSerializationData.CompleteDeserialization
         Dim ex As BadDivisionException = TryCast(deserialized, BadDivisionException)
         ex.HandleSerialization()
         ex.state = Me 
      End Sub
   End Structure
End Class
' 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

Sıfıra BadDivisionException göre kayan nokta bölme gerçekleştiğinde özel durum oluşturulur. İlk bölme sırasında sıfır, örnek bir BadDivisionException nesne örneği oluşturur, seri hale getirir ve özel durum oluşturur. Sonraki bölmeler sıfır olduğunda, örnek daha önce seri hale getirilmiş nesneyi seri durumdan çıkartır, yeniden seri durumdan alır ve özel durum oluşturur. Nesne serileştirme, seri durumdan çıkarma, seri durumdan çıkarma ve seri durumdan çıkarma sağlamak için, örnek olay işleyicisini SerializeObjectState hem sınıf oluşturucusunda BadDivisionException ISafeSerializationData.CompleteDeserialization hem de uygulamada ekler.

Açıklamalar

Özel durum nesnesi arabirimini ISafeSerializationData uygular.

SerializeObjectState Olay abone olduğunda, özel durum seri durumdan çıkarılır ve boş bir özel durum olarak oluşturulur. Özel durumun oluşturucusu çalıştırılmaz ve özel durum durumu da seri durumdan çıkarılır. Özel CompleteDeserialization durum nesnesinin geri çağırma yöntemi daha sonra seri durumdan çıkarılmış verileri boş özel duruma gönderebilecek şekilde bildirilir.

Olay, SerializeObjectState saydam özel durum türlerinin özel durum verilerini seri hale getirmesine ve seri durumdan çıkarmasına olanak tanır. Saydam kod, içinde çalışmakta olduğu izin kümesinin sınırları içinde komutları yürütebilir, ancak yürütemez, çağıramaz, türetilemez veya kritik kod içeremez.

SerializeObjectState Olay abone değilse, seri durumdan çıkarma oluşturucu kullanılarak Exception her zamanki gibi gerçekleşir.

Genellikle, serileştirme sağlamak SerializeObjectState için özel durumun oluşturucusunda olay işleyicisi eklenir. Ancak, olay işleyicisi yürütürken oluşturucu yürütülmediğinden SerializeObjectState , seri durumdan çıkarılmış bir özel durumun seri hale getirildiğinde özel durumu seri durumdan çıkarmaya çalıştığınızda bir SerializationException özel durum oluşturabilir. Bunu önlemek için, yönteminde olayın ISafeSerializationData.CompleteDeserialization işleyicisini SerializeObjectState de eklemeniz gerekir. Çizim için Örnekler bölümüne bakın.

Devralanlara Notlar

Bu olay abone olursa ve kullanılıyorsa, devralma hiyerarşisinde izleyen tüm türetilmiş türlerin aynı serileştirme mekanizmasını uygulaması gerekir.

Şunlara uygulanır