Exception.SerializeObjectState Événement

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Attention

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

Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception.

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)

Type d'événement

EventHandler<SafeSerializationEventArgs>

Attributs: ObsoleteAttribute

Exemples

L’exemple suivant définit un BadDivisionException qui gère l’événement SerializeObjectState . Il contient également un objet d’état, qui est une structure imbriquée nommée BadDivisionExceptionState qui implémente l’interface ISafeSerializationData .

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

L’exception BadDivisionException est levée lorsqu’une division à virgule flottante par zéro se produit. Pendant la première division par zéro, l’exemple instancie un BadDivisionException objet, le sérialise et lève l’exception. Lorsque des divisions ultérieures de zéro se produisent, l’exemple désérialise l’objet sérialisé précédemment, le réérialise et lève l’exception. Pour fournir la sérialisation d’objets, la désérialisation, la résérialisation et la désérialisation, l’exemple ajoute le SerializeObjectState gestionnaire d’événements à la fois dans le BadDivisionException constructeur de classe et dans l’implémentation ISafeSerializationData.CompleteDeserialization .

Remarques

L’objet d’état d’exception implémente l’interface ISafeSerializationData .

Lorsque l’événement SerializeObjectState est abonné, l’exception est désérialisée et créée en tant qu’exception vide. Le constructeur de l’exception n’est pas exécuté et l’état d’exception est également désérialisé. La CompleteDeserialization méthode de rappel de l’objet d’état d’exception est ensuite avertie afin qu’elle puisse envoyer (push) des données désérialisées dans l’exception vide.

L’événement SerializeObjectState permet aux types d’exceptions transparents de sérialiser et désérialiser les données d’exception. Le code transparent peut exécuter des commandes dans les limites du jeu d’autorisations dans lequel il fonctionne, mais ne peut pas exécuter, appeler, dériver ou contenir du code critique.

Si l’événement n’est pas abonné, la SerializeObjectState désérialisation se produit comme d’habitude à l’aide du Exception constructeur.

En règle générale, un gestionnaire pour l’événement SerializeObjectState est ajouté dans le constructeur de l’exception pour fournir sa sérialisation. Toutefois, étant donné que le constructeur n’est pas exécuté lorsque le SerializeObjectState gestionnaire d’événements s’exécute, la sérialisation d’une exception désérialisée peut lever une SerializationException exception lorsque vous essayez de désérialiser l’exception. Pour éviter cela, vous devez également ajouter le gestionnaire de l’événement SerializeObjectState dans la ISafeSerializationData.CompleteDeserialization méthode. Consultez la section Exemples pour obtenir une illustration.

Notes pour les héritiers

Si cet événement est abonné et utilisé, tous les types dérivés qui suivent dans la hiérarchie d’héritage doivent implémenter le même mécanisme de sérialisation.

S’applique à