public MyProxy(MarshalByRefObject
target)
        : base(target.GetType())
    {
        this.target
        =
        target;
    }

	// Get a lifetime service object.
	public static Object GetLifetimeService(MarshalByRefObject obj)
			{
				if(obj == null)
				{
					return null;
				}
				return obj.GetLifetimeService();
			}

	// Get the envoy chain for a specific proxy object.
	public static IMessageSink GetEnvoyChainForProxy
				(MarshalByRefObject obj)
			{
				if(IsObjectOutOfContext(obj))
				{
					RealProxy proxy = GetRealProxy(obj);
					Identity id = proxy.Identity;
					if(id != null)
					{
						return id.envoyChain;
					}
				}
				return null;
			}

	// Register an object for sponsorship.
	public bool Register(MarshalByRefObject obj)
			{
				// If there is no lease on the object, then bail out.
				ILease lease = (ILease)(obj.GetLifetimeService());
				if(lease == null)
				{
					return false;
				}

				// Inform the lease about the registered sponsor.
				lease.Register(this);
				
				// Add the lease to the sponsor table.
				lock(this)
				{
					sponsoredObjects[obj] = lease;
				}
				return true;
			}

		public static ObjRef Marshal (MarshalByRefObject Obj, string ObjURI, Type RequestedType)
		{
			if (IsTransparentProxy (Obj))
			{
				RealProxy proxy = RemotingServices.GetRealProxy (Obj);
				Identity identity = proxy.ObjectIdentity;

				if (identity != null)
				{
					if (proxy.GetProxiedType().IsContextful && !identity.IsConnected)
					{
						// Unregistered local contextbound object. Register now.
						ClientActivatedIdentity cboundIdentity = (ClientActivatedIdentity)identity;
						if (ObjURI == null) ObjURI = NewUri();
						cboundIdentity.ObjectUri = ObjURI;
						RegisterServerIdentity (cboundIdentity);
						cboundIdentity.StartTrackingLifetime ((ILease)Obj.InitializeLifetimeService());
						return cboundIdentity.CreateObjRef (RequestedType);
					}
					else if (ObjURI != null)
						throw new RemotingException ("It is not possible marshal a proxy of a remote object.");

					ObjRef or = proxy.ObjectIdentity.CreateObjRef (RequestedType);
					TrackingServices.NotifyMarshaledObject (Obj, or);
					return or;
				}
			}

			if (RequestedType == null) RequestedType = Obj.GetType ();

			if (ObjURI == null) 
			{
				if (Obj.ObjectIdentity == null)
				{
					ObjURI = NewUri();
					CreateClientActivatedServerIdentity (Obj, RequestedType, ObjURI);
				}
			}
			else
			{
				ClientActivatedIdentity identity = GetIdentityForUri ("/" + ObjURI) as ClientActivatedIdentity;
				if (identity == null || Obj != identity.GetServerObject()) 
					CreateClientActivatedServerIdentity (Obj, RequestedType, ObjURI);
			}

			ObjRef oref;
			
			if (IsTransparentProxy (Obj))
				oref = RemotingServices.GetRealProxy (Obj).ObjectIdentity.CreateObjRef (RequestedType);
			else
				oref = Obj.CreateObjRef (RequestedType);
			
			TrackingServices.NotifyMarshaledObject (Obj, oref);
			return oref;
		}

		public static ObjRef GetObjRefForProxy(MarshalByRefObject obj)
		{
			Identity ident = GetObjectIdentity(obj);
			if (ident == null) return null;
			else return ident.CreateObjRef(null);
		}

		// Get an active lease for an object.
		public ILease GetLeaseForObject(MarshalByRefObject obj)
				{
					// TODO
					return null;
				}

		public static IConstructionReturnMessage CreateConstructionReturnMessage (IConstructionCallMessage ctorMsg, MarshalByRefObject retObj)
		{
			return new ConstructionResponse (retObj, null, ctorMsg);
		}

	// Unregister an object from the sponsorship list.
	public void Unregister(MarshalByRefObject obj)
			{
				ILease lease;
				lock(this)
				{
					lease = (ILease)(sponsoredObjects[obj]);
					if(lease == null)
					{
						return;
					}
					sponsoredObjects.Remove(obj);
				}
				lease.Unregister(this);
			}

		internal static IMethodReturnMessage InternalExecuteMessage (
		        MarshalByRefObject target, IMethodCallMessage reqMsg)
		{
			ReturnMessage result;
			
			Type tt = target.GetType ();
			MethodBase method;
			if (reqMsg.MethodBase.DeclaringType == tt ||
			    reqMsg.MethodBase == FieldSetterMethod || 
			    reqMsg.MethodBase == FieldGetterMethod) {
				method = reqMsg.MethodBase;
			} else {
				method = GetVirtualMethod (tt, reqMsg.MethodBase);

				if (method == null)
					throw new RemotingException (
						String.Format ("Cannot resolve method {0}:{1}", tt, reqMsg.MethodName));
			}

			if (reqMsg.MethodBase.IsGenericMethod) {
				Type[] genericArguments = reqMsg.MethodBase.GetGenericArguments ();
				MethodInfo gmd = ((MethodInfo)method).GetGenericMethodDefinition ();
				method = gmd.MakeGenericMethod (genericArguments);
			}

			object oldContext = CallContext.SetCurrentCallContext (reqMsg.LogicalCallContext);
			
			try 
			{
				object [] out_args;
				object rval = InternalExecute (method, target, reqMsg.Args, out out_args);
			
				// Collect parameters with Out flag from the request message
				// FIXME: This can be done in the unmanaged side and will be
				// more efficient
				
				ParameterInfo[] parameters = method.GetParameters();
				object[] returnArgs = new object [parameters.Length];
				
				int n = 0;
				int noa = 0;
				foreach (ParameterInfo par in parameters)
				{
					if (par.IsOut && !par.ParameterType.IsByRef) 
						returnArgs [n++] = reqMsg.GetArg (par.Position);
					else if (par.ParameterType.IsByRef)
						returnArgs [n++] = out_args [noa++]; 
					else
						returnArgs [n++] = null; 
				}
				
				result = new ReturnMessage (rval, returnArgs, n, CallContext.CreateLogicalCallContext (true), reqMsg);
			} 
			catch (Exception e) 
			{
				result = new ReturnMessage (e, reqMsg);
			}
			
			CallContext.RestoreCallContext (oldContext);
			return result;
		}

		internal static Identity GetObjectIdentity (MarshalByRefObject obj)
		{
			if (IsTransparentProxy(obj))
				return GetRealProxy (obj).ObjectIdentity;
			else
				return obj.ObjectIdentity;
		}

	// Detach this proxy from a remote server.
	protected MarshalByRefObject DetachServer()
			{
				MarshalByRefObject saved = serverObject;
				serverObject = null;
				return saved;
			}

	// Initialize a lifetime service object for a marshal-by-ref object.
	internal static Object InitializeLifetimeService(MarshalByRefObject obj)
			{
				Manager manager = GetLifetimeManager();
				ILease lease = manager.GetLeaseForObject(obj);
				if(lease != null)
				{
					return lease;
				}
				return new Lease(obj, LeaseTime, RenewOnCallTime,
								 SponsorshipTimeout);
			}

	// Attach this proxy to a remote server.
	protected void AttachServer(MarshalByRefObject s)
			{
				serverObject = s;
			}

	public IConstructionReturnMessage InitializeServerObject
				(IConstructionCallMessage ctorMsg)
			{
				// Nothing to do if we already have a server object.
				if(serverObject != null)
				{
					return null;
				}

				// Create the server object.
				Type serverType = GetProxiedType();
				if(ctorMsg != null && ctorMsg.ActivationType != serverType)
				{
					throw new RemotingException(_("Remoting_CtorMsg"));
				}
				serverObject = (MarshalByRefObject)
					FormatterServices.GetUninitializedObject(serverType);
				if(stubData == defaultStub)
				{
					stubData = Thread.CurrentContext.ContextID;
				}
				Object proxy = GetTransparentProxy();
				if(ctorMsg == null)
				{
					// TODO: create a default constructor call message.
				}
				IMethodReturnMessage returnMessage;
				returnMessage = RemotingServices.ExecuteMessage
					((MarshalByRefObject)proxy, ctorMsg);
				return new ConstructionResponse(returnMessage);
			}

	public static String[] GetUrlsForObject(MarshalByRefObject obj)
			{
				// TODO
				return null;
			}

		public static IMessageSink GetEnvoyChainForProxy (MarshalByRefObject obj)
		{
			if (IsTransparentProxy(obj))
				return ((ClientIdentity)GetRealProxy (obj).ObjectIdentity).EnvoySink;
			else
				throw new ArgumentException ("obj must be a proxy.","obj");			
		}

		public static IMethodReturnMessage ExecuteMessage (
			MarshalByRefObject target, IMethodCallMessage reqMsg)
		{
			if (IsTransparentProxy(target))
			{
				// Message must go through all chain of sinks
				RealProxy rp = GetRealProxy (target);
				return (IMethodReturnMessage) rp.Invoke (reqMsg);
			}
			else	// Direct call
				return InternalExecuteMessage (target, reqMsg);
		}

		public static void SetObjectUriForMarshal(MarshalByRefObject obj, string uri)
		{
			if (IsTransparentProxy (obj)) {
				RealProxy proxy = RemotingServices.GetRealProxy(obj);
				Identity identity = proxy.ObjectIdentity;

				if (identity != null && !(identity is ServerIdentity) && !proxy.GetProxiedType().IsContextful)
					throw new RemotingException ("SetObjectUriForMarshal method should only be called for MarshalByRefObjects that exist in the current AppDomain.");
			}
			
			Marshal (obj, uri);
		}

		internal IMessageSink CreateServerObjectSinkChain (MarshalByRefObject obj, bool forceInternalExecute)
		{
			IMessageSink objectSink = new StackBuilderSink (obj, forceInternalExecute);
			objectSink = new ServerObjectTerminatorSink (objectSink);
			objectSink = new Lifetime.LeaseSink (objectSink);

			if (context_properties != null)
			{
				// Contribute object sinks in reverse order
				for (int n = context_properties.Count-1; n >= 0; n--)
				{
					IContextProperty prop = (IContextProperty) context_properties[n];
					IContributeObjectSink contributor = prop as IContributeObjectSink;
					if (contributor != null)
						objectSink = contributor.GetObjectSink (obj, objectSink);
				}
			}
			return objectSink;
		}