Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Evento Exception.SerializeObjectState

.NET Framework (current version)
 

Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção.

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

protected event EventHandler<SafeSerializationEventArgs> SerializeObjectState

O objeto de estado da exceção implementa o ISafeSerializationData interface.

Quando o SerializeObjectState assina eventos, a exceção é desserializada e criada como uma exceção vazia. Construtor a exceção do não é executada, e o estado de exceção também é desserializado. O CompleteDeserialization método de retorno de chamada do objeto de estado de exceção é notificado, em seguida, para que ele pode enviar dados desserializados para a exceção vazia.

O SerializeObjectState evento permite que os tipos de exceção transparente serializar e desserializar dados de exceção. Código transparente pode executar comandos dentro dos limites do conjunto de permissões que ele está operando em, mas não pode executar, chame, derivam ou conter código crítico.

Se o SerializeObjectState evento não está inscrito, desserialização ocorre normalmente usando o Exception construtor.

Normalmente, um manipulador para o SerializeObjectState evento é adicionado no construtor da exceção para fornecer sua serialização. Mas, como o construtor não é executado quando o SerializeObjectState executa do manipulador de eventos, serializar uma exceção desserializada pode lançar um SerializationException exceção ao tentar desserializar a exceção. Para evitar isso, você também deve adicionar o manipulador para o SerializeObjectState evento o ISafeSerializationData.CompleteDeserialization método. Consulte a seção de exemplos para obter uma ilustração.

Observações para os Implementadores:

Se esse evento é assinado e usado, todos os tipos derivados que seguem na hierarquia de herança devem implementar o mesmo mecanismo de serialização.

O exemplo a seguir define uma BadDivisionException que manipula o SerializeObjectState evento. Ele também contém um objeto de estado, que é uma construção estrutura denominada BadDivisionExceptionState que implementa o 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

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
Disponível desde 4.0
Retornar ao início
Mostrar: