using System.Runtime.Remoting.Contexts;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
-
+using System.Runtime.InteropServices;
+using System.Threading;
namespace System.Runtime.Remoting.Proxies
{
+#pragma warning disable 169, 649
+ [StructLayout (LayoutKind.Sequential)]
internal class TransparentProxy {
public RealProxy _rp;
- IntPtr _class;
+ Mono.RuntimeRemoteClassHandle _class;
bool _custom_type_info;
+
+ unsafe internal RuntimeType GetProxyType () {
+ RuntimeTypeHandle h = _class.ProxyClass.GetTypeHandle ();
+ return (RuntimeType)Type.GetTypeFromHandle (h);
+ }
+
+ bool IsContextBoundObject {
+ get { return GetProxyType ().IsContextful; }
+ }
+
+ Context TargetContext {
+ get { return _rp._targetContext; }
+ }
+
+ bool InCurrentContext () {
+ return IsContextBoundObject && Object.ReferenceEquals (TargetContext, Thread.CurrentContext);
+ }
+
+ internal object LoadRemoteFieldNew (IntPtr classPtr, IntPtr fieldPtr) {
+ Mono.RuntimeClassHandle classHandle = new Mono.RuntimeClassHandle (classPtr);
+ RuntimeFieldHandle fieldHandle = new RuntimeFieldHandle (fieldPtr);
+ RuntimeTypeHandle typeHandle = classHandle.GetTypeHandle ();
+
+ FieldInfo field = FieldInfo.GetFieldFromHandle (fieldHandle);
+
+ if (InCurrentContext ()) {
+ object o = _rp._server;
+ return field.GetValue(o);
+ }
+
+ object[] inArgs = new object[] { Type.GetTypeFromHandle(typeHandle).FullName,
+ field.Name };
+ object[] outArgsMsg = new object[1];
+ MethodInfo minfo = typeof(object).GetMethod("FieldGetter", BindingFlags.NonPublic | BindingFlags.Instance);
+ if (minfo == null)
+ throw new MissingMethodException ("System.Object", "FieldGetter");
+ MonoMethodMessage msg = new MonoMethodMessage (minfo, inArgs, outArgsMsg);
+ object[] outArgs;
+ Exception exc;
+ RealProxy.PrivateInvoke (_rp, msg, out exc, out outArgs);
+ if (exc != null)
+ throw exc;
+ return outArgs[0];
+ }
}
+#pragma warning restore 169, 649
+ [ComVisible (true)]
+ [StructLayout (LayoutKind.Sequential)]
public abstract class RealProxy {
// other classes visible to the runtime
// derive from this class so keep these locals
// in sync with the definition RealProxy
// in object-internals.h
+
+#pragma warning disable 169, 414
#region Sync with object-internals.h
Type class_to_proxy;
internal Context _targetContext;
- MarshalByRefObject _server;
+ internal MarshalByRefObject _server;
int _targetDomainId = -1;
internal string _targetUri;
internal Identity _objectIdentity;
- Object _objTP;\r
- object _stubData;\r
+ Object _objTP;
+ object _stubData;
#endregion
+#pragma warning restore 169, 414
protected RealProxy ()
{
public virtual void GetObjectData (SerializationInfo info, StreamingContext context)
{
- Object obj = GetTransparentProxy();\r
- RemotingServices.GetObjectData (obj, info, context); \r
+ Object obj = GetTransparentProxy();
+ RemotingServices.GetObjectData (obj, info, context);
}
internal Identity ObjectIdentity
out object [] out_args)
{
MonoMethodMessage mMsg = (MonoMethodMessage) msg;
- mMsg.LogicalCallContext = CallContext.CreateLogicalCallContext (true);
+ mMsg.LogicalCallContext = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
CallType call_type = mMsg.CallType;
- bool is_remproxy = (rp as RemotingProxy) != null;
+ bool is_remproxy = (rp is RemotingProxy);
+ out_args = null;
IMethodReturnMessage res_msg = null;
- if (call_type == CallType.BeginInvoke) \r
+ if (call_type == CallType.BeginInvoke)
// todo: set CallMessage in runtime instead
mMsg.AsyncResult.CallMessage = mMsg;
res_msg = (IMethodReturnMessage)mMsg.AsyncResult.EndInvoke ();
// Check for constructor msg
- if (mMsg.MethodBase.IsConstructor) \r
+ if (mMsg.MethodBase.IsConstructor)
{
- if (is_remproxy) \r
+ if (is_remproxy)
res_msg = (IMethodReturnMessage) (rp as RemotingProxy).ActivateRemoteObject ((IMethodMessage) msg);
- else \r
+ else
msg = new ConstructionCall (rp.GetProxiedType ());
}
if (null == res_msg)
{
- res_msg = (IMethodReturnMessage)rp.Invoke (msg);
-\r
- // Note, from begining this code used AsyncResult.IsCompleted for\r
- // checking if it was a remoting or custom proxy, but in some\r
- // cases the remoting proxy finish before the call returns\r
- // causing this method to be called, therefore causing all kind of bugs.\r
- if ((!is_remproxy) && call_type == CallType.BeginInvoke)\r
- {\r
+ bool failed = false;
+
+ try {
+ res_msg = (IMethodReturnMessage)rp.Invoke (msg);
+ } catch (Exception ex) {
+ failed = true;
+ if (call_type == CallType.BeginInvoke) {
+ // If async dispatch crashes, don't propagate the exception.
+ // The exception will be raised when calling EndInvoke.
+ mMsg.AsyncResult.SyncProcessMessage (new ReturnMessage (ex, msg as IMethodCallMessage));
+ res_msg = new ReturnMessage (null, null, 0, null, msg as IMethodCallMessage);
+ } else
+ throw;
+ }
+
+ // Note, from begining this code used AsyncResult.IsCompleted for
+ // checking if it was a remoting or custom proxy, but in some
+ // cases the remoting proxy finish before the call returns
+ // causing this method to be called, therefore causing all kind of bugs.
+ if ((!is_remproxy) && call_type == CallType.BeginInvoke && !failed)
+ {
IMessage asyncMsg = null;
// allow calltype EndInvoke to finish
asyncMsg = mMsg.AsyncResult.SyncProcessMessage (res_msg as IMessage);
+ out_args = res_msg.OutArgs;
res_msg = new ReturnMessage (asyncMsg, null, 0, null, res_msg as IMethodCallMessage);
- }\r
+ }
}
- if (res_msg.LogicalCallContext != null && res_msg.LogicalCallContext.HasInfo)
- CallContext.UpdateCurrentCallContext (res_msg.LogicalCallContext);
+ if (res_msg.LogicalCallContext != null && res_msg.LogicalCallContext.HasInfo) {
+ Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext.Merge (res_msg.LogicalCallContext);
+ }
exc = res_msg.Exception;
out_args = null;
throw exc.FixRemotingException();
}
- else if (res_msg is IConstructionReturnMessage || mMsg.CallType == CallType.BeginInvoke) {
- out_args = res_msg.OutArgs;
+ else if (res_msg is IConstructionReturnMessage) {
+ if (out_args == null)
+ out_args = res_msg.OutArgs;
+ }
+ else if (mMsg.CallType == CallType.BeginInvoke) {
+ // We don't have OutArgs in this case.
}
else if (mMsg.CallType == CallType.Sync) {
out_args = ProcessResponse (res_msg, mMsg);
out_args = ProcessResponse (res_msg, mMsg.AsyncResult.CallMessage);
}
else {
- out_args = res_msg.OutArgs;
+ if (out_args == null)
+ out_args = res_msg.OutArgs;
}
return res_msg.ReturnValue;
}
[MonoTODO]
+ [ComVisible (true)]
public IConstructionReturnMessage InitializeServerObject(IConstructionCallMessage ctorMsg)
{
throw new NotImplementedException();
projects / mono.git / blobdiff