private Delegate GetDelegate(DelegateEntry de, int index)
 {
     Delegate delegate2;
     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");
         }
         Type type = Assembly.Load(de.assembly).GetType(de.type, true, false);
         Type type2 = Assembly.Load(de.targetTypeAssembly).GetType(de.targetTypeName, true, false);
         if (this.m_methods != null)
         {
             object firstArgument = (de.target != null) ? RemotingServices.CheckCast(de.target, type2) : null;
             delegate2 = Delegate.InternalCreateDelegate(type, firstArgument, this.m_methods[index]);
         }
         else if (de.target != null)
         {
             delegate2 = Delegate.CreateDelegate(type, RemotingServices.CheckCast(de.target, type2), de.methodName);
         }
         else
         {
             delegate2 = Delegate.CreateDelegate(type, type2, de.methodName);
         }
         if (((delegate2.Method == null) || delegate2.Method.IsPublic) && ((delegate2.Method.DeclaringType == null) || delegate2.Method.DeclaringType.IsVisible))
         {
             return delegate2;
         }
         new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
     }
     catch (Exception exception)
     {
         if (exception is SerializationException)
         {
             throw exception;
         }
         throw new SerializationException(exception.Message, exception);
     }
     catch
     {
         throw new SerializationException();
     }
     return delegate2;
 }
        [System.Security.SecurityCritical]  // auto-generated
        internal static DelegateEntry GetDelegateSerializationInfo(
            SerializationInfo info, Type delegateType, Object target, MethodInfo method, int targetIndex)
        {
            // Used for MulticastDelegate

            if (method == null) 
                throw new ArgumentNullException("method");
            Contract.EndContractBlock();
    
            if (!method.IsPublic || (method.DeclaringType != null && !method.DeclaringType.IsVisible))
                new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
    
            Type c = delegateType.BaseType;

            if (c == null || (c != typeof(Delegate) && c != typeof(MulticastDelegate)))
                throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"),"type");

            if (method.DeclaringType == null)
                throw new NotSupportedException(Environment.GetResourceString("NotSupported_GlobalMethodSerialization"));

            DelegateEntry de = new DelegateEntry(delegateType.FullName, delegateType.Module.Assembly.FullName, target,
                method.ReflectedType.Module.Assembly.FullName, method.ReflectedType.FullName, method.Name);

            if (info.MemberCount == 0)
            {
                info.SetType(typeof(DelegateSerializationHolder));
                info.AddValue("Delegate",de,typeof(DelegateEntry));
            }

            // target can be an object so it needs to be added to the info, or else a fixup is needed
            // when deserializing, and the fixup will occur too late. If it is added directly to the
            // info then the rules of deserialization will guarantee that it will be available when
            // needed

            if (target != null)
            {
                String targetName = "target" + targetIndex;
                info.AddValue(targetName, de.target);
                de.target = targetName;
            }

            // Due to a number of additions (delegate signature binding relaxation, delegates with open this or closed over the
            // first parameter and delegates over generic methods) we need to send a deal more information than previously. We can
            // get this by serializing the target MethodInfo. We still need to send the same information as before though (the
            // DelegateEntry above) for backwards compatibility. And we want to send the MethodInfo (which is serialized via an
            // ISerializable holder) as a top-level child of the info for the same reason as the target above -- we wouldn't have an
            // order of deserialization guarantee otherwise.
            String methodInfoName = "method" + targetIndex;
            info.AddValue(methodInfoName, method);

            return de;
        }
 private DelegateSerializationHolder(SerializationInfo info, StreamingContext context)
 {
     if (info == null)
     {
         throw new ArgumentNullException("info");
     }
     bool flag = true;
     try
     {
         this.m_delegateEntry = (DelegateEntry) info.GetValue("Delegate", typeof(DelegateEntry));
     }
     catch
     {
         this.m_delegateEntry = this.OldDelegateWireFormat(info, context);
         flag = false;
     }
     if (flag)
     {
         DelegateEntry delegateEntry = this.m_delegateEntry;
         int num = 0;
         while (delegateEntry != null)
         {
             if (delegateEntry.target != null)
             {
                 string target = delegateEntry.target as string;
                 if (target != null)
                 {
                     delegateEntry.target = info.GetValue(target, typeof(object));
                 }
             }
             num++;
             delegateEntry = delegateEntry.delegateEntry;
         }
         MethodInfo[] infoArray = new MethodInfo[num];
         int index = 0;
         while (index < num)
         {
             string name = "method" + index;
             infoArray[index] = (MethodInfo) info.GetValueNoThrow(name, typeof(MethodInfo));
             if (infoArray[index] == null)
             {
                 break;
             }
             index++;
         }
         if (index == num)
         {
             this.m_methods = infoArray;
         }
     }
 }
Exemplo n.º 4
0
        // Used for MulticastDelegate
        internal static DelegateEntry GetDelegateSerializationInfo(SerializationInfo info, Type delegateType, Object target, MethodInfo method, int targetIndex)        
        {
            Message.DebugOut("Inside GetDelegateSerializationInfo \n");
            if (method==null) {
                throw new ArgumentNullException("method");
            }
    
            BCLDebug.Assert(!(target is Delegate),"!(target is Delegate)");
            BCLDebug.Assert(info!=null, "[DelegateSerializationHolder.GetDelegateSerializationInfo]info!=null");
    
            Type c = delegateType.BaseType;
            if (c == null || (c != typeof(Delegate) && c != typeof(MulticastDelegate))) {
                throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"),"type");
            }
    

             DelegateEntry de = new DelegateEntry(
                                                  delegateType.FullName,
                                                  delegateType.Module.Assembly.FullName,
                                                  target,
                                                  method.ReflectedType.Module.Assembly.FullName,
                                                  method.ReflectedType.FullName,
                                                  method.Name
                                                  );

            if (info.MemberCount == 0)
            {
                info.SetType(typeof(DelegateSerializationHolder));
                info.AddValue("Delegate",de,typeof(DelegateEntry));
            }

            // target can be an object so it needs to be added to the info, or else a fixup is needed
            // when deserializing, and the fixup will occur too late. If it is added directly to the
            // info then the rules of deserialization will guarantee that it will be available when
            // needed

            if (target != null)
            {
                String targetName = "target"+targetIndex;
                info.AddValue(targetName, de.target);
                de.target = targetName;
            }

            return de;
        }
	// Serialize a multicast delegate object.
	internal static void SerializeMulticast
				(SerializationInfo info, MulticastDelegate del)
			{
				DelegateEntry entry, next;
				int index = 0;

				// Serialize the first entry on the multicast list.
				entry = Serialize(info, index++, del.GetType(), del.target,
								  MethodBase.GetMethodFromHandle(del.method));

				// Serialize the rest of the multicast chain.
				del = del.prev;
				while(del != null)
				{
					next = Serialize
						(info, index++, del.GetType(), del.target,
						 MethodBase.GetMethodFromHandle(del.method));
					entry.delegateEntry = next;
					entry = next;
					del = del.prev;
				}
			}
	// Serialize a delegate object.
	internal static DelegateEntry Serialize
				(SerializationInfo info, int listPosition,
				 Type delegateType, Object target, MethodBase method)
			{
				// Create the new delegate entry block.
				DelegateEntry entry = new DelegateEntry();
				entry.type = delegateType.FullName;
				entry.assembly = delegateType.Assembly.FullName;
				entry.target = target;
				entry.targetTypeAssembly =
						method.ReflectedType.Assembly.FullName;
				entry.targetTypeName = method.ReflectedType.FullName;
				entry.methodName = method.Name;

				// Add the block if this is the first in the list.
				if(info.MemberCount == 0)
				{
					info.SetType(typeof(DelegateSerializationHolder));
					info.AddValue("Delegate", entry, typeof(DelegateEntry));
				}

				// Add the target object to the top level of the info block.
				// Needed to get around order of fixup problems in some
				// third party serialization implementations.
				if(target != null)
				{
					String name = "target" + listPosition.ToString();
					info.AddValue(name, target, typeof(Object));
					entry.target = name;
				}

				// Return the entry to the caller so that we can chain
				// multiple entries together for multicast delegates.
				return entry;
			}
	// Constructor.
	public DelegateSerializationHolder(SerializationInfo info,
									   StreamingContext context)
			{
				if(info == null)
				{
					throw new ArgumentNullException("info");
				}
				bool needsResolve = false;
				try
				{
					// Try the new serialization format first.
					entry = (DelegateEntry)(info.GetValue
						("Delegate", typeof(DelegateEntry)));
					needsResolve = true;
				}
				catch(Exception)
				{
					// Try the old-style serialization format (deprecated).
					entry = new DelegateEntry();
					entry.type = info.GetString("DelegateType");
					entry.assembly = info.GetString("DelegateAssembly");
					entry.target = info.GetValue("Target", typeof(Object));
					entry.targetTypeAssembly =
						info.GetString("TargetTypeAssembly");
					entry.targetTypeName = info.GetString("TargetTypeName");
					entry.methodName = info.GetString("MethodName");
				}

				// Resolve targets specified as field names.
				if(needsResolve)
				{
					DelegateEntry e = entry;
					while(e != null)
					{
						if(e.target is String)
						{
							e.target = info.GetValue
								((String)(e.target), typeof(Object));
						}
						e = e.delegateEntry;
					}
				}
			}
        private Delegate GetDelegate(DelegateEntry de, int index)
        {
            Delegate d;

            try
            {
                if (de.methodName == null || de.methodName.Length == 0)
                    ThrowInsufficientState("MethodName");

                if (de.assembly == null || de.assembly.Length == 0)
                    ThrowInsufficientState("DelegateAssembly");

                if (de.targetTypeName == null || de.targetTypeName.Length == 0)
                    ThrowInsufficientState("TargetTypeName");

                // We cannot use Type.GetType directly, because of AppCompat - assembly names starting with '[' would fail to load.
                RuntimeType type = (RuntimeType)Assembly.GetType_Compat(de.assembly, de.type);
                RuntimeType targetType = (RuntimeType)Assembly.GetType_Compat(de.targetTypeAssembly, de.targetTypeName);

                // If we received the new style delegate encoding we already have the target MethodInfo in hand.
                if (m_methods != null)
                {
#if FEATURE_REMOTING                
                    Object target = de.target != null ? RemotingServices.CheckCast(de.target, targetType) : null;
#else
                    if(!targetType.IsInstanceOfType(de.target))
                        throw new InvalidCastException();
                    Object target=de.target;
#endif
                    d = Delegate.CreateDelegateNoSecurityCheck(type, target, m_methods[index]);
                }
                else
                {
                    if (de.target != null)
#if FEATURE_REMOTING                
                        d = Delegate.CreateDelegate(type, RemotingServices.CheckCast(de.target, targetType), de.methodName);
#else
                {
                    if(!targetType.IsInstanceOfType(de.target))
                        throw new InvalidCastException();
                     d = Delegate.CreateDelegate(type, de.target, de.methodName);
                }
#endif
                    else
                        d = Delegate.CreateDelegate(type, targetType, de.methodName);
                }

                if ((d.Method != null && !d.Method.IsPublic) || (d.Method.DeclaringType != null && !d.Method.DeclaringType.IsVisible))
                    new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
            }
            catch (Exception e)
            {
                if (e is SerializationException)
                    throw e;

                throw new SerializationException(e.Message, e);
            }

            return d;
        }
        [System.Security.SecurityCritical]  // auto-generated
        private DelegateSerializationHolder(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
                throw new ArgumentNullException("info");
            Contract.EndContractBlock();
    
            bool bNewWire = true;

            try
            {
                m_delegateEntry = (DelegateEntry)info.GetValue("Delegate", typeof(DelegateEntry));
            }
            catch
            {
                // Old wire format
                m_delegateEntry = OldDelegateWireFormat(info, context);
                bNewWire = false;
            }

            if (bNewWire)
            {
                // retrieve the targets
                DelegateEntry deiter = m_delegateEntry;
                int count = 0;
                while (deiter != null)
                {
                    if (deiter.target != null)
                    {
                        string stringTarget = deiter.target as string; //need test to pass older wire format
                        if (stringTarget != null)
                            deiter.target = info.GetValue(stringTarget, typeof(Object));
                    }
                    count++;
                    deiter = deiter.delegateEntry;
                }

                // If the sender is as recent as us they'll have provided MethodInfos for each delegate. Look for these and pack
                // them into an ordered array if present.
                MethodInfo[] methods = new MethodInfo[count];
                int i;
                for (i = 0; i < count; i++)
                {
                    String methodInfoName = "method" + i;
                    methods[i] = (MethodInfo)info.GetValueNoThrow(methodInfoName, typeof(MethodInfo));
                    if (methods[i] == null)
                        break;
                }

                // If we got the info then make the array available for deserialization.
                if (i == count)
                    m_methods = methods;
            }
        }
        private Delegate GetDelegate(DelegateEntry de, int index)
        {
            Delegate d;

            try
            {
                if (de.methodName == null || de.methodName.Length == 0)
                    ThrowInsufficientState("MethodName");

                if (de.assembly == null || de.assembly.Length == 0)
                    ThrowInsufficientState("DelegateAssembly");

                if (de.targetTypeName == null || de.targetTypeName.Length == 0)
                    ThrowInsufficientState("TargetTypeName");

                Type type = Assembly.Load(de.assembly).GetType(de.type, true, false);
                Type targetType = Assembly.Load(de.targetTypeAssembly).GetType(de.targetTypeName, true, false);

                // If we received the new style delegate encoding we already have the target MethodInfo in hand.
                if (m_methods != null)
                {
                    Object target = de.target != null ? RemotingServices.CheckCast(de.target, targetType) : null;
                    d = Delegate.InternalCreateDelegate(type, target, m_methods[index]);
                }
                else
                {
                    if (de.target != null)
                        d = Delegate.CreateDelegate(type, RemotingServices.CheckCast(de.target, targetType), de.methodName);
                    else
                        d = Delegate.CreateDelegate(type, targetType, de.methodName);
                }

                if ((d.Method != null && !d.Method.IsPublic) || (d.Method.DeclaringType != null && !d.Method.DeclaringType.IsVisible))
                    new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
            }
            catch (Exception e)
            {
                if (e is SerializationException)
                    throw e;

                throw new SerializationException(e.Message, e);
            }
            catch
            {
                throw new SerializationException();
            }

            return d;
        }
Exemplo n.º 11
0
		public static void GetDelegateData (Delegate instance, SerializationInfo info, StreamingContext ctx)
		{
			// Fills a SerializationInfo object with the information of the delegate.

			Delegate[] delegates = instance.GetInvocationList ();
			DelegateEntry lastEntry = null;
			for (int n=0; n<delegates.Length; n++) {
				Delegate del = delegates[n];
				string targetLabel = (del.Target != null) ? ("target" + n) : null;
				DelegateEntry entry = new DelegateEntry (del, targetLabel);

				if (lastEntry == null)
					info.AddValue ("Delegate", entry);
				else
					lastEntry.delegateEntry = entry;

				lastEntry = entry;
				if (del.Target != null)
					info.AddValue (targetLabel, del.Target);
			}
			info.SetType (typeof (DelegateSerializationHolder));
		}
 internal static DelegateEntry GetDelegateSerializationInfo(SerializationInfo info, Type delegateType, object target, MethodInfo method, int targetIndex)
 {
     if (method == null)
     {
         throw new ArgumentNullException("method");
     }
     if (!method.IsPublic || ((method.DeclaringType != null) && !method.DeclaringType.IsVisible))
     {
         new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Demand();
     }
     Type baseType = delegateType.BaseType;
     if ((baseType == null) || ((baseType != typeof(Delegate)) && (baseType != typeof(MulticastDelegate))))
     {
         throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
     }
     if (method.DeclaringType == null)
     {
         throw new NotSupportedException(Environment.GetResourceString("NotSupported_GlobalMethodSerialization"));
     }
     DelegateEntry entry = new DelegateEntry(delegateType.FullName, delegateType.Module.Assembly.FullName, target, method.ReflectedType.Module.Assembly.FullName, method.ReflectedType.FullName, method.Name);
     if (info.MemberCount == 0)
     {
         info.SetType(typeof(DelegateSerializationHolder));
         info.AddValue("Delegate", entry, typeof(DelegateEntry));
     }
     if (target != null)
     {
         string str = "target" + targetIndex;
         info.AddValue(str, entry.target);
         entry.target = str;
     }
     string name = "method" + targetIndex;
     info.AddValue(name, method);
     return entry;
 }
Exemplo n.º 13
0
        internal DelegateSerializationHolder(SerializationInfo info, StreamingContext context) {
            if (info==null) {
                throw new ArgumentNullException("info");
            }
    
            bool bNewWire = true;
            try
            {
                m_delegateEntry = (DelegateEntry)info.GetValue("Delegate", typeof(DelegateEntry));
            }
            catch(Exception)
            {
                // Old wire format
                m_delegateEntry = OldDelegateWireFormat(info, context);
                bNewWire = false;
            }

            if (bNewWire)
            {
                // retrieve the targets
                DelegateEntry deiter = m_delegateEntry;
                while (deiter != null)
                {
                    if (deiter.target != null)
                    {
                        string stringTarget = deiter.target as string; //need test to pass older wire format
                        if (stringTarget != null)
                            deiter.target = info.GetValue(stringTarget, typeof(Object));
                    }
                    deiter= deiter.delegateEntry;
                }
            }

        }
Exemplo n.º 14
0
        private Delegate GetDelegate(DelegateEntry de)
        {
            Delegate d;
    
            if (de.methodName==null || de.methodName.Length==0) {
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
            }
    
            Assembly assem = FormatterServices.LoadAssemblyFromString(de.assembly);

            if (assem==null) {
                BCLDebug.Trace("SER", "[DelegateSerializationHolder.ctor]: Unable to find assembly for TargetType: ", de.assembly);
                throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_AssemblyNotFound"), de.assembly));
            }

            Type type = assem.GetTypeInternal(de.type, false, false, false);

            assem = FormatterServices.LoadAssemblyFromString(de.targetTypeAssembly);
            if (assem==null) {
                BCLDebug.Trace("SER", "[DelegateSerializationHolder.ctor]: Unable to find assembly for TargetType: ", de.targetTypeAssembly);
                throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_AssemblyNotFound"), de.targetTypeAssembly));
        }
    
            Type targetType = assem.GetTypeInternal(de.targetTypeName, false, false, false);

            if (de.target==null && targetType==null) {
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
            }
    
            if (type==null) {
                BCLDebug.Trace("SER","[DelegateSerializationHolder.GetRealObject]Missing Type");
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
            }
    
            if (targetType==null) {
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
            }

            Object target = null;

            if (de.target!=null) { //We have a delegate to a non-static object
                target = RemotingServices.CheckCast(de.target, targetType);
                d=Delegate.CreateDelegate(type, target, de.methodName);
            } else {
                //For a static delegate
                d=Delegate.CreateDelegate(type, targetType, de.methodName);
            }
    
            // We will refuse to create delegates to methods that are non-public.
            MethodInfo mi = d.Method;
            if (mi != null)
            {
                if (!mi.IsPublic)
                {
                    throw new SerializationException(
                        Environment.GetResourceString("Serialization_RefuseNonPublicDelegateCreation"));
                }
            }
    
            return d;
        }