static List<MsgData> GetNextMsgs(SQLiteConnection sqlCnn, long msgId)
{
var listResult = new List<MsgData>();
using (
var reader = DbUtil.ExecuteSql(sqlCnn,
"select MessageId, PlainMsg, HtmlMsg from Message where MessageId > @MsgId order by MessageId limit 100",
new[]
{
DbUtil.BuildParameter("@MsgId", DbType.Int64, msgId)
}))
{
while (reader.Read())
{
var data = new MsgData
{
MsgId = reader.GetInt64(0),
PlainMsg = reader.GetString(1),
HtmlMsg = reader.GetString(2)
};
if (!string.IsNullOrEmpty(data.HtmlMsg))
{
data.PlainMsg = RemoveHtmlTags(data.HtmlMsg);
}
listResult.Add(data);
}
}
return listResult;
}
public void HasRecv(MsgData obj)
{
lock (msg_obj)
{
msgs.Add(obj);
}
}
//消息流转
protected bool _TransitMsg(MsgData msgData)
{
bool success = false;
switch (msgData.mode)
{
case EnumXMsgMode.Normal:
if (_children.Count > 0)
{
foreach (var child in _children)
{
child.SendMsg(msgData.msg, msgData.mode);
}
success = true;
}
break;
case EnumXMsgMode.Reverse:
if (_parent != null)
{
_parent.SendMsg(msgData.msg, msgData.mode);
success = true;
}
break;
}
return(success);
}
public void Dispatch(int msgId, byte[] data)
{
lock (locker)
{
List <MsgData> value;
if (msgDict.TryGetValue(msgId, out value))
{
for (int i = value.Count - 1; i >= 0; i--)
{
if (!value[i].Action.Target.Equals(null))
{
MsgData queueMsg = Pool <MsgData> .Instance.Allocate();
queueMsg.Action = value[i].Action;
queueMsg.data = data;
msgQueue.Enqueue(queueMsg);
}
else
{
value.Remove(value[i]);
Pool <MsgData> .Instance.Recycle(value[i]);
}
}
}
else
{
Debug.LogError("消息ID:" + msgId + "未注册");
}
}
}
public void Regist(int msgId, Action <byte[]> action)
{
lock (locker)
{
if (action == null)
{
return;
}
List <MsgData> value;
if (!msgDict.TryGetValue(msgId, out value))
{
value = new List <MsgData>();
msgDict.Add(msgId, value);
}
foreach (var item in value)
{
if (item.Action == action)
{
Debug.LogWarning("重复注册!");
return;
}
}
MsgData msg = Pool <MsgData> .Instance.Allocate();
msg.Action = action;
value.Add(msg);
}
}
public void showmsg(TextBox tb)
{
if (list_msgdat.Count == 0 || tb == null)
{
return;
}
while (list_msgdat.Count > 0)
{
MsgData msg = list_msgdat.First();
if ((msg.msg_type & MsgCfg) != 0)
{
tb.AppendText(msg.ToString() + "\r\n");
}
if (((int)msg.msg_type & ((int)MsgCfg) >> 8) != 0)
{
SaveMsg(msg.ToString());
}
if (tb.Lines.Count() > MsgMaxLine / 2)
{
List <string> str_list = tb.Lines.ToList();
str_list.RemoveAt(0);
tb.Lines = str_list.ToArray();
}
tb.SelectionStart = tb.Text.Length;
tb.ScrollToCaret();
lock (LockObj)
{
list_msgdat.RemoveFirst();
}
}
}
public Player CreateRon(Vector3 pos, Quaternion rot, bool male = true, string name = "")
{
int modelIdx = male ? 0 : 1;
if (name == "")
{
name = RandomName(male);
}
ForceUniqueName(ref name);
// create player
GameObject go = GameObject.Instantiate(Resources.Load("Avatars/ron")) as GameObject;
MsgData userInitData = new MsgData();
userInitData.name = name;
userInitData.playerID = UnityEngine.Random.Range(0, 8);
User user = new ReplayUser(userInitData);
Player bot = new Player(user, go, modelIdx, PlayerType.STEALTH, "", userInitData.name, 0);
bot.isBot = true;
// assign transform
bot.gameObject.transform.position = pos;
bot.gameObject.transform.rotation = rot;
bot.gameObject.GetComponent <PlayerController>().forwardAngle = rot.eulerAngles.y;
// make visible and kill bouncing
bot.gameObject.SetActive(true);
localBots.Add(name, bot);
return(bot);
}
/// <summary>
/// 向client发送消息
/// </summary>
/// <param name="msg"></param>
public virtual void Send(MsgData msg)
{
if (this.SendCall != null)
{
this.SendCall(msg, this);
}
}
public async Task OnlyPostSupportedMsgDataPckControllerReturnsResponceTrue()
{
var hubProxyFactoryMock = new Mock <IHubProxyFactory>();
var iHubProxyMock = new Mock <IHubProxy>();
var tcs = new TaskCompletionSource <IHubProxy>();
tcs.SetResult(iHubProxyMock.Object);
var tcsProxy = new TaskCompletionSource <ReceiveResponce>();
tcsProxy.SetResult(new ReceiveResponce(true));
iHubProxyMock.Setup(set => set.Invoke <ReceiveResponce>(It.IsAny <string>(), It.IsAny <object[]>())).Returns(tcsProxy.Task);
hubProxyFactoryMock.Setup(set => set.Create(It.IsAny <string>(), It.IsAny <string>())).Returns(tcs.Task);
var msgHubClient = new MsgHubClientProxy(hubProxyFactoryMock.Object, "test");
await msgHubClient.StartClientProxy().ConfigureAwait(false);
var msgdata = new MsgData();
var msg = new MsgDataPckController(msgdata);
var postResult = await msgHubClient.Post <MsgDataPckController>(msg).ConfigureAwait(false);
Assert.IsTrue(postResult.MsgProcessed);
}
private void PlayLastRoomVariableChanges(int startMsgIdx, int endMsgIdx)
{
if (startMsgIdx > endMsgIdx)
{
Debug.LogError("PlayLastRoomVariableChanges: startIdx shouldn\'t be greater than endIdx");
return;
}
HashSet <string> handledVars = new HashSet <string>();
for (int i = endMsgIdx; i >= startMsgIdx; --i)
{
MsgData msg = messagesToPlay[i];
if (msg.msgType == SFSEvent.ROOM_VARIABLES_UPDATE)
{
for (int varcount = 0; varcount < msg.changedVars.Count; ++varcount)
{
if (!handledVars.Contains(msg.changedVars[varcount].Name))
{
HandleRoomVariableUpdate(msg.changedVars[varcount]);
handledVars.Add(msg.changedVars[varcount].Name);
}
}
}
}
}
private void PlayUserEnterExitMessages(int startMsgIdx, int endMsgIdx)
{
if (startMsgIdx > endMsgIdx)
{
Debug.LogError("PlayUserEnterExitMessages: startIdx shouldn\'t be greater than endIdx");
return;
}
for (int i = startMsgIdx; i < endMsgIdx; ++i)
{
MsgData msg = messagesToPlay[i];
if (msg.msgType == SFSEvent.USER_ENTER_ROOM || msg.msgType == SFSEvent.USER_EXIT_ROOM)
{
PlayBackMsg(msg);
}
else if (msg.msgType == SFSEvent.USER_VARIABLES_UPDATE)
{
bool msgPlayed = false;
for (int j = 0; !msgPlayed && j < msg.changedVars.Count; ++j)
{
if (msg.changedVars[j].Name == "op" || msg.changedVars[j].Name == "displayName")
{
PlayBackMsg(msg);
msgPlayed = true;
}
}
}
}
}
private void ExecCall(CmdMethodInfo cmdMethodInfo, TcpSocketAsync client, MsgData msg)
{
var session = client.UserState as Session;
this.OnCmdExecutingEvent(session, msg);
if (cmdMethodInfo != null && client != null)
{
ActionResult result = null;
using (var controller = Activator.CreateInstance(cmdMethodInfo.Type) as Controller)
{
try
{
controller.Init(session, msg);
if (this.OnAuth(cmdMethodInfo, session, msg, out result))
{
controller.OnExecuting();
result = cmdMethodInfo.Method.Invoke(controller, null) as ActionResult;
controller.OnResult(result);
this.OnCmdExecutedEvent(session, msg, result.Result);
}
}
catch (Exception ex)
{
bool ishand = false;
try
{
ExceptionContext excontext = new ExceptionContext()
{
Msg = msg, IsHandle = false, Exception = ex
};
controller.OnException(excontext);
ishand = excontext.IsHandle;
result = excontext.Result;
}
catch (Exception _ex)
{
this.OnMvcHostServerErrorEvent(_ex);
}
if (!ishand)
{
this.OnMvcHostServerErrorEvent(ex);
}
if (result == null)
{
result = new ActionResult();
result.SetMsg(MsgStatus.ServerError, "服务器发生错误！");
}
}
}
if (result != null && client.IsConnected)
{
result.Result.Cmd = msg.Cmd;
result.Result.Id = msg.Id;
this.SendMsg(result.Result, session);
}
}
}
void Import(string file, string password = null)
{
var exportResult = WalletService.Default.ImportBackupWallet(file, password);
if (!exportResult.IsFail)
{
//ShowMessage(LanguageService.Default.GetLanguageValue(MessageKeys.Import_sucesses));
MessagePageData data = new MessagePageData();
data.PageTitle = LanguageService.Default.GetLanguageValue(MessageKeys.Import_sucesses);
MsgData iconData = new MsgData("path_msg_warming", Colors.Red);
data.IconData = iconData;
data.MsgItems.Add(new MsgData(LanguageService.Default.GetLanguageValue("Import_caption1"), Colors.Red));
data.MsgItems.Add(new MsgData(LanguageService.Default.GetLanguageValue("Import_caption2"), "#333333"));
data.MsgBtnShowType = MsgBtnType.Ok;
data.CloseIsWord = true;
data.CloseWord = "";
data.SetOkCallBack(RestartApp);
SendMessenger(Pages.MessagePage, data);
UpdatePage(Pages.MessagePage);
}
else
{
ShowMessage(LanguageService.Default.GetLanguageValue(MessageKeys.Import_Fail));
OnClosePopup();
}
}
private void OnClientReceive(TcpSocketAsync client, byte[] data, int length)
{
byte[] buffer = this.OnDecrypt(data);
MsgData msg = MsgData.Deserialize(buffer);
if (msg != null)
{
try
{
if (cmdCallbackDic.ContainsKey(msg.Cmd))
{
var callModel = cmdCallbackDic[msg.Cmd];
this.ExecCall(callModel, client, msg);
return;
}
else
{
msg.Rest();
msg.Status = MsgStatus.Unknown;
this.SendMsg(msg, client.UserState as Session);
return;
}
}
catch (Exception ex)
{
this.OnMvcHostServerErrorEvent(ex);
}
}
else
{
this.OnMvcHostServerErrorEvent(new Exception(string.Format("client({0}): msg is null!", client.RemoteEndPoint.ToString())));
}
}
// Update is called once per frame
private void Update()
{
_timeSinceLastPub += Time.deltaTime;
if (_timeSinceLastPub >= 1 / ZmqPubRate)
{
var pubMsg = new Msg();
var position = _hip.position;
var velocity = _hip.velocity;
var msgData = new MsgData
{
Position = new[] { position.x, position.y, position.z },
Velocity = new[] { velocity.x, velocity.y, velocity.z },
ID = id
};
var pubMsgPayload = Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(msgData));
pubMsg.InitGC(pubMsgPayload, pubMsgPayload.Length);
_pub.Send(ref pubMsg, false);
_timeSinceLastPub = 0;
}
string recvStr;
if (_sub.TryReceiveFrameString(out recvStr))
{
Debug.Log(recvStr);
}
}
private void client_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
{
this.BeginInvoke((MethodInvoker) delegate
{
lblProgress.Text = LanguageHelper.GetValueOf("UPDATE_LBL_PROGRESS");
lblContent.Text = LanguageHelper.GetValueOf("UPDATE_LBL_CONTENT_DOWNLOADED");
lblInfo.Visible = false;
var dataMsg = new MsgData
{
KeyCheck = "UPDATE",
Title = LanguageHelper.GetValueOf("UPDATE_TITLE_SENDER"),
Message = LanguageHelper.GetValueOf("UPDATE_MESSAGE_SENDER"),
};
if (e.Error == null)
{
clsCommon.ShowMsg(MessageBoxIcon.Information, "UPDATE_MESSAGEBOX_MSG", "Message");
this.Hide();
this.Close();
var parentForm = this.FormParent as MainForm;
parentForm.IsStop = true;
parentForm.MainForm_FormClosed(dataMsg, null);
}
});
}
protected override void TakeRemote()
{
var session = paramGetter.GetSession();
if (session == null)
{
ErrorCode = 10000;
ErrorInfo = "Sessin is null.";
return;
}
switch (_type)
{
case NoticeMode.AllService:
{
var sessionlist = GameSession.GetAll();
foreach (var on in sessionlist)
{
if (on.Connected && !on.IsRemote)
{
MsgData data = new MsgData();
data.Type = MsgType.Notice;
data.UserId = on.UserId;
var parameters = new Parameters();
parameters["Type"] = NoticeMode.AllService;
parameters["ServerID"] = _serverID;
parameters["Content"] = _content;
data.Param = parameters;
MsgDispatcher.Push(data);
}
}
}
break;
case NoticeMode.World:
{
var cache = new MemoryCacheStruct <ChatUser>();
var list = cache.FindAll(t => t.ServerID == _serverID);
foreach (var v in list)
{
var sess = GameSession.Get(v.UserId);
if (sess != null && sess.Connected && !sess.IsRemote)
{
MsgData data = new MsgData();
data.Type = MsgType.Notice;
data.UserId = sess.UserId;
var parameters = new Parameters();
parameters["Type"] = NoticeMode.World;
parameters["ServerID"] = _serverID;
parameters["Content"] = _content;
data.Param = parameters;
MsgDispatcher.Push(data);
}
}
}
break;
}
}
void PlayBackMsg(MsgData msg)
{
//Debug.LogError("time: " + DateTime.FromBinary(msg.time).ToString() + " id:" + msg.id + " name: " + msg.name + " msgType: " + msg.msgType);
bool validPlayer = IsValidPlayer(msg.name);
if (msg.msgType == SFSEvent.OBJECT_MESSAGE && msg.msg != null && validPlayer)
{
GetPlayer(ref msg); // hack to get the mouse colors to show up - problem when jumping in the timeline over the enter message.
DataMessageManager.Inst.HandleObjectMessage(msg.id, SFSObject.NewFromBinaryData(new ByteArray(msg.msg)));
}
else if (msg.msgType == SFSEvent.USER_VARIABLES_UPDATE && validPlayer)
{
HandleUserVariableUpdate(ref msg);
}
else if (msg.msgType == SFSEvent.ROOM_VARIABLES_UPDATE)
{
HandleRoomVariableUpdate(ref msg);
}
else if (validPlayer && (msg.msgType == SFSEvent.PUBLIC_MESSAGE || msg.msgType == SFSEvent.PRIVATE_MESSAGE || msg.msgType == SFSEvent.ADMIN_MESSAGE))
{
HandleChatMessages(ref msg);
}
else if (validPlayer && (msg.msgType == SFSEvent.USER_ENTER_ROOM || msg.msgType == SFSEvent.USER_EXIT_ROOM))
{
HandleUserEnterExit(ref msg);
}
//else
// Debug.LogError("PlayBackMsg Unsupported type: " + msg.msgType);
}
public void RpcDie(int killerId)
{
var data = new DieData();
data.Victim = name;
data.IsVictim = photonView.IsMine;
var view = PhotonView.Find(killerId);
data.Killer = view.name;
data.IsKiller = view.Owner == PhotonNetwork.LocalPlayer;
var msg = new MsgData()
{
Type = GameConst.MsgDie, Data = data
};
if (data.IsVictim)
{
Observable.Timer(System.TimeSpan.FromSeconds(3)).Subscribe(_ => PhotonNetwork.Destroy(gameObject)).AddTo(this);
}
else
{
_message.Publish(msg);
}
MessageBroker.Default.Publish(msg);
}
void HandleRoomVariableUpdate(ref MsgData msg)
{
for (int i = 0; i < msg.changedVars.Count; ++i)
{
HandleRoomVariableUpdate(msg.changedVars[i]);
}
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="msg"></param>
public void SendMessage(string toUser, string msg)
{
Jid to = new Jid(BuildJid(toUser));
//to.Resource = "mobile";
Jid from = new Jid(BuildJid(UserName));
BodyBase[] bodies = new BodyBase[1];
bodies[0] = new TextBody {
type = "txt", msg = msg
};
/*
* 发消息：
* {"from":"weigang75","to":"march3","bodies":[{"type":"txt","msg":"?"}],"ext":{}};*/
MsgData data = new MsgData()
{
from = UserName, to = toUser, bodies = bodies, ext = new { }
};
string msgjson = JsonConvert.SerializeObject(data);
Message msgNode = new Message(to, from, msgjson);
msgNode.GenerateId();
//msgNode.Thread = string.Concat("MSG_", (new Random()).Next(20000, 30000));
msgNode.Type = MessageType.chat;
Send(msgNode);
}
void HandleUserVariableUpdate(ref MsgData msg)
{
Player player = GetPlayer(ref msg);
Vector3 newPos = Vector3.zero;
float newRotAngle = 0;
int transformMsgCount = 0;
for (int i = 0; i < msg.changedVars.Count; ++i)
{
UserVariable userVar = msg.changedVars[i];
if (userVar.Name == "playerModel")
{
Debug.LogError("Replay: Changed playerModel");
}
else if (userVar.Name == "x" || userVar.Name == "y" || userVar.Name == "z" || userVar.Name == "rot")
{
UpdateTransformVars(userVar, ref newRotAngle, ref newPos);
transformMsgCount++;
if (transformMsgCount == 4)
{
bool rotChanged = newRotAngle != player.gameObject.transform.rotation.eulerAngles.y;
player.UpdateTransform(newPos, newRotAngle);
if (rotChanged)
{
player.playerController.shuffleTime = 0.25f;
}
}
}
else
{
player.UpdateUserVar(userVar, true);
}
}
}
public void SendMsg(MsgData msgData)
{
lock (sendMsgQueue)
{
sendMsgQueue.Enqueue(msgData);
}
}
void HandleUserEnterExit(ref MsgData msg) // const ref
{
bool entered = (msg.msgType == SFSEvent.USER_ENTER_ROOM);
Debug.LogError("\tuser " + msg.id + " - " + msg.name + ((entered) ? " entered" : " left"));
if (entered)
{
Player replayPlayer = null;
if (!replayPlayers.TryGetValue(msg.id, out replayPlayer))
{
// Create replay player
User user = new ReplayUser(msg);
PlayerInit pInit = PlayerManager.InitPlayerVariablesFromUserVariables(msg.changedVars);
GameObject go = GameManager.Inst.playerManager.CreateRemotePlayerGO(pInit.modelIndex);
replayPlayer = new Player(user, go, pInit);
replayPlayers[msg.id] = replayPlayer;
}
replayPlayer.Visible = true;
HandleUserVariableUpdate(ref msg);
}
else
{
Player p = GetPlayer(ref msg);
p.Visible = false;
//replayPlayers.Remove(msg.id);
}
Debug.LogError("HandleUserEnterExit complete");
}
// Update is called once per frame
private void Update()
{
_timeSinceLastPub += Time.deltaTime;
if (_timeSinceLastPub >= 1 / ZmqPubRate)
{
var pubMsg = new Msg();
var position = _hip.position;
var velocity = _hip.velocity;
var msgData = new MsgData
{
Position = new[] { position.x, position.y, position.z },
Velocity = new[] { velocity.x, velocity.y, velocity.z },
ID = id
};
var pubMsgPayload = Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(msgData));
pubMsg.InitGC(pubMsgPayload, pubMsgPayload.Length);
_pub.Send(ref pubMsg, false);
_timeSinceLastPub = 0;
}
//string recvStr;
if (_sub.TryReceiveFrameString(out recvStr))
{
Debug.Log(recvStr);
var recvJson = JsonConvert.DeserializeObject <Dictionary <string, string> >(recvStr);
//if (int.Parse(recvJson["ID"]) != id) return;
var forceX = float.Parse(recvJson["force_x"]);
var forceY = float.Parse(recvJson["force_y"]);
var forceZ = float.Parse(recvJson["force_z"]);
_hip.AddRelativeForce(forceX, forceY, -(forceZ * 2)); //negative z because conversion from right-hand to left-hand coordinates
}
}
void Awake()
{
name = photonView.Owner.NickName;
MessageBroker.Default.Receive <ResData>().Subscribe(x =>
{
if (GameConst.ResPlayerRemote == x.Type && x.Data != null && !photonView.IsMine && _remote == null)
{
var asset = x.Data.LoadAsset("RemotePlayer");
asset.SetParent(transform, false);
_message = new MessageBroker();
_remote = asset.GetComponent <RemotePlayer>();
_remote.Setup(_message, transform.position, transform.rotation);
}
if (GameConst.ResPlayerLocal == x.Type && x.Data != null && photonView.IsMine && _local == null)
{
var asset = x.Data.LoadAsset("LocalPlayer");
asset.SetParent(transform, false);
Setup(asset);
}
}).AddTo(this);
var msg = new MsgData()
{
Type = GameConst.MsgEnterGame, Data = photonView.IsMine
};
MessageBroker.Default.Publish(msg);
}
public async Task MsgControllerGetAdmin()
{
var data = new MsgApiDataHandler();
var model = MsgData.GetFirst();
data.Result.Setup(m => m.Execute(It.IsAny <Loader <Msg> >())).Returns(model);
var controller = new MsgController(data, Cloud, Logic)
{
CurrentUser = AdminUser
};
var result = await controller.Get(MsgData.FirstId) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
var viewModel = result.Value as MsgViewModel;
viewModel.Id.Should().Be(model.Id);
viewModel.Name.Should().Be(model.Name);
viewModel.Text.Should().Be(model.Text);
data.HasExecuted.Should().BeTrue();
data.Result.Verify(s => s.Execute(It.IsAny <Loader <Msg> >()), Times.Once());
}
public int DispatchEvent(MsgData data)
{
int iRet = 0;
if (eventTable.ContainsKey(data.Cmd))
{
List <EventHandleMsg> evtList = eventTable[data.Cmd];
List <EventHandleMsg> clone = new List <EventHandleMsg>(evtList);
for (int i = 0; i < clone.Count; i++)
{
EventHandleMsg hd = clone[i];
if (null != hd)
{
hd(data);
}
}
}
if (key2PackageRegistry.ContainsKey(data.Cmd))
{
//如果是关键包，记录后待删除
RecordReceiveCMD(data.Cmd);
Pop(data.Cmd);
}
//通知停止锁屏
bool canUnlock = _lockManager.RemovePackageCmd(data.Cmd);
if (canUnlock)
{
EventManager.Send(EventType_Net.EVENT_UNLOCK_SCREEN);
}
return(iRet);
}
/// <summary>
/// Invio risposta a messaggi aventi messagedata di tipo <typeparamref name="MsgData"/>
/// </summary>
/// <param name="receivedMsg">Messaggio a cui viene inviata risposta</param>
/// <param name="MsgCode">Codice messaggio di risposta</param>
/// <param name="MessageData">Dato da inviare (contiene Validation)</param>
/// <param name="Result">Risultato dell'operazione richiesta</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool SendResponse(IIncomingMessage receivedMsg, MsgCodes MsgCode, MsgData MessageData, bool Result)
{
bool bOK = true;
var message = mdsClient.CreateMessage();
// Set message data
MessageData.MsgCode = MsgCode;
MessageData.validation = Result;
// Set message params
message.MessageData = GeneralHelper.SerializeObject(MessageData);
message.DestinationApplicationName = receivedMsg.SourceApplicationName;
message.TransmitRule = MessageTransmitRules.NonPersistent;
try
{
//Send message
message.Send();
Logger.InfoFormat("Inviato msg a {0}", message.DestinationApplicationName);
}
catch (Exception exc)
{
// non sono riuscito a inviare il messaggio
Logger.WarnFormat("Messaggio non inviato - {0}", exc.Message);
bOK = false;
}
return(bOK);
}
public virtual async Task <bool> Evaluate(MsgData message)
{
bool b = message.Message.ToLower().Contains(command.ToLower());
await Task.CompletedTask;
return(b);
}
static void Main(string[] args)
{
Counter counter1 = new Counter();
Counter counter2 = new Counter();
Dispatcher.Instance.Register("counter1", counter1);
Dispatcher.Instance.Register("counter2", counter2);
for (int i = 0; i < 10000; i++)
{
MsgData data1 = new MsgData(i.ToString());
Dispatcher.Instance.Send(data1, "counter2");
}
for (int i = 0; i < 10000; i++)
{
MsgData data2 = new MsgData("=========");
Dispatcher.Instance.Send(data2, "counter1");
}
MsgData data = new MsgData("stop");
Dispatcher.Instance.Send(data, "counter1");
Dispatcher.Instance.Send(data, "counter2");
Console.ReadLine();
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
if (syncContext == null) return nextSink.AsyncProcessMessage (msg, replySink);
MsgData md = new MsgData ();
md.InMessage = msg;
md.ReplySink = replySink;
syncContext.AsyncDispatch (new StatefulMessageHandler (AsyncDispatchMessage), md);
return null;
}
public IMessage SyncProcessMessage (IMessage msg)
{
if (syncContext == null) return nextSink.SyncProcessMessage (msg);
IMethodMessage mm = (IMethodMessage)msg;
if ((mm.MethodBase.Name == "FieldGetter" || mm.MethodBase.Name == "FieldSetter") && mm.MethodBase.DeclaringType == typeof(object)) {
return nextSink.SyncProcessMessage (msg);
}
MethodBase mb = GetRealMethod (mm);
if (mb.IsDefined (typeof(FreeDispatchAttribute), true)) {
return nextSink.SyncProcessMessage (msg);
}
if (mb.IsDefined (typeof(AsyncDispatchAttribute), true)) {
AsyncProcessMessage (msg, DummySink.Instance);
return new ReturnMessage (null, null, 0, null, (IMethodCallMessage)mm);
}
MsgData md = new MsgData ();
md.InMessage = msg;
SyncContext oldCtx = SyncContext.GetContext ();
try {
SyncContext.SetContext (syncContext);
syncContext.Dispatch (new StatefulMessageHandler (DispatchMessage), md);
} finally {
SyncContext.SetContext (oldCtx);
}
return md.OutMessage;
}
public IMessageCtrl AsyncProcessMessage (IMessage msg, IMessageSink replySink)
{
if (syncContext == null) return nextSink.AsyncProcessMessage (msg, replySink);
// Make a copy of the message since MS.NET seems to free the original message
// once it has been dispatched.
if (!isMono)
msg = new MethodCall (msg);
MsgData md = new MsgData ();
md.InMessage = msg;
md.ReplySink = replySink;
syncContext.AsyncDispatch (new StatefulMessageHandler (AsyncDispatchMessage), md);
return null;
}
