ObjectManager Classe

Definizione

Spazio dei nomi:

System.Runtime.Serialization

Assembly:

System.Runtime.Serialization.Formatters.dll

Origine:

ObjectManager.cs

Tiene traccia degli oggetti in fase di deserializzazione.

public ref class ObjectManager

public class ObjectManager

type ObjectManager = class

Public Class ObjectManager

Ereditarietà

Object

ObjectManager

Esempio

Nell'esempio di codice seguente viene illustrato come usare la ObjectManager classe per esaminare un grafico a oggetti, passando a ogni oggetto una sola volta.

using System;
using System.Text;
using System.Collections;
using System.Runtime.Serialization;
using System.Reflection;

// This class walks through all the objects once in an object graph.
public sealed class ObjectWalker : IEnumerable, IEnumerator {
   private Object m_current;

   // This stack contains the set of objects that will be enumerated.
   private Stack m_toWalk = new Stack();

   // The ObjectIDGenerator ensures that each object is enumerated just once.
   private ObjectIDGenerator m_idGen = new ObjectIDGenerator();

   // Construct an ObjectWalker passing the root of the object graph.
   public ObjectWalker(Object root) {
      Schedule(root);
   }

   // Return an enumerator so this class can be used with foreach.
   public IEnumerator GetEnumerator() {
      return this;
   }

   // Resetting the enumerator is not supported.
   public void Reset() {
      throw new NotSupportedException("Resetting the enumerator is not supported.");
   }

   // Return the enumeration's current object.
   public Object Current { get { return m_current; } }

   // Walk the reference of the passed-in object.
   private void Schedule(Object toSchedule) {
      if (toSchedule == null) return;

      // Ask the ObjectIDManager if this object has been examined before.
      Boolean firstOccurrence;
      m_idGen.GetId(toSchedule, out firstOccurrence);

      // If this object has been examined before, do not look at it again just return.
      if (!firstOccurrence) return;

      if (toSchedule.GetType().IsArray) {
         // The object is an array, schedule each element of the array to be looked at.
         foreach (Object item in ((Array)toSchedule)) Schedule(item);
      } else {
         // The object is not an array, schedule this object to be looked at.
         m_toWalk.Push(toSchedule);
      }
   }

   // Advance to the next item in the enumeration.
   public Boolean MoveNext() {
      // If there are no more items to enumerate, return false.
      if (m_toWalk.Count == 0) return false;

      // Check if the object is a terminal object (has no fields that refer to other objects).
      if (!IsTerminalObject(m_current = m_toWalk.Pop())) {
         // The object does have field, schedule the object's instance fields to be enumerated.
         foreach (FieldInfo fi in m_current.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) {
            Schedule(fi.GetValue(m_current));
         }
      }
      return true;
   }

   // Returns true if the object has no data fields with information of interest.
   private Boolean IsTerminalObject(Object data) {
      Type t = data.GetType();
      return t.IsPrimitive || t.IsEnum || t.IsPointer || data is String;
   }
}

public sealed class App {
   // Define some fields in the class to test the ObjectWalker.
   public String name = "Fred";
   public Int32 Age = 40;

   static void Main() {
      // Build an object graph using an array that refers to various objects.
      Object[] data = new Object[] { "Jeff", 123, 555L, (Byte) 35, new App() };

      // Construct an ObjectWalker and pass it the root of the object graph.
      ObjectWalker ow = new ObjectWalker(data);

      // Enumerate all of the objects in the graph and count the number of objects.
      Int64 num = 0;
      foreach (Object o in ow) {
         // Display each object's type and value as a string.
         Console.WriteLine("Object #{0}: Type={1}, Value's string={2}",
            num++, o.GetType(), o.ToString());
      }
   }
}

// This code produces the following output.
//
// Object #0: Type=App, Value's string=App
// Object #1: Type=System.Int32, Value's string=40
// Object #2: Type=System.String, Value's string=Fred
// Object #3: Type=System.Byte, Value's string=35
// Object #4: Type=System.Int64, Value's string=555
// Object #5: Type=System.Int32, Value's string=123
// Object #6: Type=System.String, Value's string=Jeff

Commenti

Durante la deserializzazione, le Formatter query ObjectManager su per determinare se un riferimento a un oggetto nel flusso serializzato fa riferimento a un oggetto già deserializzato (riferimento indietro) o a un oggetto che non è ancora stato deserializzato (riferimento avanti). Se il riferimento nel flusso serializzato è un riferimento in avanti, è Formatter possibile registrare una correzione con .ObjectManager Se il riferimento nel flusso serializzato è un riferimento indietro, il Formatter riferimento completa immediatamente il riferimento. Fixup fa riferimento al processo di finalizzazione dei riferimenti a oggetti non già completati durante il processo di deserializzazione dell'oggetto. Dopo aver deserializzato l'oggetto richiesto, il ObjectManager riferimento verrà completato.

Segue ObjectManager un set di regole che determinano l'ordine di correzione. Tutti gli oggetti che implementano ISerializable o dispongono di un ISerializationSurrogate oggetto possono prevedere di avere tutti gli oggetti trasmessi tramite SerializationInfo disponibili quando l'albero degli oggetti viene deserializzato. Tuttavia, un oggetto padre non può presumere che tutti gli oggetti figlio vengano completati completamente quando è completamente deserializzato. Tutti gli oggetti figlio saranno presenti, ma non tutti gli oggetti nipoti saranno necessariamente presenti. Se un oggetto deve eseguire determinate azioni che dipendono dall'esecuzione del codice sugli oggetti figlio, può ritardare queste azioni, implementare l'interfaccia ed eseguire il IDeserializationCallback codice solo quando viene richiamato su questa interfaccia.

Costruttori

ObjectManager(ISurrogateSelector, StreamingContext)

Inizializza una nuova istanza della classe ObjectManager.

Metodi

DoFixups()	Esegue tutte le correzioni registrate.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetObject(Int64)	Restituisce l'oggetto con l'ID specificato.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
RaiseDeserializationEvent()	Genera l'evento di deserializzazione per qualsiasi oggetto registrato che implementi IDeserializationCallback.
RaiseOnDeserializingEvent(Object)	Richiama il metodo contrassegnato con l'oggetto OnDeserializingAttribute.
RecordArrayElementFixup(Int64, Int32, Int64)	Registra una correzione per un elemento di una matrice.
RecordArrayElementFixup(Int64, Int32[], Int64)	Registra le correzioni per gli elementi specificati di una matrice da eseguire successivamente.
RecordDelayedFixup(Int64, String, Int64)	Registra una correzione per un membro oggetto da eseguire successivamente.
RecordFixup(Int64, MemberInfo, Int64)	Registra una correzione per un membro di un oggetto da eseguire successivamente.
RegisterObject(Object, Int64)	Registra un oggetto come se fosse deserializzato, associandolo a objectID.
RegisterObject(Object, Int64, SerializationInfo)	Registra un oggetto come se fosse deserializzato, associandolo a objectID e registrando l'oggetto SerializationInfo utilizzato.
RegisterObject(Object, Int64, SerializationInfo, Int64, MemberInfo)	Registra un membro di un oggetto come se fosse deserializzato, associandolo a objectID e registrando l'oggetto SerializationInfo.
RegisterObject(Object, Int64, SerializationInfo, Int64, MemberInfo, Int32[])	Registra un membro di una matrice contenuta in un oggetto durante la deserializzazione, associandolo a objectID e registrando l'oggetto SerializationInfo.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)