private void DoNewlyRegisteredObjectFixups(ObjectHolder holder) { if (holder.CanObjectValueChange) { return; } LongList dependentObjects = holder.DependentObjects; if (dependentObjects == null) { return; } dependentObjects.StartEnumeration(); while (dependentObjects.MoveNext()) { long objectID = dependentObjects.Current; ObjectHolder objectHolder = this.FindObjectHolder(objectID); objectHolder.DecrementFixupsRemaining(this); if (objectHolder.DirectlyDependentObjects == 0) { if (objectHolder.ObjectValue != null) { this.CompleteObject(objectHolder, true); } else { objectHolder.MarkForCompletionWhenAvailable(); } } } }
private void DoNewlyRegisteredObjectFixups(ObjectHolder holder) { if (!holder.CanObjectValueChange) { LongList dependentObjects = holder.DependentObjects; if (dependentObjects != null) { dependentObjects.StartEnumeration(); while (dependentObjects.MoveNext()) { ObjectHolder holder2 = this.FindObjectHolder(dependentObjects.Current); holder2.DecrementFixupsRemaining(this); if (holder2.DirectlyDependentObjects == 0) { if (holder2.ObjectValue != null) { this.CompleteObject(holder2, true); } else { holder2.MarkForCompletionWhenAvailable(); } } } } } }
/*================================CompleteObject================================ **Action: **Returns: **Arguments: **Exceptions: ==============================================================================*/ internal void CompleteObject(ObjectHolder holder, bool bObjectFullyComplete) { FixupHolderList fixups=holder.m_missingElements; FixupHolder currentFixup; SerializationInfo si; Object fixupInfo=null; ObjectHolder tempObjectHolder=null; int fixupsPerformed=0; BCLDebug.Assert(holder!=null,"[ObjectManager.CompleteObject]holder.m_object!=null"); if (holder.ObjectValue==null) { throw new SerializationException(Environment.GetResourceString("Serialization_MissingObject", holder.m_id)); } if (fixups==null) { return; } //If either one of these conditions is true, we need to update the data in the //SerializationInfo before calling SetObjectData. if (holder.HasSurrogate || holder.HasISerializable) { si = holder.m_serInfo; if (si==null) { throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFixupDiscovered")); } BCLDebug.Trace("SER", "[ObjectManager.CompleteObject]Complete object ", holder.m_id, " of SI Type: ", si.FullTypeName); //Walk each of the fixups and complete the name-value pair in the SerializationInfo. if (fixups!=null) { for (int i=0; i<fixups.m_count; i++) { if (fixups.m_values[i]==null) { continue; } BCLDebug.Assert(fixups.m_values[i].m_fixupType==FixupHolder.DelayedFixup,"fixups.m_values[i].m_fixupType==FixupHolder.DelayedFixup"); if (GetCompletionInfo(fixups.m_values[i], out tempObjectHolder, out fixupInfo, bObjectFullyComplete)) { //Walk the SerializationInfo and find the member needing completion. All we have to do //at this point is set the member into the Object BCLDebug.Trace("SER", "[ObjectManager.CompleteObject]Updating object ", holder.m_id, " with object ", tempObjectHolder.m_id); Object holderValue = tempObjectHolder.ObjectValue; if (CanCallGetType(holderValue)) { si.UpdateValue((String)fixupInfo, holderValue, holderValue.GetType()); } else { si.UpdateValue((String)fixupInfo, holderValue, typeof(MarshalByRefObject)); } //Decrement our total number of fixups left to do. fixupsPerformed++; fixups.m_values[i]=null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); tempObjectHolder.RemoveDependency(holder.m_id); } } } } } else { BCLDebug.Trace("SER", "[ObjectManager.CompleteObject]Non-ISerializableObject: ", holder.m_id); for (int i=0; i<fixups.m_count; i++) { currentFixup = fixups.m_values[i]; if (currentFixup==null) { continue; } BCLDebug.Trace("SER", "[ObjectManager.CompleteObject]Getting fixup info for object: ", currentFixup.m_id); if (GetCompletionInfo(currentFixup, out tempObjectHolder, out fixupInfo, bObjectFullyComplete)) { BCLDebug.Trace("SER", "[ObjectManager.CompleteObject]Fixing up: ", currentFixup.m_id); //There are two types of fixups that we could be doing: array or member. //Delayed Fixups should be handled by the above branch. switch(currentFixup.m_fixupType) { case FixupHolder.ArrayFixup: BCLDebug.Assert(holder.ObjectValue is Array,"holder.ObjectValue is Array"); if (holder.RequiresValueTypeFixup) { throw new SerializationException(Environment.GetResourceString("Serialization_ValueTypeFixup")); } else { ((Array)(holder.ObjectValue)).SetValue(tempObjectHolder.ObjectValue, ((int[])fixupInfo)); } break; case FixupHolder.MemberFixup: BCLDebug.Assert(fixupInfo is MemberInfo,"fixupInfo is MemberInfo"); //Fixup the member directly. MemberInfo tempMember = (MemberInfo)fixupInfo; if (tempMember.MemberType==MemberTypes.Field) { BCLDebug.Trace("SER", "[ObjectManager.CompleteObject]Fixing member: ", tempMember.Name, " in object ", holder.m_id, " with object ", tempObjectHolder.m_id); // If we have a valuetype that's been boxed to an object and requires a fixup, // there are two possible states: // (a)The valuetype has never been fixed up into it's container. In this case, we should // just fix up the boxed valuetype. The task of pushing that valuetype into it's container // will be handled later. This case is handled by the else clause of the following statement. // (b)The valuetype has already been inserted into it's container. In that case, we need // to go through the more complicated path laid out in DoValueTypeFixup. We can tell that the // valuetype has already been inserted into it's container because we set ValueTypeFixupPerformed // to true when we do this. if (holder.RequiresValueTypeFixup && holder.ValueTypeFixupPerformed) { if (!DoValueTypeFixup((FieldInfo)tempMember, holder, tempObjectHolder.ObjectValue)) { throw new SerializationException(Environment.GetResourceString("Serialization_PartialValueTypeFixup")); } } else { FormatterServices.SerializationSetValue(tempMember, holder.ObjectValue, tempObjectHolder.ObjectValue); if (tempObjectHolder.RequiresValueTypeFixup) { tempObjectHolder.ValueTypeFixupPerformed = true; } } } else { throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } break; default: throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } //Decrement our total number of fixups left to do. fixupsPerformed++; fixups.m_values[i]=null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); tempObjectHolder.RemoveDependency(holder.m_id); } } } } m_fixupCount-=fixupsPerformed; if (fixups.m_count==fixupsPerformed) { holder.m_missingElements=null; } }
internal void CompleteObject(ObjectHolder holder, bool bObjectFullyComplete) { FixupHolderList missingElements = holder.m_missingElements; object obj = null; ObjectHolder objectHolder = null; int num = 0; if (holder.ObjectValue == null) { throw new SerializationException(Environment.GetResourceString("Serialization_MissingObject", new object[] { holder.m_id })); } if (missingElements == null) { return; } if (holder.HasSurrogate || holder.HasISerializable) { SerializationInfo serInfo = holder.m_serInfo; if (serInfo == null) { throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFixupDiscovered")); } if (missingElements != null) { for (int i = 0; i < missingElements.m_count; i++) { if (missingElements.m_values[i] != null && this.GetCompletionInfo(missingElements.m_values[i], out objectHolder, out obj, bObjectFullyComplete)) { object objectValue = objectHolder.ObjectValue; if (this.CanCallGetType(objectValue)) { serInfo.UpdateValue((string)obj, objectValue, objectValue.GetType()); } else { serInfo.UpdateValue((string)obj, objectValue, typeof(MarshalByRefObject)); } num++; missingElements.m_values[i] = null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); objectHolder.RemoveDependency(holder.m_id); } } } } } else { for (int j = 0; j < missingElements.m_count; j++) { FixupHolder fixupHolder = missingElements.m_values[j]; if (fixupHolder != null && this.GetCompletionInfo(fixupHolder, out objectHolder, out obj, bObjectFullyComplete)) { if (objectHolder.TypeLoadExceptionReachable) { holder.TypeLoadException = objectHolder.TypeLoadException; if (holder.Reachable) { throw new SerializationException(Environment.GetResourceString("Serialization_TypeLoadFailure", new object[] { holder.TypeLoadException.TypeName })); } } if (holder.Reachable) { objectHolder.Reachable = true; } int fixupType = fixupHolder.m_fixupType; if (fixupType != 1) { if (fixupType != 2) { throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } MemberInfo memberInfo = (MemberInfo)obj; if (memberInfo.MemberType != MemberTypes.Field) { throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } if (holder.RequiresValueTypeFixup && holder.ValueTypeFixupPerformed) { if (!this.DoValueTypeFixup((FieldInfo)memberInfo, holder, objectHolder.ObjectValue)) { throw new SerializationException(Environment.GetResourceString("Serialization_PartialValueTypeFixup")); } } else { FormatterServices.SerializationSetValue(memberInfo, holder.ObjectValue, objectHolder.ObjectValue); } if (objectHolder.RequiresValueTypeFixup) { objectHolder.ValueTypeFixupPerformed = true; } } else { if (holder.RequiresValueTypeFixup) { throw new SerializationException(Environment.GetResourceString("Serialization_ValueTypeFixup")); } ((Array)holder.ObjectValue).SetValue(objectHolder.ObjectValue, (int[])obj); } num++; missingElements.m_values[j] = null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); objectHolder.RemoveDependency(holder.m_id); } } } } this.m_fixupCount -= (long)num; if (missingElements.m_count == num) { holder.m_missingElements = null; } }
internal void CompleteObject(ObjectHolder holder, bool bObjectFullyComplete) { FixupHolderList missingElements = holder.m_missingElements; object member = null; ObjectHolder holder3 = null; int num = 0; if (holder.ObjectValue == null) { throw new SerializationException(Environment.GetResourceString("Serialization_MissingObject", new object[] { holder.m_id })); } if (missingElements != null) { if (holder.HasSurrogate || holder.HasISerializable) { SerializationInfo serInfo = holder.m_serInfo; if (serInfo == null) { throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFixupDiscovered")); } if (missingElements != null) { for (int i = 0; i < missingElements.m_count; i++) { if ((missingElements.m_values[i] != null) && this.GetCompletionInfo(missingElements.m_values[i], out holder3, out member, bObjectFullyComplete)) { object objectValue = holder3.ObjectValue; if (this.CanCallGetType(objectValue)) { serInfo.UpdateValue((string)member, objectValue, objectValue.GetType()); } else { serInfo.UpdateValue((string)member, objectValue, typeof(MarshalByRefObject)); } num++; missingElements.m_values[i] = null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); holder3.RemoveDependency(holder.m_id); } } } } } else { for (int j = 0; j < missingElements.m_count; j++) { MemberInfo info2; FixupHolder fixup = missingElements.m_values[j]; if ((fixup == null) || !this.GetCompletionInfo(fixup, out holder3, out member, bObjectFullyComplete)) { continue; } if (holder3.TypeLoadExceptionReachable) { holder.TypeLoadException = holder3.TypeLoadException; if (holder.Reachable) { throw new SerializationException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_TypeLoadFailure"), new object[] { holder.TypeLoadException.TypeName })); } } if (holder.Reachable) { holder3.Reachable = true; } switch (fixup.m_fixupType) { case 1: if (holder.RequiresValueTypeFixup) { throw new SerializationException(Environment.GetResourceString("Serialization_ValueTypeFixup")); } break; case 2: info2 = (MemberInfo)member; if (info2.MemberType != MemberTypes.Field) { throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } if (!holder.RequiresValueTypeFixup || !holder.ValueTypeFixupPerformed) { goto Label_024C; } if (!this.DoValueTypeFixup((FieldInfo)info2, holder, holder3.ObjectValue)) { throw new SerializationException(Environment.GetResourceString("Serialization_PartialValueTypeFixup")); } goto Label_0260; default: throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } ((Array)holder.ObjectValue).SetValue(holder3.ObjectValue, (int[])member); goto Label_0293; Label_024C: FormatterServices.SerializationSetValue(info2, holder.ObjectValue, holder3.ObjectValue); Label_0260: if (holder3.RequiresValueTypeFixup) { holder3.ValueTypeFixupPerformed = true; } Label_0293: num++; missingElements.m_values[j] = null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); holder3.RemoveDependency(holder.m_id); } } } this.m_fixupCount -= num; if (missingElements.m_count == num) { holder.m_missingElements = null; } } }
internal void CompleteObject(ObjectHolder holder, bool bObjectFullyComplete) { FixupHolderList missingElements = holder.m_missingElements; object member = null; ObjectHolder holder3 = null; int num = 0; if (holder.ObjectValue == null) { throw new SerializationException(Environment.GetResourceString("Serialization_MissingObject", new object[] { holder.m_id })); } if (missingElements != null) { if (holder.HasSurrogate || holder.HasISerializable) { SerializationInfo serInfo = holder.m_serInfo; if (serInfo == null) { throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFixupDiscovered")); } if (missingElements != null) { for (int i = 0; i < missingElements.m_count; i++) { if ((missingElements.m_values[i] != null) && this.GetCompletionInfo(missingElements.m_values[i], out holder3, out member, bObjectFullyComplete)) { object objectValue = holder3.ObjectValue; if (this.CanCallGetType(objectValue)) { serInfo.UpdateValue((string) member, objectValue, objectValue.GetType()); } else { serInfo.UpdateValue((string) member, objectValue, typeof(MarshalByRefObject)); } num++; missingElements.m_values[i] = null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); holder3.RemoveDependency(holder.m_id); } } } } } else { for (int j = 0; j < missingElements.m_count; j++) { MemberInfo info2; FixupHolder fixup = missingElements.m_values[j]; if ((fixup == null) || !this.GetCompletionInfo(fixup, out holder3, out member, bObjectFullyComplete)) { continue; } if (holder3.TypeLoadExceptionReachable) { holder.TypeLoadException = holder3.TypeLoadException; if (holder.Reachable) { throw new SerializationException(Environment.GetResourceString("Serialization_TypeLoadFailure", new object[] { holder.TypeLoadException.TypeName })); } } if (holder.Reachable) { holder3.Reachable = true; } switch (fixup.m_fixupType) { case 1: if (holder.RequiresValueTypeFixup) { throw new SerializationException(Environment.GetResourceString("Serialization_ValueTypeFixup")); } break; case 2: info2 = (MemberInfo) member; if (info2.MemberType != MemberTypes.Field) { throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } if (!holder.RequiresValueTypeFixup || !holder.ValueTypeFixupPerformed) { goto Label_0242; } if (!this.DoValueTypeFixup((FieldInfo) info2, holder, holder3.ObjectValue)) { throw new SerializationException(Environment.GetResourceString("Serialization_PartialValueTypeFixup")); } goto Label_0256; default: throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } ((Array) holder.ObjectValue).SetValue(holder3.ObjectValue, (int[]) member); goto Label_0289; Label_0242: FormatterServices.SerializationSetValue(info2, holder.ObjectValue, holder3.ObjectValue); Label_0256: if (holder3.RequiresValueTypeFixup) { holder3.ValueTypeFixupPerformed = true; } Label_0289: num++; missingElements.m_values[j] = null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); holder3.RemoveDependency(holder.m_id); } } } this.m_fixupCount -= num; if (missingElements.m_count == num) { holder.m_missingElements = null; } } }
internal void CompleteObject(ObjectHolder holder, bool bObjectFullyComplete) { FixupHolderList fixupHolderList = holder.m_missingElements; object member = (object)null; ObjectHolder holder1 = (ObjectHolder)null; int num = 0; if (holder.ObjectValue == null) { throw new SerializationException(Environment.GetResourceString("Serialization_MissingObject", (object)holder.m_id)); } if (fixupHolderList == null) { return; } if (holder.HasSurrogate || holder.HasISerializable) { SerializationInfo serializationInfo1 = holder.m_serInfo; if (serializationInfo1 == null) { throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFixupDiscovered")); } if (fixupHolderList != null) { for (int index = 0; index < fixupHolderList.m_count; ++index) { if (fixupHolderList.m_values[index] != null && this.GetCompletionInfo(fixupHolderList.m_values[index], out holder1, out member, bObjectFullyComplete)) { object objectValue = holder1.ObjectValue; if (this.CanCallGetType(objectValue)) { SerializationInfo serializationInfo2 = serializationInfo1; string name = (string)member; object obj = objectValue; Type type = obj.GetType(); serializationInfo2.UpdateValue(name, obj, type); } else { serializationInfo1.UpdateValue((string)member, objectValue, typeof(MarshalByRefObject)); } ++num; fixupHolderList.m_values[index] = (FixupHolder)null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); holder1.RemoveDependency(holder.m_id); } } } } } else { for (int index = 0; index < fixupHolderList.m_count; ++index) { FixupHolder fixup = fixupHolderList.m_values[index]; if (fixup != null && this.GetCompletionInfo(fixup, out holder1, out member, bObjectFullyComplete)) { if (holder1.TypeLoadExceptionReachable) { holder.TypeLoadException = holder1.TypeLoadException; if (holder.Reachable) { throw new SerializationException(Environment.GetResourceString("Serialization_TypeLoadFailure", (object)holder.TypeLoadException.TypeName)); } } if (holder.Reachable) { holder1.Reachable = true; } switch (fixup.m_fixupType) { case 1: if (holder.RequiresValueTypeFixup) { throw new SerializationException(Environment.GetResourceString("Serialization_ValueTypeFixup")); } ((Array)holder.ObjectValue).SetValue(holder1.ObjectValue, (int[])member); break; case 2: MemberInfo fi = (MemberInfo)member; if (fi.MemberType != MemberTypes.Field) { throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } if (holder.RequiresValueTypeFixup && holder.ValueTypeFixupPerformed) { if (!this.DoValueTypeFixup((FieldInfo)fi, holder, holder1.ObjectValue)) { throw new SerializationException(Environment.GetResourceString("Serialization_PartialValueTypeFixup")); } } else { FormatterServices.SerializationSetValue(fi, holder.ObjectValue, holder1.ObjectValue); } if (holder1.RequiresValueTypeFixup) { holder1.ValueTypeFixupPerformed = true; break; } break; default: throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFixup")); } ++num; fixupHolderList.m_values[index] = (FixupHolder)null; if (!bObjectFullyComplete) { holder.DecrementFixupsRemaining(this); holder1.RemoveDependency(holder.m_id); } } } } this.m_fixupCount = this.m_fixupCount - (long)num; if (fixupHolderList.m_count != num) { return; } holder.m_missingElements = (FixupHolderList)null; }