* CADMessages.cs: improved argument smuggeling. Now it supports strings,

	  datetime and arrays of primitive types. This makes CAD much faster.
	* AsyncResult.cs: Added property to store the call message.

svn path=/trunk/mcs/; revision=18706

diff --git a/mcs/class/corlib/System.Runtime.Remoting.Messaging/AsyncResult.cs b/mcs/class/corlib/System.Runtime.Remoting.Messaging/AsyncResult.cs
index d403f72b6d42b82eed76f3888b85b14cd7bf520d..581c7d52394bace10f5e8363dfea8285272c268b 100644 (file)
--- a/mcs/class/corlib/System.Runtime.Remoting.Messaging/AsyncResult.cs
+++ b/mcs/class/corlib/System.Runtime.Remoting.Messaging/AsyncResult.cs
@@ -25,12 +25,10 @@ public class AsyncResult : IAsyncResult, IMessageSink {
        bool sync_completed;
        bool completed;
        bool endinvoke_called;
-       object[] out_args;
-       object ret_val;
-       Exception exception;
+       MonoMethodMessage call_message;
        IMessageCtrl message_ctrl;
        IMessage reply_message;
-               
+       
        public virtual object AsyncState
        {
                get {
@@ -119,5 +117,11 @@ public class AsyncResult : IAsyncResult, IMessageSink {
 
                return null;
        }
+       
+       internal MonoMethodMessage CallMessage
+       {
+               get { return call_message; }
+               set { call_message = value; }
+       }
 }
 }

diff --git a/mcs/class/corlib/System.Runtime.Remoting.Messaging/CADMessages.cs b/mcs/class/corlib/System.Runtime.Remoting.Messaging/CADMessages.cs
index 88a2441d13f54828696f7af59fd804ef4da94912..7db087d90839225c1d8b8fecf936fcb4808eaba2 100755 (executable)
--- a/mcs/class/corlib/System.Runtime.Remoting.Messaging/CADMessages.cs
+++ b/mcs/class/corlib/System.Runtime.Remoting.Messaging/CADMessages.cs
@@ -82,6 +82,12 @@ namespace System.Runtime.Remoting.Messaging {
                        if (objType.IsPrimitive || objType == typeof(void))
                                return true;
                        
+                       if (objType.IsArray && objType.GetElementType().IsPrimitive && ((Array)obj).Rank == 1)
+                               return true;
+                               
+                       if (obj is string || obj is DateTime || obj is TimeSpan)
+                               return true;
+                               
                        return false;
                }
 
@@ -120,6 +126,8 @@ namespace System.Runtime.Remoting.Messaging {
                }
 
                protected static object UnmarshalArgument (object arg, ArrayList args) {
+                       if (arg == null) return null;
+                       
                        // Check if argument is an holder (then we know that it's a serialized argument)
                        CADArgHolder holder = arg as CADArgHolder;
                        if (null != holder) {
@@ -130,9 +138,60 @@ namespace System.Runtime.Remoting.Messaging {
                        if (null != objref) {
                                return objref.objref.GetRealObject (new StreamingContext (StreamingContextStates.Other));
                        }
+                       
+                       if (arg.GetType().IsArray)
+                       {
+                               Array argb = (Array)arg;
+                               Array argn;
+                               
+                               // We can't use Array.CreateInstance (arg.GetType().GetElementType()) because
+                               // GetElementType() returns a type from the source domain.
+                               
+                               switch (Type.GetTypeCode (arg.GetType().GetElementType()))
+                               {
+                                       case TypeCode.Boolean: argn = new bool [argb.Length]; break;
+                                       case TypeCode.Byte: argn = new Byte [argb.Length]; break;
+                                       case TypeCode.Char: argn = new Char [argb.Length]; break;
+                                       case TypeCode.Decimal: argn = new Decimal [argb.Length]; break;
+                                       case TypeCode.Double: argn = new Double [argb.Length]; break;
+                                       case TypeCode.Int16: argn = new Int16 [argb.Length]; break;
+                                       case TypeCode.Int32: argn = new Int32 [argb.Length]; break;
+                                       case TypeCode.Int64: argn = new Int64 [argb.Length]; break;
+                                       case TypeCode.SByte: argn = new SByte [argb.Length]; break;
+                                       case TypeCode.Single: argn = new Single [argb.Length]; break;
+                                       case TypeCode.UInt16: argn = new UInt16 [argb.Length]; break;
+                                       case TypeCode.UInt32: argn = new UInt32 [argb.Length]; break;
+                                       case TypeCode.UInt64: argn = new UInt64 [argb.Length]; break;
+                                       default: throw new NotSupportedException ();
+                               }
+                               
+                               argb.CopyTo (argn, 0);
+                               return argn;
+                       }
 
-                       // otherwise the argument is ok just to return
-                       return arg;
+                       switch (Type.GetTypeCode (arg.GetType()))
+                       {
+                               case TypeCode.Boolean: return (bool)arg;
+                               case TypeCode.Byte: return (byte)arg;
+                               case TypeCode.Char: return (char)arg;
+                               case TypeCode.Decimal: return (decimal)arg;
+                               case TypeCode.Double: return (double)arg;
+                               case TypeCode.Int16: return (Int16)arg;
+                               case TypeCode.Int32: return (Int32)arg;
+                               case TypeCode.Int64: return (Int64)arg;
+                               case TypeCode.SByte: return (SByte)arg;
+                               case TypeCode.Single: return (Single)arg;
+                               case TypeCode.UInt16: return (UInt16)arg;
+                               case TypeCode.UInt32: return (UInt32)arg;
+                               case TypeCode.UInt64: return (UInt64)arg;
+                               case TypeCode.String: return new String (((string)arg).ToCharArray());
+                               case TypeCode.DateTime: return new DateTime (((DateTime)arg).Ticks);
+                               default:
+                                       if (arg is TimeSpan) return new TimeSpan (((TimeSpan)arg).Ticks);
+                                       break;
+                       }       
+
+                       throw new NotSupportedException ("Parameter of type " + arg.GetType () + " cannot be unmarshalled");
                }
 
                internal static object [] MarshalArguments (object [] arguments, ref ArrayList args) {

diff --git a/mcs/class/corlib/System.Runtime.Remoting.Messaging/ChangeLog b/mcs/class/corlib/System.Runtime.Remoting.Messaging/ChangeLog
index 277daa54d8e382db358eda3a063f93ce4b3f59b8..703b4d826dbd3f949bc59c598a33dead97f480e5 100644 (file)
--- a/mcs/class/corlib/System.Runtime.Remoting.Messaging/ChangeLog
+++ b/mcs/class/corlib/System.Runtime.Remoting.Messaging/ChangeLog
@@ -1,3 +1,9 @@
+2003-10-07  Lluis Sanchez Gual  <lluis@ximian.com>
+
+       * CADMessages.cs: improved argument smuggeling. Now it supports strings,
+         datetime and arrays of primitive types. This makes CAD much faster.
+       * AsyncResult.cs: Added property to store the call message.
+
 2003-09-11  Lluis Sanchez Gual  <lluis@ximian.com>
 
        * ArgInfo.cs: Include parameters with the Out flag in the out parameters list.