Inheritance: IObjectReference, ISerializable
        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"));
                }
            }
        }
Esempio n. 2
0
 // 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"));
                }
            }
        }
Esempio n. 4
0
 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);
 }
Esempio n. 5
0
 // 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));
 }
Esempio n. 6
0
        //
        // 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;
            }
        }
Esempio n. 8
0
        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"));
                }
            }
        }
Esempio n. 9
0
        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;
                }
            }
        }
Esempio n. 10
0
 // 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;
		}