/// <include file='doc\ObjectManager.uex' path='docs/doc[@for="ObjectManager.RemoveOnDeserialization"]/*' />
internal virtual void RemoveOnDeserialization(DeserializationEventHandler handler) {
m_onDeserializationHandler = (DeserializationEventHandler)Delegate.Remove(m_onDeserializationHandler, handler);
}
/// <include file='doc\ObjectManager.uex' path='docs/doc[@for="ObjectManager.RegisterObject3"]/*' />
public void RegisterObject(Object obj, long objectID, SerializationInfo info, long idOfContainingObj, MemberInfo member, int[] arrayIndex) {
ObjectHolder temp;
ISerializationSurrogate surrogate = null;
ISurrogateSelector useless;
if (obj==null) {
throw new ArgumentNullException("obj");
}
if (objectID<=0) {
throw new ArgumentOutOfRangeException("objectID", Environment.GetResourceString("ArgumentOutOfRange_ObjectID"));
}
if (member!=null && !(member is RuntimeFieldInfo) && !(member is SerializationFieldInfo)) {
throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMemberInfo"));
}
if (m_selector != null)
{
Type selectorType=null;
if (CanCallGetType(obj)) {
selectorType = obj.GetType();
} else {
selectorType = typeof(MarshalByRefObject);
}
BCLDebug.Trace("SER", "[ObjectManager.RegisterObject]ID: ", objectID, "\tType: ", selectorType, "\tValue: ", obj);
//If we need a surrogate for this object, lets find it now.
surrogate = m_selector.GetSurrogate(selectorType, m_context, out useless);
}
//The object is interested in DeserializationEvents so lets register it.
if (obj is IDeserializationCallback) {
DeserializationEventHandler d = new DeserializationEventHandler(((IDeserializationCallback)obj).OnDeserialization);
AddOnDeserialization(d);
}
temp = FindObjectHolder(objectID);
//This is the first time which we've seen the object, we need to create a new holder.
if (temp==null) {
BCLDebug.Trace("SER", "[ObjectManager.RegisterObject]Adding a new object holder for ", objectID);
//Formatter developers may cache and reuse arrayIndex in their code.
//So that we don't get bitten by this, take a copy up front.
int [] arrayTemp=null;
if (arrayIndex!=null) {
arrayTemp = (int[])arrayIndex.Clone();
}
temp = new ObjectHolder(obj, objectID, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayTemp);
AddObjectHolder(temp);
if (temp.RequiresDelayedFixup) {
SpecialFixupObjects.Add(temp);
}
return;
}
//If the object isn't null, we've registered this before. Not good.
if (temp.ObjectValue!=null) {
throw new SerializationException(Environment.GetResourceString("Serialization_RegisterTwice"));
}
//Complete the data in the ObjectHolder
temp.UpdateData(obj, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayIndex, this);
// The following case will only be true when somebody has registered a fixup on an object before
// registering the object itself. I don't believe that most well-behaved formatters will do this,
// but we need to allow it anyway. We will walk the list of fixups which have been recorded on
// the new object and fix those that we can. Because the user could still register later fixups
// on this object, we won't call any implementations of ISerializable now. If that's required,
// it will have to be handled by the code in DoFixups.
// README README: We have to do the UpdateData before
if (temp.DirectlyDependentObjects>0) {
CompleteObject(temp, false);
}
if (temp.RequiresDelayedFixup) {
BCLDebug.Trace("SER", "[ObjectManager.RegisterObject]Tracking incomplete objref for element: ", temp.m_id);
SpecialFixupObjects.Add(temp);
}
if (!(temp.IsIncompleteObjectReference)) {
//Here's where things get tricky. If this isn't an instance of IObjectReference, we need to walk it's fixup
//chain and decrement the counters on anything that has reached 0. Once we've notified all of the dependencies,
//we can simply clear the list of dependent objects.
BCLDebug.Trace("SER", "[ObjectManager.RegisterObject]Calling DoNewlyRegisteredObjectFixups for element: ", temp.m_id);
DoNewlyRegisteredObjectFixups(temp);
temp.DependentObjects=null;
}
BCLDebug.Trace("SER", "[ObjectManager.RegisterObject]Exiting.");
}
/// <include file='doc\ObjectManager.uex' path='docs/doc[@for="ObjectManager.AddOnDeserialization"]/*' />
internal virtual void AddOnDeserialization(DeserializationEventHandler handler) {
m_onDeserializationHandler = (DeserializationEventHandler)Delegate.Combine(m_onDeserializationHandler, handler);
}
// Token: 0x06005164 RID: 20836 RVA: 0x0011DAC3 File Offset: 0x0011BCC3
internal virtual void AddOnDeserialization(DeserializationEventHandler handler)
{
this.m_onDeserializationHandler = (DeserializationEventHandler)Delegate.Combine(this.m_onDeserializationHandler, handler);
}
// Token: 0x06005165 RID: 20837 RVA: 0x0011DADC File Offset: 0x0011BCDC
internal virtual void RemoveOnDeserialization(DeserializationEventHandler handler)
{
this.m_onDeserializationHandler = (DeserializationEventHandler)Delegate.Remove(this.m_onDeserializationHandler, handler);
}
public void RegisterObject(object obj, long objectID, SerializationInfo info, long idOfContainingObj, MemberInfo member, int[] arrayIndex)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (objectID <= 0L)
{
throw new ArgumentOutOfRangeException("objectID", Environment.GetResourceString("ArgumentOutOfRange_ObjectID"));
}
if (member != null && !(member is RuntimeFieldInfo) && !(member is SerializationFieldInfo))
{
throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMemberInfo"));
}
ISerializationSurrogate surrogate = null;
if (this.m_selector != null)
{
Type type;
if (this.CanCallGetType(obj))
{
type = obj.GetType();
}
else
{
type = typeof(MarshalByRefObject);
}
ISurrogateSelector surrogateSelector;
surrogate = this.m_selector.GetSurrogate(type, this.m_context, out surrogateSelector);
}
if (obj is IDeserializationCallback)
{
DeserializationEventHandler handler = new DeserializationEventHandler(((IDeserializationCallback)obj).OnDeserialization);
this.AddOnDeserialization(handler);
}
if (arrayIndex != null)
{
arrayIndex = (int[])arrayIndex.Clone();
}
ObjectHolder objectHolder = this.FindObjectHolder(objectID);
if (objectHolder == null)
{
objectHolder = new ObjectHolder(obj, objectID, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayIndex);
this.AddObjectHolder(objectHolder);
if (objectHolder.RequiresDelayedFixup)
{
this.SpecialFixupObjects.Add(objectHolder);
}
this.AddOnDeserialized(obj);
return;
}
if (objectHolder.ObjectValue != null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_RegisterTwice"));
}
objectHolder.UpdateData(obj, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayIndex, this);
if (objectHolder.DirectlyDependentObjects > 0)
{
this.CompleteObject(objectHolder, false);
}
if (objectHolder.RequiresDelayedFixup)
{
this.SpecialFixupObjects.Add(objectHolder);
}
if (objectHolder.CompletelyFixed)
{
this.DoNewlyRegisteredObjectFixups(objectHolder);
objectHolder.DependentObjects = null;
}
if (objectHolder.TotalDependentObjects > 0)
{
this.AddOnDeserialized(obj);
return;
}
this.RaiseOnDeserializedEvent(obj);
}
public void RegisterObject(object obj, long objectID, SerializationInfo info, long idOfContainingObj, MemberInfo member, int[] arrayIndex)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (objectID <= 0)
{
throw new ArgumentOutOfRangeException(nameof(objectID), SR.ArgumentOutOfRange_ObjectID);
}
if (member != null && !(member is FieldInfo))
{
throw new SerializationException(SR.Serialization_UnknownMemberInfo);
}
ObjectHolder temp;
ISerializationSurrogate surrogate = null;
ISurrogateSelector useless;
if (_selector != null)
{
Type selectorType = CanCallGetType(obj) ?
obj.GetType() :
typeof(MarshalByRefObject);
//If we need a surrogate for this object, lets find it now.
surrogate = _selector.GetSurrogate(selectorType, _context, out useless);
}
//The object is interested in DeserializationEvents so lets register it.
if (obj is IDeserializationCallback)
{
DeserializationEventHandler d = new DeserializationEventHandler(((IDeserializationCallback)obj).OnDeserialization);
AddOnDeserialization(d);
}
//Formatter developers may cache and reuse arrayIndex in their code.
//So that we don't get bitten by this, take a copy up front.
if (arrayIndex != null)
{
arrayIndex = (int[])arrayIndex.Clone();
}
//This is the first time which we've seen the object, we need to create a new holder.
temp = FindObjectHolder(objectID);
if (temp == null)
{
temp = new ObjectHolder(obj, objectID, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayIndex);
AddObjectHolder(temp);
if (temp.RequiresDelayedFixup)
{
SpecialFixupObjects.Add(temp);
}
// We cannot compute whether this has any fixups required or not
AddOnDeserialized(obj);
return;
}
//If the object isn't null, we've registered this before. Not good.
if (temp.ObjectValue != null)
{
throw new SerializationException(SR.Serialization_RegisterTwice);
}
//Complete the data in the ObjectHolder
temp.UpdateData(obj, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayIndex, this);
// The following case will only be true when somebody has registered a fixup on an object before
// registering the object itself. I don't believe that most well-behaved formatters will do this,
// but we need to allow it anyway. We will walk the list of fixups which have been recorded on
// the new object and fix those that we can. Because the user could still register later fixups
// on this object, we won't call any implementations of ISerializable now. If that's required,
// it will have to be handled by the code in DoFixups.
// README README: We have to do the UpdateData before
if (temp.DirectlyDependentObjects > 0)
{
CompleteObject(temp, false);
}
if (temp.RequiresDelayedFixup)
{
SpecialFixupObjects.Add(temp);
}
if (temp.CompletelyFixed)
{
//Here's where things get tricky. If this isn't an instance of IObjectReference, we need to walk it's fixup
//chain and decrement the counters on anything that has reached 0. Once we've notified all of the dependencies,
//we can simply clear the list of dependent objects.
DoNewlyRegisteredObjectFixups(temp);
temp.DependentObjects = null;
}
//Register the OnDeserialized methods to be invoked after deserialization is complete
if (temp.TotalDependentObjects > 0)
{
AddOnDeserialized(obj);
}
else
{
RaiseOnDeserializedEvent(obj);
}
}
public void RegisterObject(object obj, long objectID, SerializationInfo info, long idOfContainingObj, MemberInfo member, int[] arrayIndex)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (objectID <= 0L)
{
throw new ArgumentOutOfRangeException("objectID", Environment.GetResourceString("ArgumentOutOfRange_ObjectID"));
}
if (((member != null) && !(member is RuntimeFieldInfo)) && !(member is SerializationFieldInfo))
{
throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMemberInfo"));
}
ISerializationSurrogate surrogate = null;
if (this.m_selector != null)
{
ISurrogateSelector selector;
Type type = null;
if (this.CanCallGetType(obj))
{
type = obj.GetType();
}
else
{
type = typeof(MarshalByRefObject);
}
surrogate = this.m_selector.GetSurrogate(type, this.m_context, out selector);
}
if (obj is IDeserializationCallback)
{
IDeserializationCallback callback1 = (IDeserializationCallback) obj;
DeserializationEventHandler handler = new DeserializationEventHandler(callback1.OnDeserialization);
this.AddOnDeserialization(handler);
}
if (arrayIndex != null)
{
arrayIndex = (int[]) arrayIndex.Clone();
}
ObjectHolder holder = this.FindObjectHolder(objectID);
if (holder == null)
{
holder = new ObjectHolder(obj, objectID, info, surrogate, idOfContainingObj, (FieldInfo) member, arrayIndex);
this.AddObjectHolder(holder);
if (holder.RequiresDelayedFixup)
{
this.SpecialFixupObjects.Add(holder);
}
this.AddOnDeserialized(obj);
}
else
{
if (holder.ObjectValue != null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_RegisterTwice"));
}
holder.UpdateData(obj, info, surrogate, idOfContainingObj, (FieldInfo) member, arrayIndex, this);
if (holder.DirectlyDependentObjects > 0)
{
this.CompleteObject(holder, false);
}
if (holder.RequiresDelayedFixup)
{
this.SpecialFixupObjects.Add(holder);
}
if (holder.CompletelyFixed)
{
this.DoNewlyRegisteredObjectFixups(holder);
holder.DependentObjects = null;
}
if (holder.TotalDependentObjects > 0)
{
this.AddOnDeserialized(obj);
}
else
{
this.RaiseOnDeserializedEvent(obj);
}
}
}
internal virtual void RemoveOnDeserialization(DeserializationEventHandler handler)
{
this.m_onDeserializationHandler = this.m_onDeserializationHandler - handler;
}
internal virtual void AddOnDeserialization(DeserializationEventHandler handler)
{
this.m_onDeserializationHandler = this.m_onDeserializationHandler + handler;
}
