/// <summary>
/// 发送消息
/// </summary>
/// <param name="serviceID">服务号</param>
/// <param name="message">消息实体</param>
/// <returns></returns>
public LazynetService SendSharpMessage(int serviceID, string routeUrl, object[] parameters)
{
LazynetServiceMessage message = new LazynetServiceMessage(LazynetMessageType.Normal, routeUrl, parameters);
this.Context.RecvMessage(serviceID, message);
return(this);
}
public object[] CallBack(LazynetServiceMessage message)
{
var result = this.MethodInfo?.CallMethod(this.Instance, message.Parameters);
return(new object[] {
result
});
}
/// <summary>
/// 断线
/// </summary>
/// <param name="ctx"></param>
public void Inactive(LazynetChannelHandlerContext ctx)
{
var parameters = new object[] {
ctx,
ctx.Channel.RemoteAddress.ToString()
};
var serviceMessage = new LazynetServiceMessage(LazynetMessageType.Normal, ServiceContext.SocketEvent.InactiveEvent, parameters);
ServiceContext.Context.RecvMessage(ServiceContext.ID, serviceMessage);
}
private void ProcessNormalMessage(LazynetServiceMessage msg)
{
if (this.NormalTriggerDict.ContainsKey(msg.RouteUrl))
{
var trigger = this.NormalTriggerDict[msg.RouteUrl];
trigger.CallBack(msg);
}
else
{
Context.Logger.Info(this.ID.ToString(), "no mapping");
}
}
/// <summary>
/// 接收消息
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public LazynetService RecvMessage(LazynetServiceMessage message)
{
if (this.MessageQueue.Count > 100000)
{
this.Context.Logger.Info(this.ID.ToString(), "超出10万");
Thread.Sleep(100);
}
this.MessageQueue.Enqueue(message);
this.SetState(LazynetServiceState.Runing);
this.ManualEvent.Set();
return(this);
}
/// <summary>
/// 处理消息
/// </summary>
/// <param name="obj"></param>
private void ProcessMessage()
{
while (true)
{
LazynetServiceMessage messageEntity = this.GetMessage();
if (messageEntity != null)
{
//try
//{
if (messageEntity.Type == LazynetMessageType.System)
{
int result = ProcessSystemMessage(messageEntity);
if (result == 1)
{
break;
}
}
else if (messageEntity.Type == LazynetMessageType.Normal)
{
ProcessNormalMessage(messageEntity);
}
else
{
// other消息
Context.Logger.Info(this.ID.ToString(), "no type message");
}
//}
//catch (Exception ex)
//{
// Context.Logger.Info(this.ID.ToString(), ex.ToString());
//}
}
else
{
if (this.State == LazynetServiceState.Runing)
{
this.SetState(LazynetServiceState.Suspend);
this.ManualEvent.Reset();
this.ManualEvent.WaitOne();
}
}
}
}
private int ProcessSystemMessage(LazynetServiceMessage msg)
{
// 系统消息
if (msg.RouteUrl.Equals("exit"))
{
this.SetState(LazynetServiceState.Exit);
this.ExitCallback();
return(1);
}
if (this.SystemTriggerDict.ContainsKey(msg.RouteUrl))
{
var trigger = this.SystemTriggerDict[msg.RouteUrl];
trigger.CallBack(msg);
}
else
{
Context.Logger.Info(this.ID.ToString(), "no mapping");
}
return(0);
}
/// <summary>
/// 接收从service发过来的消息
/// </summary>
/// <param name="serviceID">服务id</param>
/// <param name="serviceMessage">服务消息</param>
public void RecvMessage(int serviceID, LazynetServiceMessage serviceMessage)
{
if (!this.ServiceDictionary.ContainsKey(serviceID))
{
this.Logger.Info(serviceID.ToString(), "不包含这个id");
return;
}
if (serviceMessage is null)
{
this.Logger.Info(serviceID.ToString(), "消息实体为空");
return;
}
var globaMessage = new LazynetGlobaMessage()
{
ServiceID = serviceID,
ServiceMessage = serviceMessage
};
lock (globaMessageQueueLock)
{
this.GlobaMessageQueue.Enqueue(globaMessage);
}
this.MessageEvent.Set();
}
/// <summary>
/// 调用方法
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public object[] CallBack(LazynetServiceMessage message)
{
var result = this.Function?.Call(message.Parameters);
return(result);
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="serviceID">服务号</param>
/// <param name="message">消息实体</param>
/// <returns></returns>
public LazynetService SendMessage(int serviceID, LazynetServiceMessage message)
{
this.Context.RecvMessage(serviceID, message);
return(this);
}
