2 // System.Runtime.Remoting.MessageFormatter.cs
4 // Author: Lluis Sanchez Gual (lluis@ideary.com)
6 // (C) 2003, Lluis Sanchez Gual
11 using System.Reflection;
\r
12 using System.Collections;
\r
13 using System.Runtime.Remoting;
\r
14 using System.Runtime.Serialization;
\r
15 using System.Runtime.Remoting.Messaging;
\r
17 namespace System.Runtime.Serialization.Formatters.Binary
\r
19 internal class MessageFormatter
\r
21 public static void WriteMethodCall (BinaryWriter writer, object obj, Header[] headers, ISurrogateSelector surrogateSelector, StreamingContext context)
\r
23 IMethodCallMessage call = (IMethodCallMessage)obj;
\r
24 writer.Write ((byte) BinaryElement.MethodCall);
\r
26 MethodFlags methodFlags;
\r
27 int infoArraySize = 0;
\r
29 object[] extraProperties = null;
\r
31 if (call.LogicalCallContext != null && call.LogicalCallContext.HasInfo)
\r
33 methodFlags = MethodFlags.IncludesLogicalCallContext;
\r
37 methodFlags = MethodFlags.ExcludeLogicalCallContext;
\r
39 if (RemotingServices.IsMethodOverloaded (call))
\r
42 methodFlags |= MethodFlags.IncludesSignature;
\r
45 if (call.Properties.Count > MethodCallDictionary.InternalKeys.Length)
\r
47 extraProperties = GetExtraProperties (call.Properties, MethodCallDictionary.InternalKeys);
\r
51 if (call.ArgCount == 0)
\r
52 methodFlags |= MethodFlags.NoArguments;
\r
54 if (AllTypesArePrimitive (call.Args))
\r
55 methodFlags |= MethodFlags.PrimitiveArguments;
\r
57 if (infoArraySize == 0)
\r
58 methodFlags |= MethodFlags.ArgumentsInSimpleArray;
\r
60 methodFlags |= MethodFlags.ArgumentsInMultiArray;
\r
66 writer.Write ((byte) (methodFlags));
\r
68 // FIXME: what are the following 3 bytes for?
\r
69 writer.Write ((byte) 0);
\r
70 writer.Write ((byte) 0);
\r
71 writer.Write ((byte) 0);
\r
74 writer.Write ((byte) BinaryTypeCode.String);
\r
75 writer.Write (call.MethodName);
\r
78 writer.Write ((byte) BinaryTypeCode.String);
\r
79 writer.Write (call.TypeName);
\r
83 if ((methodFlags & MethodFlags.PrimitiveArguments) > 0)
\r
85 writer.Write ((uint)call.Args.Length);
\r
86 for (int n=0; n<call.InArgCount; n++)
\r
88 object arg = call.GetArg(n);
\r
90 writer.Write (BinaryCommon.GetTypeCode (arg.GetType()));
\r
91 ObjectWriter.WritePrimitiveValue (writer, arg);
\r
94 writer.Write ((byte)BinaryTypeCode.Null);
\r
98 if ( infoArraySize > 0)
\r
100 object[] ainfo = new object[infoArraySize];
\r
102 if ((methodFlags & MethodFlags.ArgumentsInMultiArray) > 0) ainfo[n++] = call.Args;
\r
103 if ((methodFlags & MethodFlags.IncludesSignature) > 0) ainfo[n++] = call.MethodSignature;
\r
104 if ((methodFlags & MethodFlags.IncludesLogicalCallContext) > 0) ainfo[n++] = call.LogicalCallContext;
\r
105 if (extraProperties != null) ainfo[n++] = extraProperties;
\r
108 else if ((methodFlags & MethodFlags.ArgumentsInSimpleArray) > 0)
\r
113 ObjectWriter objectWriter = new ObjectWriter(surrogateSelector, context);
\r
114 objectWriter.WriteObjectGraph (writer, info, headers);
\r
117 writer.Write ((byte) BinaryElement.End);
\r
120 public static void WriteMethodResponse (BinaryWriter writer, object obj, Header[] headers, ISurrogateSelector surrogateSelector, StreamingContext context)
\r
122 IMethodReturnMessage resp = (IMethodReturnMessage)obj;
\r
123 writer.Write ((byte) BinaryElement.MethodResponse);
\r
125 string[] internalProperties = MethodReturnDictionary.InternalReturnKeys;
\r
127 int infoArrayLength = 0;
\r
128 object info = null;
\r
129 object[] extraProperties = null;
\r
131 // Type of return value
\r
133 ReturnTypeTag returnTypeTag;
\r
135 if (resp.Exception != null) {
\r
136 returnTypeTag = ReturnTypeTag.Exception | ReturnTypeTag.Null;
\r
137 info = new object[] {resp.Exception};
\r
138 internalProperties = MethodReturnDictionary.InternalExceptionKeys;
\r
140 else if (resp.ReturnValue == null) {
\r
141 returnTypeTag = ReturnTypeTag.Null;
\r
143 else if (IsMethodPrimitive(resp.ReturnValue.GetType())) {
\r
144 returnTypeTag = ReturnTypeTag.PrimitiveType;
\r
147 returnTypeTag = ReturnTypeTag.ObjectType;
\r
153 MethodFlags contextFlag;
\r
154 MethodFlags formatFlag;
\r
156 if ((resp.LogicalCallContext != null) && resp.LogicalCallContext.HasInfo && ((returnTypeTag & ReturnTypeTag.Exception) == 0))
\r
158 contextFlag = MethodFlags.IncludesLogicalCallContext;
\r
162 contextFlag = MethodFlags.ExcludeLogicalCallContext;
\r
164 if (resp.Properties.Count > internalProperties.Length && ((returnTypeTag & ReturnTypeTag.Exception) == 0))
\r
166 extraProperties = GetExtraProperties (resp.Properties, internalProperties);
\r
170 if (resp.OutArgCount == 0)
\r
171 formatFlag = MethodFlags.NoArguments;
\r
174 if (AllTypesArePrimitive (resp.OutArgs))
\r
175 formatFlag = MethodFlags.PrimitiveArguments;
\r
178 if (infoArrayLength == 0)
\r
179 formatFlag = MethodFlags.ArgumentsInSimpleArray;
\r
181 formatFlag = MethodFlags.ArgumentsInMultiArray;
\r
187 writer.Write ((byte) (contextFlag | formatFlag));
\r
188 writer.Write ((byte) returnTypeTag);
\r
190 // FIXME: what are the following 2 bytes for?
\r
191 writer.Write ((byte) 0);
\r
192 writer.Write ((byte) 0);
\r
196 if (returnTypeTag == ReturnTypeTag.PrimitiveType)
\r
198 writer.Write (BinaryCommon.GetTypeCode (resp.ReturnValue.GetType()));
\r
199 ObjectWriter.WritePrimitiveValue (writer, resp.ReturnValue);
\r
202 if (formatFlag == MethodFlags.PrimitiveArguments)
\r
204 writer.Write ((uint)resp.OutArgCount);
\r
205 for (int n=0; n<resp.OutArgCount; n++)
\r
207 object val = resp.GetOutArg(n);
\r
209 writer.Write (BinaryCommon.GetTypeCode (val.GetType()));
\r
210 ObjectWriter.WritePrimitiveValue (writer, val);
\r
213 writer.Write ((byte)BinaryTypeCode.Null);
\r
217 if (infoArrayLength > 0)
\r
219 object[] infoArray = new object[infoArrayLength];
\r
222 if (formatFlag == MethodFlags.ArgumentsInMultiArray)
\r
223 infoArray[n++] = resp.OutArgs;
\r
225 if (returnTypeTag == ReturnTypeTag.ObjectType)
\r
226 infoArray[n++] = resp.ReturnValue;
\r
228 if (contextFlag == MethodFlags.IncludesLogicalCallContext)
\r
229 infoArray[n++] = resp.LogicalCallContext;
\r
231 if (extraProperties != null)
\r
232 infoArray[n++] = extraProperties;
\r
236 else if ((formatFlag & MethodFlags.ArgumentsInSimpleArray) > 0)
\r
237 info = resp.OutArgs;
\r
241 ObjectWriter objectWriter = new ObjectWriter(surrogateSelector, context);
\r
242 objectWriter.WriteObjectGraph (writer, info, headers);
\r
245 writer.Write ((byte) BinaryElement.End);
\r
248 public static object ReadMethodCall (BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, ISurrogateSelector surrogateSelector, StreamingContext context, SerializationBinder binder)
\r
250 BinaryElement elem = (BinaryElement)reader.ReadByte(); // The element code
\r
251 if (elem != BinaryElement.MethodCall) throw new SerializationException("Invalid format. Expected BinaryElement.MethodCall, found " + elem);
\r
253 MethodFlags flags = (MethodFlags) reader.ReadByte();
\r
255 // FIXME: find a meaning for those 3 bytes
\r
260 if (((BinaryTypeCode)reader.ReadByte()) != BinaryTypeCode.String) throw new SerializationException ("Invalid format");
\r
261 string methodName = reader.ReadString();
\r
263 if (((BinaryTypeCode)reader.ReadByte()) != BinaryTypeCode.String) throw new SerializationException ("Invalid format");
\r
264 string className = reader.ReadString();
\r
266 bool hasContextInfo = (flags & MethodFlags.IncludesLogicalCallContext) > 0;
268 object[] arguments = null;
269 object methodSignature = null;
270 object callContext = null;
271 object[] extraProperties = null;
273 if ((flags & MethodFlags.PrimitiveArguments) > 0)
275 uint count = reader.ReadUInt32();
276 arguments = new object[count];
277 for (int n=0; n<count; n++)
279 Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());
280 arguments[n] = ObjectReader.ReadPrimitiveTypeValue (reader, type);
284 if ((flags & MethodFlags.NeedsInfoArrayMask) > 0)
\r
286 ObjectReader objectReader = new ObjectReader(surrogateSelector, context, binder);
\r
287 object[] msgInfo = (object[]) objectReader.ReadObjectGraph (reader, hasHeaders, headerHandler);
\r
289 if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0) {
\r
290 arguments = msgInfo;
\r
295 if ((flags & MethodFlags.ArgumentsInMultiArray) > 0) {
\r
296 if (msgInfo.Length > 1) arguments = (object[]) msgInfo[n++];
\r
297 else arguments = new object[0];
\r
300 if ((flags & MethodFlags.IncludesSignature) > 0)
\r
301 methodSignature = msgInfo[n++];
\r
303 if ((flags & MethodFlags.IncludesLogicalCallContext) > 0)
\r
304 callContext = msgInfo[n++];
\r
306 if (n < msgInfo.Length)
\r
307 extraProperties = (object[]) msgInfo[n];
\r
311 reader.ReadByte (); // Reads the stream ender
\r
314 if (arguments == null) arguments = new object[0];
\r
316 Header[] methodInfo = new Header[5];
\r
317 methodInfo[0] = new Header("__MethodName", methodName);
318 methodInfo[1] = new Header("__MethodSignature", methodSignature);
319 methodInfo[2] = new Header("__TypeName", className);
320 methodInfo[3] = new Header("__Args", arguments);
321 methodInfo[4] = new Header("__CallContext", callContext);
323 MethodCall call = new MethodCall (methodInfo);
325 if (extraProperties != null) {
326 foreach (DictionaryEntry entry in extraProperties)
327 call.Properties [(string)entry.Key] = entry.Value;
333 public static object ReadMethodResponse (BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, IMethodCallMessage methodCallMessage, ISurrogateSelector surrogateSelector, StreamingContext context, SerializationBinder binder)
\r
335 BinaryElement elem = (BinaryElement)reader.ReadByte(); // The element code
\r
336 if (elem != BinaryElement.MethodResponse) throw new SerializationException("Invalid format. Expected BinaryElement.MethodResponse, found " + elem);
\r
338 MethodFlags flags = (MethodFlags) reader.ReadByte ();
\r
339 ReturnTypeTag typeTag = (ReturnTypeTag) reader.ReadByte ();
\r
340 bool hasContextInfo = (flags & MethodFlags.IncludesLogicalCallContext) > 0;
342 // FIXME: find a meaning for those 2 bytes
\r
346 object returnValue = null;
\r
347 object[] outArgs = null;
\r
348 LogicalCallContext callContext = null;
\r
349 Exception exception = null;
\r
350 object[] extraProperties = null;
352 if ((typeTag & ReturnTypeTag.PrimitiveType) > 0)
354 Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());
355 returnValue = ObjectReader.ReadPrimitiveTypeValue (reader, type);
\r
358 if ((flags & MethodFlags.PrimitiveArguments) > 0)
360 uint count = reader.ReadUInt32();
361 outArgs = new object[count];
362 for (int n=0; n<count; n++) {
363 Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());
364 outArgs[n] = ObjectReader.ReadPrimitiveTypeValue (reader, type);
368 if (hasContextInfo || (typeTag & ReturnTypeTag.ObjectType) > 0 ||
\r
369 (typeTag & ReturnTypeTag.Exception) > 0 ||
\r
370 (flags & MethodFlags.ArgumentsInSimpleArray) > 0 ||
\r
371 (flags & MethodFlags.ArgumentsInMultiArray) > 0)
\r
373 // There objects that need to be deserialized using an ObjectReader
\r
375 ObjectReader objectReader = new ObjectReader(surrogateSelector, context, binder);
\r
376 object[] msgInfo = (object[]) objectReader.ReadObjectGraph (reader, hasHeaders, headerHandler);
\r
378 if ((typeTag & ReturnTypeTag.Exception) > 0) {
\r
379 exception = (Exception) msgInfo[0];
\r
381 else if ((flags & MethodFlags.NoArguments) > 0 || (flags & MethodFlags.PrimitiveArguments) > 0) {
\r
383 if ((typeTag & ReturnTypeTag.ObjectType) > 0) returnValue = msgInfo [n++];
\r
384 if (hasContextInfo) callContext = (LogicalCallContext)msgInfo[n++];
\r
385 if (n < msgInfo.Length) extraProperties = (object[]) msgInfo[n];
\r
387 else if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0) {
\r
392 outArgs = (object[]) msgInfo[n++];
\r
393 if ((typeTag & ReturnTypeTag.ObjectType) > 0) returnValue = msgInfo[n++];
\r
394 if (hasContextInfo) callContext = (LogicalCallContext)msgInfo[n++];
\r
395 if (n < msgInfo.Length) extraProperties = (object[]) msgInfo[n];
\r
399 reader.ReadByte (); // Reads the stream ender
\r
402 if (exception != null)
\r
403 return new ReturnMessage (exception, methodCallMessage);
\r
406 int argCount = (outArgs!=null) ? outArgs.Length : 0;
\r
407 ReturnMessage result = new ReturnMessage (returnValue, outArgs, argCount, callContext, methodCallMessage);
\r
409 if (extraProperties != null) {
410 foreach (DictionaryEntry entry in extraProperties)
411 result.Properties [(string)entry.Key] = entry.Value;
418 private static bool AllTypesArePrimitive(object[] objects)
\r
420 foreach (object ob in objects)
\r
422 if (ob != null && !IsMethodPrimitive(ob.GetType()))
\r
428 // When serializing methods, string are considered primitive types
\r
429 public static bool IsMethodPrimitive (Type type)
\r
431 return type.IsPrimitive || type == typeof(string) || type == typeof (DateTime) || type == typeof (Decimal);
\r
434 static object[] GetExtraProperties (IDictionary properties, string[] internalKeys)
\r
436 object[] extraProperties = new object [properties.Count - internalKeys.Length];
\r
439 IDictionaryEnumerator e = properties.GetEnumerator();
\r
440 while (e.MoveNext())
\r
441 if (!IsInternalKey ((string) e.Entry.Key, internalKeys)) extraProperties [n++] = e.Entry;
\r
443 return extraProperties;
\r
446 static bool IsInternalKey (string key, string[] internalKeys)
\r
448 foreach (string ikey in internalKeys)
\r
449 if (key == ikey) return true;
\r