Exception.SerializeObjectState 이벤트

정의

예외에 대한 serialize된 데이터가 들어 있는 예외 상태 개체가 만들어지도록 예외가 serialize될 때 발생합니다.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

protected:
 event EventHandler<System::Runtime::Serialization::SafeSerializationEventArgs ^> ^ SerializeObjectState;
protected event EventHandler<System.Runtime.Serialization.SafeSerializationEventArgs> SerializeObjectState;
member this.SerializeObjectState : EventHandler<System.Runtime.Serialization.SafeSerializationEventArgs> 
Protected Custom Event SerializeObjectState As EventHandler(Of SafeSerializationEventArgs) 

예제

다음 예제에서는 정의 BadDivisionException 처리 하는 SerializeObjectState 이벤트.The following example defines a BadDivisionException that handles the SerializeObjectState event. 또한 중첩 된 상태 개체를 포함 라는 구조 BadDivisionExceptionState 구현 하는 ISafeSerializationData 인터페이스입니다.It also contains a state object, which is a nested structure named BadDivisionExceptionState that implements the ISafeSerializationData interface.

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

BadDivisionException 0으로 부동 소수점 나누기가 발생 하는 경우 예외가 throw 됩니다.The BadDivisionException exception is thrown when a floating-point division by zero occurs. 이 예제에서는 0으로 첫 번째 나누기에서 하는 동안 인스턴스화합니다를 BadDivisionException 개체를 serialize 하 고 예외를 throw 합니다.During the first division by zero, the example instantiates a BadDivisionException object, serializes it, and throws the exception. 후속 부서 0으로 발생 하는 경우이 예제에서는 이전에 serialize 된 개체를 역직렬화, reserializes, 및 예외를 throwWhen subsequent divisions by zero occur, the example deserializes the previously serialized object, reserializes it, and throws the exception. 개체 serialization, deserialization, reserialization, 및 역직렬화를 제공 하려면이 예제에서는 추가 합니다 SerializeObjectState 이벤트 처리기 모두에 BadDivisionException 클래스 생성자 및를 ISafeSerializationData.CompleteDeserialization 구현 합니다.To provide for object serialization, deserialization, reserialization, and deserialization, the example adds the SerializeObjectState event handler both in the BadDivisionException class constructor and in the ISafeSerializationData.CompleteDeserialization implementation.

설명

예외 상태 개체를 구현 하는 ISafeSerializationData 인터페이스입니다.The exception state object implements the ISafeSerializationData interface.

경우는 SerializeObjectState 이벤트를 구독, 예외는 역직렬화 되 고 빈 예외로 생성 합니다.When the SerializeObjectState event is subscribed to, the exception is deserialized and created as an empty exception. 예외의 생성자를 실행 되지 않습니다 및 예외 상태를 역직렬화 할 수도 있습니다.The exception's constructor is not run, and the exception state is also deserialized. CompleteDeserialization 예외 상태 개체의 콜백 메서드는 빈 예외를 deserialize 된 데이터를 푸시 수 있도록 다음 알림이 전송 됩니다.The CompleteDeserialization callback method of the exception state object is then notified so that it can push deserialized data into the empty exception.

SerializeObjectState 이벤트 예외 데이터 직렬화 및 역직렬화를 투명 하 게 예외 형식을 사용 하도록 설정 합니다.The SerializeObjectState event enables transparent exception types to serialize and deserialize exception data. 투명 코드 수 내에서 작동 하는 권한 집합의 범위 내에서 명령을 실행 하지만 없습니다 실행, 호출, 컨트롤에서 파생 또는 중요 한 코드를 포함 합니다.Transparent code can execute commands within the bounds of the permission set it is operating within, but cannot execute, call, derive from, or contain critical code.

경우는 SerializeObjectState 이벤트는 구독 하지 않는, 사용 하 여 일반적인 방식으로 deserialization이 발생 합니다 Exception 생성자입니다.If the SerializeObjectState event is not subscribed to, deserialization occurs as usual using the Exception constructor.

일반적으로 대 한 처리기를 SerializeObjectState 이벤트는 serialization을 위해 제공 하는 예외의 생성자에 추가 됩니다.Typically, a handler for the SerializeObjectState event is added in the exception's constructor to provide for its serialization. 생성자가 없기 때문에 있지만 될 때 실행 되는 SerializeObjectState 이벤트 처리기가 실행, 직렬화 deserialize 된 예외를 throw 할 수 있습니다를 SerializationException 예외를 deserialize 하려는 동안 예외가 발생 합니다.But because the constructor is not executed when the SerializeObjectState event handler executes, serializing a deserialized exception can throw a SerializationException exception when you try to deserialize the exception. 이 방지 하려면 추가 해야에 대 한 처리기를 SerializeObjectState 이벤트에는 ISafeSerializationData.CompleteDeserialization 메서드.To avoid this, you should also add the handler for the SerializeObjectState event in the ISafeSerializationData.CompleteDeserialization method. 예시 "예" 섹션을 참조 하세요.See the Examples section for an illustration.

상속자 참고

이 이벤트 구독을 사용 하는 경우 모든 파생된 형식에 상속 계층 구조에 따라 동일한 serialization 메커니즘을 구현 해야 합니다.If this event is subscribed to and used, all derived types that follow in the inheritance hierarchy must implement the same serialization mechanism.

적용 대상