Exception.SerializeObjectState Evento
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Precaución
BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.
Ocurre cuando una excepción se serializa para crear un objeto de estado de excepción que contenga datos serializados sobre la excepción.
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)
Tipo de evento
- Atributos
Ejemplos
En el ejemplo siguiente se define un BadDivisionException
objeto que controla el SerializeObjectState evento . También contiene un objeto de estado, que es una estructura anidada denominada BadDivisionExceptionState
que implementa la ISafeSerializationData interfaz .
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
La BadDivisionException
excepción se produce cuando se produce una división de punto flotante por cero. Durante la primera división por cero, en el ejemplo se crea una instancia de un BadDivisionException
objeto, se serializa y se produce la excepción. Cuando se producen divisiones posteriores por cero, el ejemplo deserializa el objeto serializado previamente, lo vuelve a serializar y produce la excepción. Para proporcionar la serialización de objetos, la deserialización, la reserialización y la deserialización, en el ejemplo se agrega el SerializeObjectState controlador de eventos tanto en el BadDivisionException
constructor de clase como en la ISafeSerializationData.CompleteDeserialization implementación.
Comentarios
El objeto de estado de excepción implementa la ISafeSerializationData interfaz .
Cuando se suscribe el SerializeObjectState evento, la excepción se deserializa y se crea como una excepción vacía. El constructor de la excepción no se ejecuta y el estado de excepción también se deserializa. A CompleteDeserialization continuación, se notifica al método de devolución de llamada del objeto de estado de excepción para que pueda insertar datos deserializados en la excepción vacía.
El SerializeObjectState evento permite a los tipos de excepción transparentes serializar y deserializar los datos de excepción. El código transparente puede ejecutar comandos dentro de los límites del conjunto de permisos en el que está funcionando, pero no puede ejecutar, llamar, derivar de o contener código crítico.
Si el evento no está suscrito, la SerializeObjectState deserialización se produce como de costumbre mediante el Exception constructor .
Normalmente, se agrega un controlador para el SerializeObjectState evento en el constructor de la excepción para proporcionar su serialización. Pero dado que el constructor no se ejecuta cuando se ejecuta el SerializeObjectState controlador de eventos, la serialización de una excepción deserializada puede producir una SerializationException excepción al intentar deserializar la excepción. Para evitar esto, también debe agregar el controlador para el SerializeObjectState evento en el ISafeSerializationData.CompleteDeserialization método . Consulte la sección Ejemplos para obtener una ilustración.
Notas a los desarrolladores de herederos
Si este evento está suscrito a y se usa, todos los tipos derivados que siguen en la jerarquía de herencia deben implementar el mismo mecanismo de serialización.