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, FormatterAssemblyStyle assemblyFormat)
\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.ArgCount; 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, assemblyFormat);
\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, FormatterAssemblyStyle assemblyFormat)
\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, assemblyFormat);
\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, BinaryFormatter formatter)
\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;
272 Header[] headers = null;
274 if ((flags & MethodFlags.PrimitiveArguments) > 0)
276 uint count = reader.ReadUInt32();
277 arguments = new object[count];
278 for (int n=0; n<count; n++)
280 Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());
281 arguments[n] = ObjectReader.ReadPrimitiveTypeValue (reader, type);
285 if ((flags & MethodFlags.NeedsInfoArrayMask) > 0)
\r
287 ObjectReader objectReader = new ObjectReader (formatter);
\r
290 objectReader.ReadObjectGraph (reader, hasHeaders, out result, out headers);
\r
291 object[] msgInfo = (object[]) result;
\r
293 if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0) {
\r
294 arguments = msgInfo;
\r
299 if ((flags & MethodFlags.ArgumentsInMultiArray) > 0) {
\r
300 if (msgInfo.Length > 1) arguments = (object[]) msgInfo[n++];
\r
301 else arguments = new object[0];
\r
304 if ((flags & MethodFlags.IncludesSignature) > 0)
\r
305 methodSignature = msgInfo[n++];
\r
307 if ((flags & MethodFlags.IncludesLogicalCallContext) > 0)
\r
308 callContext = msgInfo[n++];
\r
310 if (n < msgInfo.Length)
\r
311 extraProperties = (object[]) msgInfo[n];
\r
315 reader.ReadByte (); // Reads the stream ender
\r
318 if (arguments == null) arguments = new object[0];
\r
321 if (headerHandler != null)
\r
322 uri = headerHandler(headers) as string;
\r
324 Header[] methodInfo = new Header[6];
\r
325 methodInfo[0] = new Header("__MethodName", methodName);
326 methodInfo[1] = new Header("__MethodSignature", methodSignature);
327 methodInfo[2] = new Header("__TypeName", className);
328 methodInfo[3] = new Header("__Args", arguments);
329 methodInfo[4] = new Header("__CallContext", callContext);
330 methodInfo[5] = new Header("__Uri", uri);
332 MethodCall call = new MethodCall (methodInfo);
334 if (extraProperties != null) {
335 foreach (DictionaryEntry entry in extraProperties)
336 call.Properties [(string)entry.Key] = entry.Value;
342 public static object ReadMethodResponse (BinaryReader reader, bool hasHeaders, HeaderHandler headerHandler, IMethodCallMessage methodCallMessage, BinaryFormatter formatter)
\r
344 BinaryElement elem = (BinaryElement)reader.ReadByte(); // The element code
\r
345 if (elem != BinaryElement.MethodResponse) throw new SerializationException("Invalid format. Expected BinaryElement.MethodResponse, found " + elem);
\r
347 MethodFlags flags = (MethodFlags) reader.ReadByte ();
\r
348 ReturnTypeTag typeTag = (ReturnTypeTag) reader.ReadByte ();
\r
349 bool hasContextInfo = (flags & MethodFlags.IncludesLogicalCallContext) > 0;
351 // FIXME: find a meaning for those 2 bytes
\r
355 object returnValue = null;
\r
356 object[] outArgs = null;
\r
357 LogicalCallContext callContext = null;
\r
358 Exception exception = null;
\r
359 object[] extraProperties = null;
360 Header[] headers = null;
362 if ((typeTag & ReturnTypeTag.PrimitiveType) > 0)
364 Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());
365 returnValue = ObjectReader.ReadPrimitiveTypeValue (reader, type);
\r
368 if ((flags & MethodFlags.PrimitiveArguments) > 0)
370 uint count = reader.ReadUInt32();
371 outArgs = new object[count];
372 for (int n=0; n<count; n++) {
373 Type type = BinaryCommon.GetTypeFromCode (reader.ReadByte());
374 outArgs[n] = ObjectReader.ReadPrimitiveTypeValue (reader, type);
378 if (hasContextInfo || (typeTag & ReturnTypeTag.ObjectType) > 0 ||
\r
379 (typeTag & ReturnTypeTag.Exception) > 0 ||
\r
380 (flags & MethodFlags.ArgumentsInSimpleArray) > 0 ||
\r
381 (flags & MethodFlags.ArgumentsInMultiArray) > 0)
\r
383 // There objects that need to be deserialized using an ObjectReader
\r
385 ObjectReader objectReader = new ObjectReader (formatter);
\r
387 objectReader.ReadObjectGraph (reader, hasHeaders, out result, out headers);
\r
388 object[] msgInfo = (object[]) result;
\r
390 if ((typeTag & ReturnTypeTag.Exception) > 0) {
\r
391 exception = (Exception) msgInfo[0];
\r
393 else if ((flags & MethodFlags.NoArguments) > 0 || (flags & MethodFlags.PrimitiveArguments) > 0) {
\r
395 if ((typeTag & ReturnTypeTag.ObjectType) > 0) returnValue = msgInfo [n++];
\r
396 if (hasContextInfo) callContext = (LogicalCallContext)msgInfo[n++];
\r
397 if (n < msgInfo.Length) extraProperties = (object[]) msgInfo[n];
\r
399 else if ((flags & MethodFlags.ArgumentsInSimpleArray) > 0) {
\r
404 outArgs = (object[]) msgInfo[n++];
\r
405 if ((typeTag & ReturnTypeTag.ObjectType) > 0) returnValue = msgInfo[n++];
\r
406 if (hasContextInfo) callContext = (LogicalCallContext)msgInfo[n++];
\r
407 if (n < msgInfo.Length) extraProperties = (object[]) msgInfo[n];
\r
411 reader.ReadByte (); // Reads the stream ender
\r
414 if (headerHandler != null)
\r
415 headerHandler(headers);
\r
417 if (exception != null)
\r
418 return new ReturnMessage (exception, methodCallMessage);
\r
421 int argCount = (outArgs!=null) ? outArgs.Length : 0;
\r
422 ReturnMessage result = new ReturnMessage (returnValue, outArgs, argCount, callContext, methodCallMessage);
\r
424 if (extraProperties != null) {
425 foreach (DictionaryEntry entry in extraProperties)
426 result.Properties [(string)entry.Key] = entry.Value;
433 private static bool AllTypesArePrimitive(object[] objects)
\r
435 foreach (object ob in objects)
\r
437 if (ob != null && !IsMethodPrimitive(ob.GetType()))
\r
443 // When serializing methods, string are considered primitive types
\r
444 public static bool IsMethodPrimitive (Type type)
\r
446 return type.IsPrimitive || type == typeof(string) || type == typeof (DateTime) || type == typeof (Decimal);
\r
449 static object[] GetExtraProperties (IDictionary properties, string[] internalKeys)
\r
451 object[] extraProperties = new object [properties.Count - internalKeys.Length];
\r
454 IDictionaryEnumerator e = properties.GetEnumerator();
\r
455 while (e.MoveNext())
\r
456 if (!IsInternalKey ((string) e.Entry.Key, internalKeys)) extraProperties [n++] = e.Entry;
\r
458 return extraProperties;
\r
461 static bool IsInternalKey (string key, string[] internalKeys)
\r
463 foreach (string ikey in internalKeys)
\r
464 if (key == ikey) return true;
\r