private void SendRequest(ISerializerable request, int requestIndex)
{
if (this.IsConnect)
{
var index = 0;
if (MessageHandleTypes.GetTypeIndex(request.GetType(), out index))
{
using (var mem = new MemoryStream())
{
using (var bw = new BinaryWriter(mem))
{
bw.Write(requestIndex);
request.ToBinary(bw);
if (NetProtoTool.EnableLog)
{
Debuger.Log(request.GetType() + "-->" + JsonTool.Serialize(request));
}
}
var result = new Message(MessageClass.Request, index, mem.ToArray());
SendMessage(result);
}
}
}
else
{
IHandler handler;
if (Handler._handlers.TryToGetValue(requestIndex, out handler))
{
handler.OnHandle(false, null);
}
}
}
/// <summary>
/// 注册一个类型
/// </summary>
/// <typeparam name="T">The 1st type parameter.</typeparam>
public void RegType <T>() where T : class, new()
{
var attrs = typeof(T).GetCustomAttributes <HandleTypeAttribute>();
if (attrs.Count() > 0)
{
var index = 0;
if (MessageHandleTypes.GetTypeIndex(attrs.First().HandleType, out index))
{
_handler.Add(index, typeof(T));
}
}
}
public void ToBytes(BinaryWriter bw)
{
bw.Write(time);
bw.Write(notifys.Count);
foreach (var i in notifys)
{
int index = 0;
if (MessageHandleTypes.GetTypeIndex(i.GetType(), out index))
{
bw.Write(index);
i.ToBinary(bw);
}
}
}
public static ISerializerable GetProtoMessage(Message message)
{
var type = MessageHandleTypes.GetTypeByIndex(message.Flag);
var protoMsg = Activator.CreateInstance(type) as ISerializerable;
using (var mem = new MemoryStream(message.Content))
{
using (var br = new BinaryReader(mem))
{
protoMsg.ParseFormBinary(br);
}
}
return(protoMsg);
}
public static Message ToNetMessage(MessageClass @class, ISerializerable m)
{
int flag;
MessageHandleTypes.GetTypeIndex(m.GetType(), out flag);
using (var mem = new MemoryStream())
{
using (var bw = new BinaryWriter(mem))
{
m.ToBinary(bw);
}
return(new Message(@class, flag, mem.ToArray()));
}
}
public override void Handle(Message message)
{
int requestIndex = 0;
Type responseType = MessageHandleTypes.GetTypeByIndex(message.Flag);
ISerializerable response;
using (var mem = new MemoryStream(message.Content))
{
using (var br = new BinaryReader(mem))
{
if (message.Class == MessageClass.Response)
{
requestIndex = br.ReadInt32();
}
response = Activator.CreateInstance(responseType) as Proto.ISerializerable;
response.ParseFormBinary(br);
#if NETDEBUG
Debug.Log(response.GetType() + "-->" + JsonTool.Serialize(response));
#endif
}
}
if (message.Class == MessageClass.Response)
{
IHandler handler;
if (_handlers.TryGetValue(requestIndex, out handler))
{
_handlers.Remove(requestIndex);
handler.OnHandle(true, response);
}
}
else if (message.Class == MessageClass.Task)
{
Type handlerType;
if (_taskHandler.TryGetValue(message.Flag, out handlerType))
{
var handler = Activator.CreateInstance(handlerType);
var m = handlerType.GetMethod("DoTask");
m.Invoke(handler, new object[] { response });
}
else
{
Debuger.LogError("NoHanlderType:" + message.Flag);
}
}
}
public override void Handle(Message message)
{
Type notifyType = MessageHandleTypes.GetTypeByIndex(message.Flag);
ISerializerable notify;
using (var mem = new MemoryStream(message.Content))
{
using (var br = new BinaryReader(mem))
{
notify = Activator.CreateInstance(notifyType) as Proto.ISerializerable;
notify.ParseFormBinary(br);
#if NETDEBUG
Debug.Log(notify.GetType() + "-->" + JsonTool.Serialize(notify));
#endif
}
}
Gate.ProcessNotify(notify);
}
public static Message ToMessage(MessageClass @class, Proto.ISerializerable m)
{
var index = 0;
if (MessageHandleTypes.GetTypeIndex(m.GetType(), out index))
{
using (var mem = new MemoryStream())
{
using (var bw = new BinaryWriter(mem))
{
m.ToBinary(bw);
}
return(new Message(@class, index, mem.ToArray()));
}
}
return(null);
}
private void SendRequest(Proto.ISerializerable request, int requestIndex)
{
var index = 0;
if (MessageHandleTypes.GetTypeIndex(request.GetType(), out index))
{
using (var mem = new MemoryStream())
{
using (var bw = new BinaryWriter(mem))
{
bw.Write(requestIndex);
request.ToBinary(bw);
#if NETDEBUG
Debug.Log(request.GetType() + "-->" + JsonTool.Serialize(request));
#endif
}
var result = new Message(MessageClass.Request, index, mem.ToArray());
SendMessage(result);
}
}
}
/// <summary>
/// 注册一个程序集
/// </summary>
/// <param name="assembly">Assembly.</param>
/// <param name="rTy">R ty.</param>
public void RegAssembly(Assembly assembly, HandleResponserType rTy)
{
var types = assembly.GetTypes();
foreach (var i in types)
{
var attrs = i.GetCustomAttributes <HandleTypeAttribute>();
if (attrs.Count() > 0)
{
var attr = attrs.First();
if (attr.RType != rTy)
{
continue;
}
var index = 0;
if (MessageHandleTypes.GetTypeIndex(attrs.First().HandleType, out index))
{
_handler.Add(index, i);
}
}
}
}
private void DoHandle(Message message, Client client)
{
var handlerID = message.Flag;
Type m;
if (_handler.TryGetValue(handlerID, out m))
{
var type = MessageHandleTypes.GetTypeByIndex(handlerID);
if (type == null)
{
Debuger.Log(string.Format("TypeId:{0} no found!", handlerID));
return;
}
ISerializerable request;
int requestIndex = 0;
using (var mem = new MemoryStream(message.Content))
{
using (var br = new BinaryReader(mem))
{
requestIndex = br.ReadInt32();
request = Activator.CreateInstance(type) as Proto.ISerializerable;
request.ParseFormBinary(br);
if (NetProtoTool.EnableLog)
{
Debuger.Log(request.GetType() + "-->" + JsonTool.Serialize(request));
}
}
}
var responser = Activator.CreateInstance(m);
var NeedAccess = (bool)m.GetProperty("NeedAccess").GetValue(responser);
if (NeedAccess)
{
if (!client.HaveAdmission)
{
//直接断开
client.Server.DisConnectClient(client, 1);
return;
}
}
var begin = DateTime.Now;
ISerializerable result = null;
try
{
result = m.GetMethod("DoResponse")
.Invoke(responser, new object[] { request, client })
as ISerializerable;
}
catch (Exception ex)
{
Debuger.LogError(ex.ToString());
}
if (result == null)
{
var rem = m.GetMethod("DoResponse");
var emptyResult = Activator.CreateInstance(rem.ReturnType) as ISerializerable;
result = emptyResult;
//Debuger.LogWaring("Empty")
}
if (NetProtoTool.EnableLog)
{
var processTime = DateTime.Now - begin;
Debuger.Log(
string.Format("{1}({0}ms)-->{2}",
processTime.TotalMilliseconds,
request.GetType(),
JsonTool.Serialize(result))
);
}
var index = 0;
if (MessageHandleTypes.GetTypeIndex(result.GetType(), out index))
{
using (var mem = new MemoryStream())
{
using (var bw = new BinaryWriter(mem))
{
bw.Write(requestIndex);
result.ToBinary(bw);
}
var response = new Message(MessageClass.Response, index, mem.ToArray());
client.SendMessage(response);
}
}
}
else
{
Debuger.LogError(string.Format("TypeID:{0} no Handle!", handlerID));
}
}
