public static T ParseCommand <T>(byte[] cmdBytes)
{
var cmdSize = GetFirstCommandSize(cmdBytes);
var bts = cmdBytes.Skip(tag4ContentSize).Take(cmdSize).ToArray();
return(SerializerUtility.Instance().BinDeserialize <T>(bts));
}
internal void SendResponse(CommandResult result)
{
MemoryStream ms = new MemoryStream();
BufferedStream bs = new BufferedStream(ms);
BinaryWriter bw = new BinaryWriter(bs, UnicodeEncoding.UTF8);
var cmdBytes = SerializerUtility.Instance().BinSerialize(result);
bw.Write(cmdBytes.Length);
bw.Write(cmdBytes);
bw.Flush();
if (!this.IsTagged)
{
try
{
this.Socket.Send(ms.ToArray());
}
catch (Exception ex)
{
Console.WriteLine("Socket.Send失败");
}
}
}
public CommandResult WaitForResult()
{
var commandResult = mgr.Receive();
if (!commandResult.Sucessful)
{
Exception exception = SerializerUtility.Instance().BinDeserialize <Exception>(commandResult.Exception);
throw exception;
}
return(commandResult);
}
public void Send(Command cmd)
{
MemoryStream ms = new MemoryStream();
BufferedStream bs = new BufferedStream(ms);
BinaryWriter bw = new BinaryWriter(bs, UnicodeEncoding.UTF8);
var cmdBytes = SerializerUtility.Instance().BinSerialize(cmd);
bw.Write(cmdBytes.Length);
bw.Write(cmdBytes);
bw.Flush();
clientSocket.Send(ms.ToArray());
}
private CommandResult Process(Command command)
{
var serviceDescriptor = ServiceRegistry.ResolveServiceDescriptor(command.CallContract);
var methodDescriptor = ServiceRegistry.ResolveMethodDescriptor(command.CallContract, command.Method2Invoke);
List <object> parameters = new List <object>();
foreach (var pd in methodDescriptor.ParameterDescriptors)
{
parameters.Add(ParameterParser.GetValue(command, pd));
}
object serviceInstance = Activator.CreateInstance(serviceDescriptor.ServiceType);
bool successful = false;
Exception exc = null;
bool noReturnValue = false;
object resultValue = null;
if (methodDescriptor.MethodInfo.ReturnType.Equals(typeof(void)))
{
noReturnValue = true;
}
try
{
if (noReturnValue)
{
methodDescriptor.MethodInfo.Invoke(serviceInstance, parameters.ToArray());
}
else
{
resultValue = methodDescriptor.MethodInfo.Invoke(serviceInstance, parameters.ToArray());
}
successful = true;
}
catch (Exception ex)
{
exc = ex.InnerException;
successful = false;
}
CommandResult result = new CommandResult();
result.Sucessful = successful;
result.ConnectionWorker = command.ConnectionWorker;
if (successful)
{
if (!noReturnValue)
{
result.Result = SerializerUtility.Instance().BinSerialize(resultValue);
}
}
else
{
result.Exception = SerializerUtility.Instance().BinSerialize(exc);
}
result.ConnectionWorker.LastActiveTime = DateTime.Now; //reset timeout
return(result);
}
public static T Create <T>(CommandBusClient commandBusClient)
{
string id = string.Format("Commonization{0}", typeof(T).FullName.Replace(".", ""));
string proxyTypeString = "Commonization" + id;
string proxyDllName = id + ".dll";
Type proxyType = null;
if (!createdProxies.ContainsKey(typeof(T)))
{
AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(id), AssemblyBuilderAccess.RunAndSave);
var mdlBldr = asmBuilder.DefineDynamicModule(id, proxyDllName);
var typeBldr = mdlBldr.DefineType(proxyTypeString, TypeAttributes.Public, null, new Type[] { typeof(T) });
//嵌入ESB私有变量
var esbSrvField = typeBldr.DefineField("esbSrv", typeof(CommandBusClient), FieldAttributes.Private);
var serializeField = typeBldr.DefineField("serializeSrv", typeof(SerializerUtility), FieldAttributes.Private);
//构造函数
var constructor = typeBldr.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(CommandBusClient), typeof(SerializerUtility) });
var il = constructor.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Stfld, serializeField);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, esbSrvField);
il.Emit(OpCodes.Ret);
//改写方法
var methods = typeof(T).GetMethods(BindingFlags.Public | BindingFlags.Instance);
for (var i = 0; i < methods.Length; i++)
{
var paramTypes = GetParametersType(methods[i]);
Type[] parameterTypes = null;
if (paramTypes != null && paramTypes.Length > 0)
{
parameterTypes = paramTypes.Select(f => f.ParameterType).ToArray();
}
else
{
parameterTypes = new Type[] { }
};
var methodBlfr = typeBldr.DefineMethod(methods[i].Name, MethodAttributes.Public | MethodAttributes.Virtual, CallingConventions.Standard, methods[i].ReturnType, parameterTypes);
il = methodBlfr.GetILGenerator();
//声明各个局部变量
var requestLocal = il.DeclareLocal(typeof(Command));
var argsLocal = il.DeclareLocal(typeof(Dictionary <string, object>));
var responseLocal = il.DeclareLocal(typeof(CommandResult));
var value2Object = il.DeclareLocal(typeof(object));
#region Command requestLocal=new Command();
il.Emit(OpCodes.Newobj, typeof(Command).GetConstructor(new Type[0]));
il.Emit(OpCodes.Stloc, requestLocal);
#endregion
#region Dictionary<string, object> argsLocal=new Dictionary<string, object>();
il.Emit(OpCodes.Newobj, typeof(Dictionary <string, object>).GetConstructor(new Type[0]));
il.Emit(OpCodes.Stloc, argsLocal);
#endregion
#region 将传入方法的参数全部Add到List object 中
MethodInfo mi = typeof(Dictionary <string, object>).GetMethod("Add");
if (paramTypes != null)
{
for (var index = 0; index < paramTypes.Length; index++)
{
if (paramTypes[index].ParameterType.IsValueType)
{
//box
il.Emit(OpCodes.Ldarg, 1 + index);
il.Emit(OpCodes.Box, paramTypes[index].ParameterType);
il.Emit(OpCodes.Stloc, value2Object);
il.Emit(OpCodes.Ldloc, argsLocal);
il.Emit(OpCodes.Ldstr, paramTypes[index].ParameterName); //Dictionary->key
il.Emit(OpCodes.Ldloc, value2Object); //Dictionary->value
il.Emit(OpCodes.Callvirt, mi);
}
else
{
il.Emit(OpCodes.Ldloc, argsLocal);
il.Emit(OpCodes.Ldstr, paramTypes[index].ParameterName); //Dictionary->key
il.Emit(OpCodes.Ldarg, 1 + index); //Dictionary->value
il.Emit(OpCodes.Callvirt, mi);
}
}
}
#endregion
#region requestLocal.Arguments=argsLocal
mi = typeof(Command).GetMethod("set_Arguments");
il.Emit(OpCodes.Ldloc, requestLocal);
il.Emit(OpCodes.Ldloc, 1);
il.Emit(OpCodes.Callvirt, mi);
#endregion
#region requestLocal.Method2Invoke=methods[i].Name
mi = typeof(Command).GetMethod("set_Method2Invoke");
il.Emit(OpCodes.Ldloc, requestLocal);
il.Emit(OpCodes.Ldstr, methods[i].Name);
il.Emit(OpCodes.Callvirt, mi);
#endregion
#region requestLocal.CallContractNamespace=typeof(T).Namespace
mi = typeof(Command).GetMethod("set_CallContractNamespace");
il.Emit(OpCodes.Ldloc, requestLocal);
il.Emit(OpCodes.Ldstr, typeof(T).Namespace);
il.Emit(OpCodes.Callvirt, mi);
#endregion
#region requestLocal.CallContract=typeof(T).Name
mi = typeof(Command).GetMethod("set_CallContract");
il.Emit(OpCodes.Ldloc, requestLocal);
il.Emit(OpCodes.Ldstr, typeof(T).Name);
il.Emit(OpCodes.Callvirt, mi);
#endregion
#region esbSrvField.Send(requestLocal)
mi = typeof(CommandBusClient).GetMethod("Send");
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, esbSrvField);
il.Emit(OpCodes.Ldloc, requestLocal);
il.Emit(OpCodes.Call, mi);
#endregion
#region esbSrvField.WaitForResult()
mi = typeof(CommandBusClient).GetMethod("WaitForResult");
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, esbSrvField);
il.Emit(OpCodes.Callvirt, mi);
il.Emit(OpCodes.Stloc, responseLocal);
#endregion
if (methods[i].ReturnType != typeof(void))
{
var response_Result_Bytes = il.DeclareLocal(typeof(byte[]));
var responseResultCasted = il.DeclareLocal(methods[i].ReturnType);
#region responseResult=responseLocal.Result/Successful/Exception;
mi = typeof(CommandResult).GetMethod("get_Result");
il.Emit(OpCodes.Ldloc, responseLocal);
il.Emit(OpCodes.Callvirt, mi);
il.Emit(OpCodes.Stloc, response_Result_Bytes);
#endregion
#region SerializerUtility.BinDeserialize<T>(cmdResult.Result)
mi = typeof(SerializerUtility).GetMethod("BinDeserialize");
mi = mi.MakeGenericMethod(methods[i].ReturnType);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, serializeField);
il.Emit(OpCodes.Ldloc, response_Result_Bytes);
il.Emit(OpCodes.Callvirt, mi);
il.Emit(OpCodes.Stloc, responseResultCasted);
il.Emit(OpCodes.Ldloc, responseResultCasted);
#endregion
}
il.Emit(OpCodes.Ret);
}
proxyType = typeBldr.CreateType();
//asmBuilder.Save(proxyDllName);
createdProxies[typeof(T)] = proxyType;
}
proxyType = createdProxies[typeof(T)];
return((T)Activator.CreateInstance(proxyType, new object[] { commandBusClient, SerializerUtility.Instance() }));
}
