|
private DecrementFixupsRemaining ( |
||
| manager | ||
| return | void | |
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;
}
