Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale
Questo argomento non è stato ancora valutato - Valuta questo argomento

Evento Exception.SerializeObjectState

Si verifica quando un'eccezione viene serializzata per creare un oggetto stato di eccezione che contiene dati serializzati sull'eccezione.

Spazio dei nomi:  System
Assembly:  mscorlib (in mscorlib.dll)
protected event EventHandler<SafeSerializationEventArgs> SerializeObjectState

Oggetto stato di eccezione che implementa l'interfaccia ISafeSerializationData.

Quando l'evento SerializeObjectState viene sottoscritto, l'eccezione viene deserializzata e viene creata come un'eccezione vuota. Il costruttore dell'eccezione non viene eseguito e inoltre lo stato di eccezione viene deserializzato. Il metodo di callback CompleteDeserialization dell'oggetto stato di eccezione riceve una notifica in modo da poter inserire i dati deserializzati nell'eccezione vuota.

L'evento SerializeObjectState consente ai tipi di eccezione trasparenti di serializzare e deserializzare i dati dell'eccezione. Il codice trasparente può eseguire comandi all'interno dei limiti del set di autorizzazioni in cui sta funzionando, ma non può eseguire, chiamare, derivare o contenere codice critico.

Se l'evento SerializeObjectState non è sottoscritto, si verifica la deserializzazione che utilizza come di solito il costruttore Exception.

In genere, un gestore per l'evento SerializeObjectState viene aggiunto al costruttore dell'eccezione per fornire alla serializzazione. Poiché tuttavia il costruttore non viene eseguito il gestore eventi SerializeObjectState, serializzare un'eccezione deserializzata può generare un'eccezione SerializationException quando si tenta di deserializzare l'eccezione. Per evitare tale comportamento, è inoltre necessario aggiungere il gestore per l'evento SerializeObjectState nel metodo ISafeSerializationData.CompleteDeserialization. Vedere la sezione relativa agli esempi per un'illustrazione.

Note per gli implementatori

Se questo evento è sottoscritto e viene utilizzato, tutti i tipi derivati che seguono nella gerarchia dell'ereditarietà devono implementare lo stesso meccanismo di serializzazione.

Nell'esempio riportato di seguito BadDivisionException che gestisce l'evento SerializeObjectState. Contiene inoltre un oggetto stato, che è una struttura annidata denominata BadDivisionExceptionState che implementa l'interfaccia 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


L'eccezione BadDivisionException viene generata quando una divisione a virgola mobile da zero si verifica. Durante la prima divisione per zero, viene creata un'istanza di un oggetto BadDivisionException, lo serializza e genera l'eccezione. Quando le divisioni successive da zero si verificano, l'esempio deserializza nuovamente l'oggetto serializzato, reserializes e genera l'eccezione. Per affrontare alla serializzazione di oggetti, la deserializzazione, il reserialization e la deserializzazione, viene aggiunto il gestore eventi SerializeObjectState sia nel costruttore della classe BadDivisionException che nell'implementazione ISafeSerializationData.CompleteDeserialization.

.NET Framework

Supportato in: 4.5, 4

.NET Framework Client Profile

Supportato in: 4

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.
Il documento è risultato utile?
(1500 caratteri rimanenti)
Grazie per i commenti inviati.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft. Tutti i diritti riservati.