public void SetMemberValue(ObjectManager manager, MemberInfo member, object value) { if (member is FieldInfo) { ((FieldInfo)member).SetValue(ObjectInstance, value); } else if (member is PropertyInfo) { ((PropertyInfo)member).SetValue(ObjectInstance, value, null); } else { throw new SerializationException("Cannot perform fixup"); } if (Member != null) { ObjectRecord containerRecord = manager.GetObjectRecord(IdOfContainingObj); if (containerRecord.IsRegistered) { containerRecord.SetMemberValue(manager, Member, ObjectInstance); } } else if (ArrayIndex != null) { ObjectRecord containerRecord = manager.GetObjectRecord(IdOfContainingObj); if (containerRecord.IsRegistered) { containerRecord.SetArrayValue(manager, ObjectInstance, ArrayIndex); } } }
private void RegisterObjectInternal(object obj, ObjectRecord record) { if (obj == null) { throw new ArgumentNullException("obj"); } if (record.IsRegistered) { if (record.OriginalObject != obj) { throw new SerializationException("An object with Id " + record.ObjectID + " has already been registered"); } else { return; } } record.ObjectInstance = obj; record.OriginalObject = obj; if (obj is IObjectReference) { record.Status = ObjectRecordStatus.ReferenceUnsolved; } else { record.Status = ObjectRecordStatus.ReferenceSolved; } if (_selector != null) { record.Surrogate = _selector.GetSurrogate( obj.GetType(), _context, out record.SurrogateSelector); if (record.Surrogate != null) { record.Status = ObjectRecordStatus.ReferenceUnsolved; } } record.DoFixups(true, this, false); record.DoFixups(false, this, false); _registeredObjectsCount++; // Adds the object to the chain of registered objects. This chain // is needed to be able to to perform the final fixups in the right order if (_objectRecordChain == null) { _objectRecordChain = record; _lastObjectRecord = record; } else { _lastObjectRecord.Next = record; _lastObjectRecord = record; } }
/// <summary>Returns the object with the specified object ID.</summary> /// <returns>The object with the specified object ID if it has been previously stored or null if no such object has been registered.</returns> /// <param name="objectID">The ID of the requested object. </param> /// <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="objectID" /> parameter is less than or equal to zero. </exception> public virtual object GetObject(long objectID) { if (objectID <= 0L) { throw new ArgumentOutOfRangeException("objectID", "The objectID parameter is less than or equal to zero"); } ObjectRecord objectRecord = (ObjectRecord)this._objectRecords[objectID]; if (objectRecord == null || !objectRecord.IsRegistered) { return(null); } return(objectRecord.ObjectInstance); }
/// <summary>Registers an object as it is deserialized, associating it with <paramref name="objectID" />, and recording the <see cref="T:System.Runtime.Serialization.SerializationInfo" /> used with it.</summary> /// <param name="obj">The object to register. </param> /// <param name="objectID">The ID of the object to register. </param> /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> used if <paramref name="obj" /> implements <see cref="T:System.Runtime.Serialization.ISerializable" /> or has a <see cref="T:System.Runtime.Serialization.ISerializationSurrogate" />. <paramref name="info" /> will be completed with any required fixup information and then passed to the required object when that object is completed. </param> /// <exception cref="T:System.ArgumentNullException">The <paramref name="obj" /> parameter is null. </exception> /// <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="objectID" /> parameter is less than or equal to zero. </exception> /// <exception cref="T:System.Runtime.Serialization.SerializationException">The <paramref name="objectID" /> has already been registered for an object other than <paramref name="obj" />. </exception> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.ReflectionPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="MemberAccess" /> /// </PermissionSet> public void RegisterObject(object obj, long objectID, SerializationInfo info) { if (obj == null) { throw new ArgumentNullException("obj", "The obj parameter is null."); } if (objectID <= 0L) { throw new ArgumentOutOfRangeException("objectID", "The objectID parameter is less than or equal to zero"); } ObjectRecord objectRecord = this.GetObjectRecord(objectID); objectRecord.Info = info; this.RegisterObjectInternal(obj, objectRecord); }
private void RegisterObjectInternal(object obj, ObjectRecord record) { if (obj == null) { throw new ArgumentNullException("obj"); } if (!record.IsRegistered) { record.ObjectInstance = obj; record.OriginalObject = obj; if (obj is IObjectReference) { record.Status = ObjectRecordStatus.ReferenceUnsolved; } else { record.Status = ObjectRecordStatus.ReferenceSolved; } if (this._selector != null) { record.Surrogate = this._selector.GetSurrogate(obj.GetType(), this._context, out record.SurrogateSelector); if (record.Surrogate != null) { record.Status = ObjectRecordStatus.ReferenceUnsolved; } } record.DoFixups(true, this, false); record.DoFixups(false, this, false); this._registeredObjectsCount++; if (this._objectRecordChain == null) { this._objectRecordChain = record; this._lastObjectRecord = record; } else { this._lastObjectRecord.Next = record; this._lastObjectRecord = record; } return; } if (record.OriginalObject != obj) { throw new SerializationException("An object with Id " + record.ObjectID + " has already been registered"); } }
/// <summary>Raises the deserialization event to any registered object that implements <see cref="T:System.Runtime.Serialization.IDeserializationCallback" />.</summary> public virtual void RaiseDeserializationEvent() { for (int i = this._onDeserializedCallbackRecords.Count - 1; i >= 0; i--) { ObjectRecord objectRecord = (ObjectRecord)this._onDeserializedCallbackRecords[i]; this.RaiseOnDeserializedEvent(objectRecord.OriginalObject); } for (int j = this._deserializedRecords.Count - 1; j >= 0; j--) { ObjectRecord objectRecord2 = (ObjectRecord)this._deserializedRecords[j]; IDeserializationCallback deserializationCallback = objectRecord2.OriginalObject as IDeserializationCallback; if (deserializationCallback != null) { deserializationCallback.OnDeserialization(this); } } }
public virtual void RaiseDeserializationEvent() { for (int i = _onDeserializedCallbackRecords.Count - 1; i >= 0; i--) { ObjectRecord record = (ObjectRecord)_onDeserializedCallbackRecords [i]; RaiseOnDeserializedEvent(record.OriginalObject); } for (int i = _deserializedRecords.Count - 1; i >= 0; i--) { ObjectRecord record = (ObjectRecord)_deserializedRecords [i]; IDeserializationCallback obj = record.OriginalObject as IDeserializationCallback; if (obj != null) { obj.OnDeserialization(this); } } }
public virtual object GetObject(long objectID) { if (objectID <= 0) { throw new ArgumentOutOfRangeException("objectID", "The objectID parameter is less than or equal to zero"); } ObjectRecord rec = (ObjectRecord)_objectRecords[objectID]; if (rec == null || !rec.IsRegistered) { return(null); } else { return(rec.ObjectInstance); } }
/// <summary>Registers a member of an array contained in an object while it is deserialized, associating it with <paramref name="objectID" />, and recording the <see cref="T:System.Runtime.Serialization.SerializationInfo" />.</summary> /// <param name="obj">The object to register. </param> /// <param name="objectID">The ID of the object to register. </param> /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> used if <paramref name="obj" /> implements <see cref="T:System.Runtime.Serialization.ISerializable" /> or has a <see cref="T:System.Runtime.Serialization.ISerializationSurrogate" />. <paramref name="info" /> will be completed with any required fixup information and then passed to the required object when that object is completed. </param> /// <param name="idOfContainingObj">The ID of the object that contains <paramref name="obj" />. This parameter is required only if <paramref name="obj" /> is a value type. </param> /// <param name="member">The field in the containing object where <paramref name="obj" /> exists. This parameter has meaning only if <paramref name="obj" /> is a value type. </param> /// <param name="arrayIndex">If <paramref name="obj" /> is a <see cref="T:System.ValueType" /> and a member of an array, <paramref name="arrayIndex" /> contains the index within that array where <paramref name="obj" /> exists. <paramref name="arrayIndex" /> is ignored if <paramref name="obj" /> is not both a <see cref="T:System.ValueType" /> and a member of an array. </param> /// <exception cref="T:System.ArgumentNullException">The <paramref name="obj" /> parameter is null. </exception> /// <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="objectID" /> parameter is less than or equal to zero. </exception> /// <exception cref="T:System.Runtime.Serialization.SerializationException">The <paramref name="objectID" /> has already been registered for an object other than <paramref name="obj" />, or <paramref name="member" /> is not a <see cref="T:System.Reflection.FieldInfo" /> and <paramref name="member" /> isn't null. </exception> /// <PermissionSet> /// <IPermission class="System.Security.Permissions.ReflectionPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="MemberAccess" /> /// </PermissionSet> public void RegisterObject(object obj, long objectID, SerializationInfo info, long idOfContainingObj, MemberInfo member, int[] arrayIndex) { if (obj == null) { throw new ArgumentNullException("obj", "The obj parameter is null."); } if (objectID <= 0L) { throw new ArgumentOutOfRangeException("objectID", "The objectID parameter is less than or equal to zero"); } ObjectRecord objectRecord = this.GetObjectRecord(objectID); objectRecord.Info = info; objectRecord.IdOfContainingObj = idOfContainingObj; objectRecord.Member = member; objectRecord.ArrayIndex = arrayIndex; this.RegisterObjectInternal(obj, objectRecord); }
internal ObjectRecord GetObjectRecord(long objectID) { ObjectRecord objectRecord = (ObjectRecord)this._objectRecords[objectID]; if (objectRecord == null) { if (this._finalFixup) { throw new SerializationException("The object with Id " + objectID + " has not been registered"); } objectRecord = new ObjectRecord(); objectRecord.ObjectID = objectID; this._objectRecords[objectID] = objectRecord; } if (!objectRecord.IsRegistered && this._finalFixup) { throw new SerializationException("The object with Id " + objectID + " has not been registered"); } return(objectRecord); }
internal ObjectRecord GetObjectRecord(long objectID) { ObjectRecord rec = (ObjectRecord)_objectRecords[objectID]; if (rec == null) { if (_finalFixup) { throw new SerializationException("The object with Id " + objectID + " has not been registered"); } rec = new ObjectRecord(); rec.ObjectID = objectID; _objectRecords[objectID] = rec; } if (!rec.IsRegistered && _finalFixup) { throw new SerializationException("The object with Id " + objectID + " has not been registered"); } return(rec); }
public BaseFixupRecord(ObjectRecord objectToBeFixed, ObjectRecord objectRequired) { this.ObjectToBeFixed = objectToBeFixed; this.ObjectRequired = objectRequired; }
public bool LoadData(ObjectManager manager, ISurrogateSelector selector, StreamingContext context) { if (Info != null) { if (Surrogate != null) { object new_obj = Surrogate.SetObjectData(ObjectInstance, Info, context, SurrogateSelector); if (new_obj != null) { ObjectInstance = new_obj; } Status = ObjectRecordStatus.ReferenceSolved; } else if (ObjectInstance is ISerializable) { object[] pars = new object[] { Info, context }; ConstructorInfo con = ObjectInstance.GetType().GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(SerializationInfo), typeof(StreamingContext) }, null); if (con == null) { throw new SerializationException("The constructor to deserialize an object of type " + ObjectInstance.GetType().FullName + " was not found."); } con.Invoke(ObjectInstance, pars); } else { throw new SerializationException("No surrogate selector was found for type " + ObjectInstance.GetType().FullName); } Info = null; } if (ObjectInstance is IObjectReference && Status != ObjectRecordStatus.ReferenceSolved) { try { ObjectInstance = ((IObjectReference)ObjectInstance).GetRealObject(context); int n = 100; while (ObjectInstance is IObjectReference && n > 0) { object ob = ((IObjectReference)ObjectInstance).GetRealObject(context); if (ob == ObjectInstance) { break; } ObjectInstance = ob; n--; } if (n == 0) { throw new SerializationException("The implementation of the IObjectReference interface returns too many nested references to other objects that implement IObjectReference."); } Status = ObjectRecordStatus.ReferenceSolved; } catch (NullReferenceException) { // Give a second chance return(false); } } if (Member != null) { // If this object is a value object embedded in another object, the parent // object must be updated ObjectRecord containerRecord = manager.GetObjectRecord(IdOfContainingObj); containerRecord.SetMemberValue(manager, Member, ObjectInstance); } else if (ArrayIndex != null) { ObjectRecord containerRecord = manager.GetObjectRecord(IdOfContainingObj); containerRecord.SetArrayValue(manager, ObjectInstance, ArrayIndex); } return(true); }
public virtual void DoFixups() { _finalFixup = true; try { if (_registeredObjectsCount < _objectRecords.Count) { throw new SerializationException("There are some fixups that refer to objects that have not been registered"); } ObjectRecord last = _lastObjectRecord; bool firstCicle = true; // Solve al pending fixups of all objects ObjectRecord record = _objectRecordChain; while (record != null) { bool ready = !(record.IsUnsolvedObjectReference && firstCicle); if (ready) { ready = record.DoFixups(true, this, true); } if (ready) { ready = record.LoadData(this, _selector, _context); } ObjectRecord next; if (ready) { if (record.OriginalObject is IDeserializationCallback) { _deserializedRecords.Add(record); } SerializationCallbacks sc = SerializationCallbacks .GetSerializationCallbacks(record.OriginalObject.GetType()); if (sc.HasDeserializedCallbacks) { _onDeserializedCallbackRecords.Add(record); } next = record.Next; } else { // There must be an unresolved IObjectReference instance. // Chain the record at the end so it is solved later if ((record.ObjectInstance is IObjectReference) && !firstCicle) { if (record.Status == ObjectRecordStatus.ReferenceSolvingDelayed) { throw new SerializationException("The object with ID " + record.ObjectID + " could not be resolved"); } else { record.Status = ObjectRecordStatus.ReferenceSolvingDelayed; } } if (record != _lastObjectRecord) { next = record.Next; record.Next = null; _lastObjectRecord.Next = record; _lastObjectRecord = record; } else { next = record; } } if (record == last) { firstCicle = false; } record = next; } } finally { _finalFixup = false; } }
public DelayedFixupRecord(ObjectRecord objectToBeFixed, string memberName, ObjectRecord objectRequired) : base(objectToBeFixed, objectRequired) { _memberName = memberName; }
public FixupRecord(ObjectRecord objectToBeFixed, MemberInfo member, ObjectRecord objectRequired) : base(objectToBeFixed, objectRequired) { _member = member; }
public DelayedFixupRecord (ObjectRecord objectToBeFixed, string memberName, ObjectRecord objectRequired): base (objectToBeFixed, objectRequired) { _memberName = memberName; }
public MultiArrayFixupRecord (ObjectRecord objectToBeFixed, int[] indices, ObjectRecord objectRequired): base (objectToBeFixed, objectRequired) { _indices = indices; }
public BaseFixupRecord(ObjectRecord objectToBeFixed, ObjectRecord objectRequired) { ObjectToBeFixed = objectToBeFixed; ObjectRequired = objectRequired; }
public virtual void DoFixups() { _finalFixup = true; try { if (_registeredObjectsCount < _objectRecords.Count) throw new SerializationException ("There are some fixups that refer to objects that have not been registered"); ObjectRecord last = _lastObjectRecord; bool firstCycle = true; bool lastCycle = false; int unresolvedCount = 0; // Unresolved objects found in the current cycle int lastUnresolvedCount = 0; // Unresolved objects before the current cycle // Solve al pending fixups of all objects ObjectRecord record = _objectRecordChain; while (record != null) { // We ignore object references in the first cycle bool ready = !(record.IsUnsolvedObjectReference && firstCycle); if (ready) ready = record.DoFixups (true, this, true); if (ready) ready = record.LoadData(this, _selector, _context); ObjectRecord next; if (ready) { if (record.OriginalObject is IDeserializationCallback) _deserializedRecords.Add (record); SerializationCallbacks sc = SerializationCallbacks .GetSerializationCallbacks (record.OriginalObject.GetType ()); if (sc.HasDeserializedCallbacks) _onDeserializedCallbackRecords.Add (record); next = record.Next; } else { // There must be an unresolved IObjectReference instance. // Chain the record at the end so it is solved later if ((record.ObjectInstance is IObjectReference) && !firstCycle) { if (record.IsUnsolvedObjectReference && lastCycle) // No more chances to resolve throw new SerializationException ("The object with ID " + record.ObjectID + " could not be resolved"); else { unresolvedCount++; } } if (record != _lastObjectRecord) { next = record.Next; record.Next = null; _lastObjectRecord.Next = record; _lastObjectRecord = record; } else next = record; } if (record == last) { last = _lastObjectRecord; if (firstCycle) firstCycle = false; else { if (lastUnresolvedCount == unresolvedCount) lastCycle = true; } lastUnresolvedCount = unresolvedCount; unresolvedCount = 0; } record = next; } } finally { _finalFixup = false; } }
internal ObjectRecord GetObjectRecord (long objectID) { ObjectRecord rec = (ObjectRecord)_objectRecords[objectID]; if (rec == null) { if (_finalFixup) throw new SerializationException ("The object with Id " + objectID + " has not been registered"); rec = new ObjectRecord(); rec.ObjectID = objectID; _objectRecords[objectID] = rec; } if (!rec.IsRegistered && _finalFixup) throw new SerializationException ("The object with Id " + objectID + " has not been registered"); return rec; }
public bool LoadData(ObjectManager manager, ISurrogateSelector selector, StreamingContext context) { if (this.Info != null) { if (this.Surrogate != null) { object obj = this.Surrogate.SetObjectData(this.ObjectInstance, this.Info, context, this.SurrogateSelector); if (obj != null) { this.ObjectInstance = obj; } this.Status = ObjectRecordStatus.ReferenceSolved; } else { if (!(this.ObjectInstance is ISerializable)) { throw new SerializationException("No surrogate selector was found for type " + this.ObjectInstance.GetType().FullName); } object[] parameters = new object[] { this.Info, context }; ConstructorInfo constructor = this.ObjectInstance.GetType().GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(SerializationInfo), typeof(StreamingContext) }, null); if (constructor == null) { throw new SerializationException("The constructor to deserialize an object of type " + this.ObjectInstance.GetType().FullName + " was not found."); } constructor.Invoke(this.ObjectInstance, parameters); } this.Info = null; } if (this.ObjectInstance is IObjectReference && this.Status != ObjectRecordStatus.ReferenceSolved) { try { this.ObjectInstance = ((IObjectReference)this.ObjectInstance).GetRealObject(context); int num = 100; while (this.ObjectInstance is IObjectReference && num > 0) { object realObject = ((IObjectReference)this.ObjectInstance).GetRealObject(context); if (realObject == this.ObjectInstance) { break; } this.ObjectInstance = realObject; num--; } if (num == 0) { throw new SerializationException("The implementation of the IObjectReference interface returns too many nested references to other objects that implement IObjectReference."); } this.Status = ObjectRecordStatus.ReferenceSolved; } catch (NullReferenceException) { return(false); } } if (this.Member != null) { ObjectRecord objectRecord = manager.GetObjectRecord(this.IdOfContainingObj); objectRecord.SetMemberValue(manager, this.Member, this.ObjectInstance); } else if (this.ArrayIndex != null) { ObjectRecord objectRecord2 = manager.GetObjectRecord(this.IdOfContainingObj); objectRecord2.SetArrayValue(manager, this.ObjectInstance, this.ArrayIndex); } return(true); }
private void RegisterObjectInternal (object obj, ObjectRecord record) { if (obj == null) throw new ArgumentNullException("obj"); if (record.IsRegistered) { if (record.OriginalObject != obj) throw new SerializationException ("An object with Id " + record.ObjectID + " has already been registered"); else return; } record.ObjectInstance = obj; record.OriginalObject = obj; if (obj is IObjectReference) record.Status = ObjectRecordStatus.ReferenceUnsolved; else record.Status = ObjectRecordStatus.ReferenceSolved; if (_selector != null) { record.Surrogate = _selector.GetSurrogate ( obj.GetType(), _context, out record.SurrogateSelector); if (record.Surrogate != null) record.Status = ObjectRecordStatus.ReferenceUnsolved; } record.DoFixups (true, this, false); record.DoFixups (false, this, false); _registeredObjectsCount++; // Adds the object to the chain of registered objects. This chain // is needed to be able to to perform the final fixups in the right order if (_objectRecordChain == null) { _objectRecordChain = record; _lastObjectRecord = record; } else { _lastObjectRecord.Next = record; _lastObjectRecord = record; } }
/// <summary>Performs all the recorded fixups.</summary> /// <exception cref="T:System.Runtime.Serialization.SerializationException">A fixup was not successfully completed. </exception> public virtual void DoFixups() { this._finalFixup = true; try { if (this._registeredObjectsCount < this._objectRecords.Count) { throw new SerializationException("There are some fixups that refer to objects that have not been registered"); } ObjectRecord lastObjectRecord = this._lastObjectRecord; bool flag = true; ObjectRecord objectRecord2; for (ObjectRecord objectRecord = this._objectRecordChain; objectRecord != null; objectRecord = objectRecord2) { bool flag2 = !objectRecord.IsUnsolvedObjectReference || !flag; if (flag2) { flag2 = objectRecord.DoFixups(true, this, true); } if (flag2) { flag2 = objectRecord.LoadData(this, this._selector, this._context); } if (flag2) { if (objectRecord.OriginalObject is IDeserializationCallback) { this._deserializedRecords.Add(objectRecord); } SerializationCallbacks serializationCallbacks = SerializationCallbacks.GetSerializationCallbacks(objectRecord.OriginalObject.GetType()); if (serializationCallbacks.HasDeserializedCallbacks) { this._onDeserializedCallbackRecords.Add(objectRecord); } objectRecord2 = objectRecord.Next; } else { if (objectRecord.ObjectInstance is IObjectReference && !flag) { if (objectRecord.Status == ObjectRecordStatus.ReferenceSolvingDelayed) { throw new SerializationException("The object with ID " + objectRecord.ObjectID + " could not be resolved"); } objectRecord.Status = ObjectRecordStatus.ReferenceSolvingDelayed; } if (objectRecord != this._lastObjectRecord) { objectRecord2 = objectRecord.Next; objectRecord.Next = null; this._lastObjectRecord.Next = objectRecord; this._lastObjectRecord = objectRecord; } else { objectRecord2 = objectRecord; } } if (objectRecord == lastObjectRecord) { flag = false; } } } finally { this._finalFixup = false; } }
public ArrayFixupRecord (ObjectRecord objectToBeFixed, int index, ObjectRecord objectRequired): base (objectToBeFixed, objectRequired) { _index = index; }
public ArrayFixupRecord(ObjectRecord objectToBeFixed, int index, ObjectRecord objectRequired) : base(objectToBeFixed, objectRequired) { _index = index; }
public FixupRecord (ObjectRecord objectToBeFixed, MemberInfo member, ObjectRecord objectRequired): base (objectToBeFixed, objectRequired) { _member = member; }
public MultiArrayFixupRecord(ObjectRecord objectToBeFixed, int[] indices, ObjectRecord objectRequired) : base(objectToBeFixed, objectRequired) { _indices = indices; }
public virtual void DoFixups() { _finalFixup = true; try { if (_registeredObjectsCount < _objectRecords.Count) throw new SerializationException ("There are some fixups that refer to objects that have not been registered"); ObjectRecord last = _lastObjectRecord; bool firstCicle = true; // Solve al pending fixups of all objects ObjectRecord record = _objectRecordChain; while (record != null) { bool ready = !(record.IsUnsolvedObjectReference && firstCicle); if (ready) ready = record.DoFixups (true, this, true); if (ready) ready = record.LoadData(this, _selector, _context); ObjectRecord next; if (ready) { if (record.OriginalObject is IDeserializationCallback) _deserializedRecords.Add (record); SerializationCallbacks sc = SerializationCallbacks .GetSerializationCallbacks (record.OriginalObject.GetType ()); if (sc.HasDeserializedCallbacks) _onDeserializedCallbackRecords.Add (record); next = record.Next; } else { // There must be an unresolved IObjectReference instance. // Chain the record at the end so it is solved later if ((record.ObjectInstance is IObjectReference) && !firstCicle) { if (record.Status == ObjectRecordStatus.ReferenceSolvingDelayed) throw new SerializationException ("The object with ID " + record.ObjectID + " could not be resolved"); else record.Status = ObjectRecordStatus.ReferenceSolvingDelayed; } if (record != _lastObjectRecord) { next = record.Next; record.Next = null; _lastObjectRecord.Next = record; _lastObjectRecord = record; } else next = record; } if (record == last) firstCicle = false; record = next; } } finally { _finalFixup = false; } }
public virtual void DoFixups() { _finalFixup = true; try { if (_registeredObjectsCount < _objectRecords.Count) { throw new SerializationException("There are some fixups that refer to objects that have not been registered"); } ObjectRecord last = _lastObjectRecord; bool firstCycle = true; bool lastCycle = false; int unresolvedCount = 0; // Unresolved objects found in the current cycle int lastUnresolvedCount = 0; // Unresolved objects before the current cycle // Solve al pending fixups of all objects ObjectRecord record = _objectRecordChain; while (record != null) { // We ignore object references in the first cycle bool ready = !(record.IsUnsolvedObjectReference && firstCycle); if (ready) { ready = record.DoFixups(true, this, true); } if (ready) { ready = record.LoadData(this, _selector, _context); } ObjectRecord next; if (ready) { if (record.OriginalObject is IDeserializationCallback) { _deserializedRecords.Add(record); } SerializationCallbacks sc = SerializationCallbacks .GetSerializationCallbacks(record.OriginalObject.GetType()); if (sc.HasDeserializedCallbacks) { _onDeserializedCallbackRecords.Add(record); } next = record.Next; } else { // There must be an unresolved IObjectReference instance. // Chain the record at the end so it is solved later if ((record.ObjectInstance is IObjectReference) && !firstCycle) { if (record.IsUnsolvedObjectReference && lastCycle) { // No more chances to resolve throw new SerializationException("The object with ID " + record.ObjectID + " could not be resolved"); } else { unresolvedCount++; } } if (record != _lastObjectRecord) { next = record.Next; record.Next = null; _lastObjectRecord.Next = record; _lastObjectRecord = record; } else { next = record; } } if (record == last) { last = _lastObjectRecord; if (firstCycle) { firstCycle = false; } else { if (lastUnresolvedCount == unresolvedCount) { lastCycle = true; } } lastUnresolvedCount = unresolvedCount; unresolvedCount = 0; } record = next; } } finally { _finalFixup = false; } }