public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
int targetIndex = 0;
Object[] invocationList = _invocationList as Object[];
if (invocationList == null)
{
MethodInfo method = Method;
// A MethodInfo object can be a RuntimeMethodInfo, a RefEmit method (MethodBuilder, etc), or a DynamicMethod
// One can only create delegates on RuntimeMethodInfo and DynamicMethod.
// If it is not a RuntimeMethodInfo (must be a DynamicMethod) or if it is an unmanaged function pointer, throw
if (!(method is RuntimeMethodInfo) || IsUnmanagedFunctionPtr())
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
// We can't deal with secure delegates either.
if (!InvocationListLogicallyNull() && !_invocationCount.IsNull() && !_methodPtrAux.IsNull())
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
DelegateSerializationHolder.GetDelegateSerializationInfo(info, this.GetType(), Target, method, targetIndex);
}
else
{
DelegateSerializationHolder.DelegateEntry nextDe = null;
int invocationCount = (int)_invocationCount;
for (int i = invocationCount; --i >= 0;)
{
MulticastDelegate d = (MulticastDelegate)invocationList[i];
MethodInfo method = d.Method;
// If it is not a RuntimeMethodInfo (must be a DynamicMethod) or if it is an unmanaged function pointer, skip
if (!(method is RuntimeMethodInfo) || IsUnmanagedFunctionPtr())
{
continue;
}
// We can't deal with secure delegates either.
if (!d.InvocationListLogicallyNull() && !d._invocationCount.IsNull() && !d._methodPtrAux.IsNull())
{
continue;
}
DelegateSerializationHolder.DelegateEntry de = DelegateSerializationHolder.GetDelegateSerializationInfo(info, d.GetType(), d.Target, method, targetIndex++);
if (nextDe != null)
{
nextDe.Entry = de;
}
nextDe = de;
}
// if nothing was serialized it is a delegate over a DynamicMethod, so just throw
if (nextDe == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
}
}
// Get serialization data for this delegate.
public override void GetObjectData
(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
DelegateSerializationHolder.SerializeMulticast(info, this);
}
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
int targetIndex = 0;
Object[] invocationList = _invocationList as Object[];
if (invocationList == null)
{
MethodInfo method = Method;
// if it is a delegate over a DynamicMethod or an unmanaged function pointer, throw
if (method is System.Reflection.Emit.DynamicMethod || method is System.Reflection.Emit.DynamicMethod.RTDynamicMethod || IsUnmanagedFunctionPtr())
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
// We can't deal with secure delegates either.
if (_invocationList != null && !_invocationCount.IsNull())
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
DelegateSerializationHolder.GetDelegateSerializationInfo(info, this.GetType(), Target, method, targetIndex);
}
else
{
DelegateSerializationHolder.DelegateEntry nextDe = null;
int invocationCount = (int)_invocationCount;
for (int i = invocationCount; --i >= 0;)
{
MulticastDelegate d = (MulticastDelegate)invocationList[i];
MethodInfo method = d.Method;
if (method is System.Reflection.Emit.DynamicMethod || method is System.Reflection.Emit.DynamicMethod.RTDynamicMethod || IsUnmanagedFunctionPtr())
{
continue;
}
// We can't deal with secure delegates either.
if (d._invocationList != null && !d._invocationCount.IsNull())
{
continue;
}
DelegateSerializationHolder.DelegateEntry de = DelegateSerializationHolder.GetDelegateSerializationInfo(info, d.GetType(), d.Target, method, targetIndex++);
if (nextDe != null)
{
nextDe.Entry = de;
}
nextDe = de;
}
// if nothing was serialized it is a delegate over a DynamicMethod, so just throw
if (nextDe == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
}
}
internal DelegateSerializationHolder.DelegateEntry GetDelegateSerializationInfo(SerializationInfo info, StreamingContext context, int targetIndex)
{
DelegateSerializationHolder.DelegateEntry de = DelegateSerializationHolder.GetDelegateSerializationInfo(info, this.GetType(), Target, Method, targetIndex);
if (_prev != null)
{
DelegateSerializationHolder.DelegateEntry previousde = _prev.GetDelegateSerializationInfo(info, context, ++targetIndex);
de.Entry = previousde;
}
return(de);
}
// Get the serialization data for this object.
public virtual void GetObjectData(SerializationInfo info,
StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
DelegateSerializationHolder.Serialize
(info, 0, GetType(), target,
MethodBase.GetMethodFromHandle(method));
}
//
// Implementation of ISerializable
//
/// <include file='doc\Delegate.uex' path='docs/doc[@for="Delegate.GetObjectData"]/*' />
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (!IsStatic())
{
DelegateSerializationHolder.GetDelegateSerializationInfo(info, this.GetType(), _target, Method, 0);
}
else
{
DelegateSerializationHolder.GetDelegateSerializationInfo(info, this.GetType(), null, Method, 0);
}
}
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
int targetIndex = 0;
object[] array = this._invocationList as object[];
if (array == null)
{
MethodInfo method = base.Method;
if (!(method is RuntimeMethodInfo) || this.IsUnmanagedFunctionPtr())
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
if (!this.InvocationListLogicallyNull() && !this._invocationCount.IsNull() && !this._methodPtrAux.IsNull())
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
DelegateSerializationHolder.GetDelegateSerializationInfo(info, base.GetType(), base.Target, method, targetIndex);
return;
}
else
{
DelegateSerializationHolder.DelegateEntry delegateEntry = null;
int num = (int)this._invocationCount;
int num2 = num;
while (--num2 >= 0)
{
MulticastDelegate multicastDelegate = (MulticastDelegate)array[num2];
MethodInfo method2 = multicastDelegate.Method;
if (method2 is RuntimeMethodInfo && !this.IsUnmanagedFunctionPtr() && (multicastDelegate.InvocationListLogicallyNull() || multicastDelegate._invocationCount.IsNull() || multicastDelegate._methodPtrAux.IsNull()))
{
DelegateSerializationHolder.DelegateEntry delegateSerializationInfo = DelegateSerializationHolder.GetDelegateSerializationInfo(info, multicastDelegate.GetType(), multicastDelegate.Target, method2, targetIndex++);
if (delegateEntry != null)
{
delegateEntry.Entry = delegateSerializationInfo;
}
delegateEntry = delegateSerializationInfo;
}
}
if (delegateEntry == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
return;
}
}
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
int targetIndex = 0;
object[] objArray = this._invocationList as object[];
if (objArray == null)
{
MethodInfo method = base.Method;
if (((method is DynamicMethod) || (method is DynamicMethod.RTDynamicMethod)) || this.IsUnmanagedFunctionPtr())
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
if ((this._invocationList != null) && !this._invocationCount.IsNull())
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
DelegateSerializationHolder.GetDelegateSerializationInfo(info, base.GetType(), base.Target, method, targetIndex);
}
else
{
DelegateSerializationHolder.DelegateEntry entry = null;
int index = (int)this._invocationCount;
while (--index >= 0)
{
MulticastDelegate delegate2 = (MulticastDelegate)objArray[index];
MethodInfo info3 = delegate2.Method;
if (((!(info3 is DynamicMethod) && !(info3 is DynamicMethod.RTDynamicMethod)) && !this.IsUnmanagedFunctionPtr()) && ((delegate2._invocationList == null) || delegate2._invocationCount.IsNull()))
{
DelegateSerializationHolder.DelegateEntry entry2 = DelegateSerializationHolder.GetDelegateSerializationInfo(info, delegate2.GetType(), delegate2.Target, info3, targetIndex++);
if (entry != null)
{
entry.Entry = entry2;
}
entry = entry2;
}
}
if (entry == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_InvalidDelegateType"));
}
}
}
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
Contract.EndContractBlock();
Delegate[] invocationList = m_helperObject as Delegate[];
if (invocationList == null)
{
if (Method == null)
{
throw new SerializationException(SR.DelegateSer_InsufficientMetadata);
}
DelegateSerializationHolder.GetDelegateSerializationInfo(info, this.GetType(), Target, Method, 0);
}
else
{
int targetIndex = 0;
DelegateSerializationHolder.DelegateEntry previousEntry = null;
int invocationCount = (int)m_extraFunctionPointerOrData;
for (int i = invocationCount; --i >= 0;)
{
MulticastDelegate d = (MulticastDelegate)invocationList[i];
if (d.Method == null)
{
throw new SerializationException(SR.DelegateSer_InsufficientMetadata);
}
DelegateSerializationHolder.DelegateEntry de = DelegateSerializationHolder.GetDelegateSerializationInfo(info, d.GetType(), d.Target, d.Method, targetIndex++);
if (previousEntry != null)
{
previousEntry.NextEntry = de;
}
previousEntry = de;
}
}
}
// This is from ISerializable
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
DelegateSerializationHolder.GetDelegateData(this, info, context);
}
private Delegate GetDelegate(DelegateSerializationHolder.DelegateEntry de, int index)
{
Delegate @delegate;
try
{
if (de.methodName == null || de.methodName.Length == 0)
{
this.ThrowInsufficientState("MethodName");
}
if (de.assembly == null || de.assembly.Length == 0)
{
this.ThrowInsufficientState("DelegateAssembly");
}
if (de.targetTypeName == null || de.targetTypeName.Length == 0)
{
this.ThrowInsufficientState("TargetTypeName");
}
RuntimeType type = (RuntimeType)Assembly.Load(de.assembly).GetType(de.type, true, false);
RuntimeType runtimeType = (RuntimeType)Assembly.Load(de.targetTypeAssembly).GetType(de.targetTypeName, true, false);
if (this.m_methods != null)
{
object firstArgument = (de.target != null) ? RemotingServices.CheckCast(de.target, runtimeType) : null;
@delegate = Delegate.InternalCreateDelegate(type, firstArgument, this.m_methods[index]);
}
else
{
if (de.target != null)
{
@delegate = Delegate.CreateDelegate(type, RemotingServices.CheckCast(de.target, runtimeType), de.methodName);
}
else
{
@delegate = Delegate.CreateDelegate(type, runtimeType, de.methodName);
}
}
if ((@delegate.Method != null && [email protected]) || (@delegate.Method.DeclaringType != null && [email protected]))
{
new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
}
}
catch (Exception ex)
{
if (ex is SerializationException)
{
throw ex;
}
throw new SerializationException(ex.Message, ex);
}
return @delegate;
}