Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Classe ObjectManager

Mantém registro de objetos como eles são desserializados.

System.Object
  System.Runtime.Serialization.ObjectManager

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

[ComVisibleAttribute(true)]
public class ObjectManager

O tipo ObjectManager expõe os membros a seguir.

  NomeDescrição
Método públicoObjectManagerInicializa uma nova instância da classe ObjectManager.
Superior

  NomeDescrição
Método públicoDoFixupsExecuta todas as correções gravadas.
Método públicoEquals(Object) Verifica se o objeto especificado é igual ao objeto atual. (Herdado de Object.)
Método protegidoFinalize Permite um objeto tentar liberar recursos e executar outras operações de limpeza antes que ele seja recuperado pela coleta de lixo. (Herdado de Object.)
Método públicoGetHashCodeServe como a função de hash padrão. (Herdado de Object.)
Método públicoGetObjectRetorna o objeto com a identificação do objeto especificado.
Método públicoGetType Obtém o Type da instância atual. (Herdado de Object.)
Método protegidoMemberwiseCloneCria uma cópia superficial do Object atual. (Herdado de Object.)
Método públicoRaiseDeserializationEventGera o evento de desserialização para qualquer objeto registrado que implementa IDeserializationCallback.
Método públicoRaiseOnDeserializingEventInvoca o método marcado com o OnDeserializingAttribute.
Método públicoRecordArrayElementFixup(Int64, Int32, Int64)Registra uma correção para um elemento em uma matriz.
Método públicoRecordArrayElementFixup(Int64, Int32[], Int64)Correções de registros para os elementos especificados em uma matriz, a ser executado posteriormente.
Método públicoRecordDelayedFixupRegistra uma correção para um membro de objeto a ser executada posteriormente.
Método públicoRecordFixupRegistra uma correção para um membro de um objeto, a ser executado posteriormente.
Método públicoRegisterObject(Object, Int64)Registra um objeto como ele é desserializado, associando-o com objectID.
Método públicoRegisterObject(Object, Int64, SerializationInfo)Registra um objeto como ele é desserializado, associando-o com objectID, gravação e o SerializationInfo usados com ele.
Método públicoRegisterObject(Object, Int64, SerializationInfo, Int64, MemberInfo)Registra um membro de um objeto como ele é desserializado, associando-o com objectID, gravação e o SerializationInfo.
Método públicoRegisterObject(Object, Int64, SerializationInfo, Int64, MemberInfo, Int32[])Registra um membro de uma matriz contido em um objeto enquanto ele é desserializado, associando-o com objectID, gravação e o SerializationInfo.
Método públicoToStringRetorna uma string que representa o objeto atual. (Herdado de Object.)
Superior

Durante a desserialização, o Formatter consultas a ObjectManager para determinar se uma referência a um objeto no fluxo serializado se refere a um objeto que já foi desserializado (uma referência com versões anteriores), ou a um objeto que ainda não tenham sido desserializado (uma referência direta). Se a referência no fluxo serializado é uma referência direta, em seguida, a Formatter pode registrar uma correção com o ObjectManager. Se a referência no fluxo serializado é uma referência com versões anteriores, o Formatter imediatamente conclui a referência. Correção refere-se ao processo de finalizar as referências de objeto não tiver sido concluídas durante o processo de desserialização do objeto. Depois que o objeto necessário tem sido desserializado, o ObjectManager concluirá a referência.

O ObjectManager segue um conjunto de regras que determinam a ordem de correção. Todos os objetos que implementam ISerializable ou tem um ISerializationSurrogate pode esperar para que todos os objetos que eles são transmitidos por meio de SerializationInfo disponível quando a árvore de objetos é desserializada. No entanto, um objeto pai não assumem que todos os seus objetos filho serão concluídos totalmente quando ele é desserializado totalmente. Todos os objetos filho estará presentes, mas não todos os objetos neto necessariamente estarão presentes. Se precisar de um objeto fazer determinadas ações que dependem da execução do código em seus objetos filho, ele pode atrasar a essas ações, implementar a IDeserializationCallback interface e executar o código somente quando ele é chamado de volta nesta interface.

O exemplo de código a seguir mostra como usar o ObjectManager classe para percorrer um gráfico de objeto, atravessando a cada objeto apenas uma vez.


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


.NET Framework

Com suporte em: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.

Quaisquer membros estático (Shared no Visual Basic) públicos deste tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2015 Microsoft