public void WriteValue(BinaryWriter writer, Type valueType, object val) { if (val == null) { BinaryCommon.CheckSerializable(valueType, this._surrogateSelector, this._context); writer.Write(10); } else if (BinaryCommon.IsPrimitive(val.GetType())) { if (!BinaryCommon.IsPrimitive(valueType)) { writer.Write(8); this.WriteTypeSpec(writer, val.GetType()); } ObjectWriter.WritePrimitiveValue(writer, val); } else if (valueType.IsValueType) { this.WriteObjectInstance(writer, val, true); } else if (val is string) { bool flag; long id = this._idGenerator.GetId(val, out flag); if (flag) { this.WriteObjectInstance(writer, val, false); } else { this.WriteObjectReference(writer, id); } } else { bool flag2; long id2 = this._idGenerator.GetId(val, out flag2); if (flag2) { this._pendingObjects.Enqueue(val); } this.WriteObjectReference(writer, id2); } }
public static void WriteMethodCall(BinaryWriter writer, object obj, Header[] headers, BinaryFormatter formatter) { IMethodCallMessage call = (IMethodCallMessage)obj; writer.Write((byte)BinaryElement.MethodCall); MethodFlags methodFlags; int infoArraySize = 0; object info = null; object[] extraProperties = null; if (call.LogicalCallContext != null && call.LogicalCallContext.HasInfo) { methodFlags = MethodFlags.IncludesLogicalCallContext; infoArraySize++; } else { methodFlags = MethodFlags.ExcludeLogicalCallContext; } if (RemotingServices.IsMethodOverloaded(call)) { infoArraySize++; methodFlags |= MethodFlags.IncludesSignature; } if (call.Properties.Count > MethodCallDictionary.InternalKeys.Length) { extraProperties = GetExtraProperties(call.Properties, MethodCallDictionary.InternalKeys); infoArraySize++; } if (call.MethodBase.IsGenericMethod) { infoArraySize++; methodFlags |= MethodFlags.GenericArguments; } if (call.ArgCount == 0) { methodFlags |= MethodFlags.NoArguments; } else { if (AllTypesArePrimitive(call.Args)) { methodFlags |= MethodFlags.PrimitiveArguments; } else { if (infoArraySize == 0) { methodFlags |= MethodFlags.ArgumentsInSimpleArray; } else { methodFlags |= MethodFlags.ArgumentsInMultiArray; infoArraySize++; } } } writer.Write((int)methodFlags); // Method name writer.Write((byte)BinaryTypeCode.String); writer.Write(call.MethodName); // Class name writer.Write((byte)BinaryTypeCode.String); writer.Write(call.TypeName); // Arguments if ((methodFlags & MethodFlags.PrimitiveArguments) > 0) { writer.Write((uint)call.Args.Length); for (int n = 0; n < call.ArgCount; n++) { object arg = call.GetArg(n); if (arg != null) { writer.Write(BinaryCommon.GetTypeCode(arg.GetType())); ObjectWriter.WritePrimitiveValue(writer, arg); } else { writer.Write((byte)BinaryTypeCode.Null); } } } if (infoArraySize > 0) { object[] ainfo = new object[infoArraySize]; int n = 0; if ((methodFlags & MethodFlags.ArgumentsInMultiArray) > 0) { ainfo[n++] = call.Args; } if ((methodFlags & MethodFlags.GenericArguments) > 0) { ainfo[n++] = call.MethodBase.GetGenericArguments(); } if ((methodFlags & MethodFlags.IncludesSignature) > 0) { ainfo[n++] = call.MethodSignature; } if ((methodFlags & MethodFlags.IncludesLogicalCallContext) > 0) { ainfo[n++] = call.LogicalCallContext; } if (extraProperties != null) { ainfo[n++] = extraProperties; } info = ainfo; } else if ((methodFlags & MethodFlags.ArgumentsInSimpleArray) > 0) { info = call.Args; } if (info != null) { ObjectWriter objectWriter = new ObjectWriter(formatter); objectWriter.WriteObjectGraph(writer, info, headers); } else { writer.Write((byte)BinaryElement.End); } }
public static void WriteMethodResponse(BinaryWriter writer, object obj, Header[] headers, BinaryFormatter formatter) { IMethodReturnMessage resp = (IMethodReturnMessage)obj; writer.Write((byte)BinaryElement.MethodResponse); string[] internalProperties = MethodReturnDictionary.InternalReturnKeys; int infoArrayLength = 0; object info = null; object[] extraProperties = null; // Type of return value ReturnTypeTag returnTypeTag; MethodFlags contextFlag = MethodFlags.ExcludeLogicalCallContext; if (resp.Exception != null) { returnTypeTag = ReturnTypeTag.Exception | ReturnTypeTag.Null; internalProperties = MethodReturnDictionary.InternalExceptionKeys; infoArrayLength = 1; } else if (resp.ReturnValue == null) { returnTypeTag = ReturnTypeTag.Null; } else if (IsMethodPrimitive(resp.ReturnValue.GetType())) { returnTypeTag = ReturnTypeTag.PrimitiveType; } else { returnTypeTag = ReturnTypeTag.ObjectType; infoArrayLength++; } // Message flags MethodFlags formatFlag; if ((resp.LogicalCallContext != null) && resp.LogicalCallContext.HasInfo) { contextFlag = MethodFlags.IncludesLogicalCallContext; infoArrayLength++; } if (resp.Properties.Count > internalProperties.Length && ((returnTypeTag & ReturnTypeTag.Exception) == 0)) { extraProperties = GetExtraProperties(resp.Properties, internalProperties); infoArrayLength++; } if (resp.OutArgCount == 0) { formatFlag = MethodFlags.NoArguments; } else { if (AllTypesArePrimitive(resp.Args)) { formatFlag = MethodFlags.PrimitiveArguments; } else { if (infoArrayLength == 0) { formatFlag = MethodFlags.ArgumentsInSimpleArray; } else { formatFlag = MethodFlags.ArgumentsInMultiArray; infoArrayLength++; } } } writer.Write((byte)(contextFlag | formatFlag)); writer.Write((byte)returnTypeTag); // FIXME: what are the following 2 bytes for? writer.Write((byte)0); writer.Write((byte)0); // Arguments if (returnTypeTag == ReturnTypeTag.PrimitiveType) { writer.Write(BinaryCommon.GetTypeCode(resp.ReturnValue.GetType())); ObjectWriter.WritePrimitiveValue(writer, resp.ReturnValue); } if (formatFlag == MethodFlags.PrimitiveArguments) { writer.Write((uint)resp.ArgCount); for (int n = 0; n < resp.ArgCount; n++) { object val = resp.GetArg(n); if (val != null) { writer.Write(BinaryCommon.GetTypeCode(val.GetType())); ObjectWriter.WritePrimitiveValue(writer, val); } else { writer.Write((byte)BinaryTypeCode.Null); } } } if (infoArrayLength > 0) { object[] infoArray = new object[infoArrayLength]; int n = 0; if ((returnTypeTag & ReturnTypeTag.Exception) != 0) { infoArray[n++] = resp.Exception; } if (formatFlag == MethodFlags.ArgumentsInMultiArray) { infoArray[n++] = resp.Args; } if (returnTypeTag == ReturnTypeTag.ObjectType) { infoArray[n++] = resp.ReturnValue; } if (contextFlag == MethodFlags.IncludesLogicalCallContext) { infoArray[n++] = resp.LogicalCallContext; } if (extraProperties != null) { infoArray[n++] = extraProperties; } info = infoArray; } else if ((formatFlag & MethodFlags.ArgumentsInSimpleArray) > 0) { info = resp.Args; } if (info != null) { ObjectWriter objectWriter = new ObjectWriter(formatter); objectWriter.WriteObjectGraph(writer, info, headers); } else { writer.Write((byte)BinaryElement.End); } }
public static void WriteMethodResponse(BinaryWriter writer, object obj, Header[] headers, ISurrogateSelector surrogateSelector, StreamingContext context, FormatterAssemblyStyle assemblyFormat, FormatterTypeStyle typeFormat) { IMethodReturnMessage methodReturnMessage = (IMethodReturnMessage)obj; writer.Write(22); string[] array = MethodReturnDictionary.InternalReturnKeys; int num = 0; object obj2 = null; object[] array2 = null; MethodFlags methodFlags = MethodFlags.ExcludeLogicalCallContext; ReturnTypeTag returnTypeTag; if (methodReturnMessage.Exception != null) { returnTypeTag = (ReturnTypeTag)34; array = MethodReturnDictionary.InternalExceptionKeys; num = 1; } else if (methodReturnMessage.ReturnValue == null) { returnTypeTag = ReturnTypeTag.Null; } else if (MessageFormatter.IsMethodPrimitive(methodReturnMessage.ReturnValue.GetType())) { returnTypeTag = ReturnTypeTag.PrimitiveType; } else { returnTypeTag = ReturnTypeTag.ObjectType; num++; } if (methodReturnMessage.LogicalCallContext != null && methodReturnMessage.LogicalCallContext.HasInfo) { methodFlags = MethodFlags.IncludesLogicalCallContext; num++; } if (methodReturnMessage.Properties.Count > array.Length && (byte)(returnTypeTag & ReturnTypeTag.Exception) == 0) { array2 = MessageFormatter.GetExtraProperties(methodReturnMessage.Properties, array); num++; } MethodFlags methodFlags2; if (methodReturnMessage.OutArgCount == 0) { methodFlags2 = MethodFlags.NoArguments; } else if (MessageFormatter.AllTypesArePrimitive(methodReturnMessage.Args)) { methodFlags2 = MethodFlags.PrimitiveArguments; } else if (num == 0) { methodFlags2 = MethodFlags.ArgumentsInSimpleArray; } else { methodFlags2 = MethodFlags.ArgumentsInMultiArray; num++; } writer.Write((byte)(methodFlags | methodFlags2)); writer.Write((byte)returnTypeTag); writer.Write(0); writer.Write(0); if (returnTypeTag == ReturnTypeTag.PrimitiveType) { writer.Write(BinaryCommon.GetTypeCode(methodReturnMessage.ReturnValue.GetType())); ObjectWriter.WritePrimitiveValue(writer, methodReturnMessage.ReturnValue); } if (methodFlags2 == MethodFlags.PrimitiveArguments) { writer.Write((uint)methodReturnMessage.ArgCount); for (int i = 0; i < methodReturnMessage.ArgCount; i++) { object arg = methodReturnMessage.GetArg(i); if (arg != null) { writer.Write(BinaryCommon.GetTypeCode(arg.GetType())); ObjectWriter.WritePrimitiveValue(writer, arg); } else { writer.Write(17); } } } if (num > 0) { object[] array3 = new object[num]; int num2 = 0; if ((byte)(returnTypeTag & ReturnTypeTag.Exception) != 0) { array3[num2++] = methodReturnMessage.Exception; } if (methodFlags2 == MethodFlags.ArgumentsInMultiArray) { array3[num2++] = methodReturnMessage.Args; } if (returnTypeTag == ReturnTypeTag.ObjectType) { array3[num2++] = methodReturnMessage.ReturnValue; } if (methodFlags == MethodFlags.IncludesLogicalCallContext) { array3[num2++] = methodReturnMessage.LogicalCallContext; } if (array2 != null) { array3[num2++] = array2; } obj2 = array3; } else if ((methodFlags2 & MethodFlags.ArgumentsInSimpleArray) > (MethodFlags)0) { obj2 = methodReturnMessage.Args; } if (obj2 != null) { ObjectWriter objectWriter = new ObjectWriter(surrogateSelector, context, assemblyFormat, typeFormat); objectWriter.WriteObjectGraph(writer, obj2, headers); } else { writer.Write(11); } }
public static void WriteMethodCall(BinaryWriter writer, object obj, Header[] headers, ISurrogateSelector surrogateSelector, StreamingContext context, FormatterAssemblyStyle assemblyFormat, FormatterTypeStyle typeFormat) { IMethodCallMessage methodCallMessage = (IMethodCallMessage)obj; writer.Write(21); int num = 0; object obj2 = null; object[] array = null; MethodFlags methodFlags; if (methodCallMessage.LogicalCallContext != null && methodCallMessage.LogicalCallContext.HasInfo) { methodFlags = MethodFlags.IncludesLogicalCallContext; num++; } else { methodFlags = MethodFlags.ExcludeLogicalCallContext; } if (RemotingServices.IsMethodOverloaded(methodCallMessage)) { num++; methodFlags |= MethodFlags.IncludesSignature; } if (methodCallMessage.Properties.Count > MethodCallDictionary.InternalKeys.Length) { array = MessageFormatter.GetExtraProperties(methodCallMessage.Properties, MethodCallDictionary.InternalKeys); num++; } if (methodCallMessage.MethodBase.IsGenericMethod) { num++; methodFlags |= MethodFlags.GenericArguments; } if (methodCallMessage.ArgCount == 0) { methodFlags |= MethodFlags.NoArguments; } else if (MessageFormatter.AllTypesArePrimitive(methodCallMessage.Args)) { methodFlags |= MethodFlags.PrimitiveArguments; } else if (num == 0) { methodFlags |= MethodFlags.ArgumentsInSimpleArray; } else { methodFlags |= MethodFlags.ArgumentsInMultiArray; num++; } writer.Write((int)methodFlags); writer.Write(18); writer.Write(methodCallMessage.MethodName); writer.Write(18); writer.Write(methodCallMessage.TypeName); if ((methodFlags & MethodFlags.PrimitiveArguments) > (MethodFlags)0) { writer.Write((uint)methodCallMessage.Args.Length); for (int i = 0; i < methodCallMessage.ArgCount; i++) { object arg = methodCallMessage.GetArg(i); if (arg != null) { writer.Write(BinaryCommon.GetTypeCode(arg.GetType())); ObjectWriter.WritePrimitiveValue(writer, arg); } else { writer.Write(17); } } } if (num > 0) { object[] array2 = new object[num]; int num2 = 0; if ((methodFlags & MethodFlags.ArgumentsInMultiArray) > (MethodFlags)0) { array2[num2++] = methodCallMessage.Args; } if ((methodFlags & MethodFlags.GenericArguments) > (MethodFlags)0) { array2[num2++] = methodCallMessage.MethodBase.GetGenericArguments(); } if ((methodFlags & MethodFlags.IncludesSignature) > (MethodFlags)0) { array2[num2++] = methodCallMessage.MethodSignature; } if ((methodFlags & MethodFlags.IncludesLogicalCallContext) > (MethodFlags)0) { array2[num2++] = methodCallMessage.LogicalCallContext; } if (array != null) { array2[num2++] = array; } obj2 = array2; } else if ((methodFlags & MethodFlags.ArgumentsInSimpleArray) > (MethodFlags)0) { obj2 = methodCallMessage.Args; } if (obj2 != null) { ObjectWriter objectWriter = new ObjectWriter(surrogateSelector, context, assemblyFormat, typeFormat); objectWriter.WriteObjectGraph(writer, obj2, headers); } else { writer.Write(11); } }