Skip to content

Commit 2028e24

Browse files
AlianBlankAlianBlank
committed
[修改]1. 修改收到的消息以链表队列的方式依次回调
1 parent 954baf7 commit 2028e24

File tree

4 files changed

+82
-86
lines changed

4 files changed

+82
-86
lines changed

‎Runtime/Network/Network/NetworkManager.NetworkChannelBase.cs‎

Lines changed: 29 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -78,7 +78,8 @@ protected bool PActive
7878
private IPacketReceiveHeaderHandler m_PacketReceiveHeaderHandler;
7979
private IPacketReceiveBodyHandler m_PacketReceiveBodyHandler;
8080
private IPacketHeartBeatHandler m_PacketHeartBeatHandler;
81-
private readonly GameFrameworkLinkedList<MessageHandlerAttribute> m_ExecutionNotifyMessageLinkedList = new GameFrameworkLinkedList<MessageHandlerAttribute>();
81+
82+
protected readonly GameFrameworkLinkedList<MessageObject> m_ExecutionMessageLinkedList = new GameFrameworkLinkedList<MessageObject>();
8283

8384
public Action<NetworkChannelBase, object> NetworkChannelConnected;
8485
public Action<NetworkChannelBase> NetworkChannelClosed;
@@ -308,29 +309,49 @@ public virtual void Update(float elapseSeconds, float realElapseSeconds)
308309
}
309310

310311
ProcessHeartBeat(realElapseSeconds);
311-
ProcessInvokingNotifyMessage();
312+
ProcessReceivedMessage();
312313
PRpcState.Update(elapseSeconds, realElapseSeconds);
313314
}
314315

315316
/// <summary>
316-
/// 处理通知消息的执行
317+
///
317318
/// </summary>
318-
private void ProcessInvokingNotifyMessage()
319+
private void ProcessReceivedMessage()
319320
{
320-
while (m_ExecutionNotifyMessageLinkedList.First != null)
321+
while (m_ExecutionMessageLinkedList.First != null)
321322
{
322-
var handler = m_ExecutionNotifyMessageLinkedList.First;
323+
var messageObject = m_ExecutionMessageLinkedList.First.Value;
323324
try
324325
{
325-
handler.Value.Invoke();
326+
// 执行RPC匹配
327+
var replySuccess = PRpcState.TryReply(messageObject);
328+
if (replySuccess)
329+
{
330+
continue;
331+
}
332+
333+
// 执行通知消息
334+
var handlers = ProtoMessageHandler.GetHandlers(messageObject.GetType());
335+
foreach (var handler in handlers)
336+
{
337+
handler.SetMessageObject(messageObject);
338+
try
339+
{
340+
handler.Invoke();
341+
}
342+
catch (Exception e)
343+
{
344+
Log.Fatal(e);
345+
}
346+
}
326347
}
327348
catch (Exception e)
328349
{
329350
Log.Fatal(e);
330351
}
331352
finally
332353
{
333-
m_ExecutionNotifyMessageLinkedList.RemoveFirst();
354+
m_ExecutionMessageLinkedList.RemoveFirst();
334355
}
335356
}
336357
}
@@ -809,16 +830,6 @@ protected void DebugReceiveLog(MessageObject messageObject)
809830
#endif
810831
}
811832

812-
protected void InvokeMessageHandler(MessageObject messageObject)
813-
{
814-
var handlers = ProtoMessageHandler.GetHandlers(messageObject.GetType());
815-
foreach (var handler in handlers)
816-
{
817-
handler.SetMessageObject(messageObject);
818-
m_ExecutionNotifyMessageLinkedList.AddLast(handler);
819-
}
820-
}
821-
822833

823834
/// <summary>
824835
/// 设置忽略的消息打印列表

‎Runtime/Network/Network/NetworkManager.RpcState.cs‎

Lines changed: 49 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -17,76 +17,66 @@ public sealed partial class NetworkManager
1717
{
1818
public partial class RpcState : IDisposable
1919
{
20-
private readonly ConcurrentDictionary<long, RpcMessageData> m_HandlingObjects = new ConcurrentDictionary<long, RpcMessageData>();
21-
private readonly GameFrameworkLinkedList<MessageObject> m_ExecutionMessageLinkedList = new GameFrameworkLinkedList<MessageObject>();
22-
private readonly HashSet<long> m_HandlingObjectIds = new HashSet<long>();
23-
private EventHandler<MessageObject> m_RpcStartHandler;
24-
private EventHandler<MessageObject> m_RpcEndHandler;
25-
private EventHandler<MessageObject> m_RpcErrorHandler;
26-
private int m_rpcTimeout = 5000;
27-
private bool m_Disposed = false;
20+
/// <summary>
21+
/// 等待回复处理对象字典
22+
/// </summary>
23+
private readonly ConcurrentDictionary<long, RpcMessageData> _waitingReplyHandlingObjects = new ConcurrentDictionary<long, RpcMessageData>();
24+
25+
/// <summary>
26+
/// 删除等待中的处理器ID列表,由于超时导致的删除
27+
/// </summary>
28+
private readonly HashSet<long> _removeReplyHandlingObjectIds = new HashSet<long>();
29+
30+
private EventHandler<MessageObject> _rpcStartHandler;
31+
private EventHandler<MessageObject> _rpcEndHandler;
32+
private EventHandler<MessageObject> _rpcErrorHandler;
33+
private readonly int _rpcTimeout;
34+
private bool _disposed;
2835

2936
public RpcState(int timeout)
3037
{
31-
m_rpcTimeout = timeout;
32-
if (m_rpcTimeout < 3000)
38+
_rpcTimeout = timeout;
39+
if (_rpcTimeout < 3000)
3340
{
3441
throw new ArgumentOutOfRangeException(nameof(timeout), "RPC超时时间不能小于3000毫秒");
3542
}
3643
}
3744

3845
public void Dispose()
3946
{
40-
if (m_Disposed)
47+
if (_disposed)
4148
{
4249
return;
4350
}
4451

45-
m_HandlingObjects.Clear();
46-
m_HandlingObjectIds.Clear();
47-
m_Disposed = true;
52+
_waitingReplyHandlingObjects.Clear();
53+
_removeReplyHandlingObjectIds.Clear();
54+
_disposed = true;
4855
}
4956

57+
5058
/// <summary>
5159
/// 处理RPC回复消息。
5260
/// 此方法用于处理接收到的RPC回复消息，并触发相应的结束处理程序。
5361
/// </summary>
62+
/// <param name="message">要处理的消息对象，必须实现IResponseMessage接口。</param>
5463
/// <returns>如果成功处理回复消息，则返回true；否则返回false。</returns>
55-
private void InvokingReplyRpcMessage()
64+
public bool TryReply(MessageObject message)
5665
{
57-
while (m_ExecutionMessageLinkedList.First != null)
66+
if (message.GetType().IsImplWithInterface(typeof(IResponseMessage)))
5867
{
59-
var messageObject = m_ExecutionMessageLinkedList.First.Value;
60-
61-
if (m_HandlingObjects.TryRemove(messageObject.UniqueId, out var messageActorObject))
68+
if (_waitingReplyHandlingObjects.TryRemove(message.UniqueId, out var messageActorObject))
6269
{
6370
try
6471
{
65-
messageActorObject.Reply(messageObject as IResponseMessage);
66-
m_RpcEndHandler?.Invoke(this, messageObject);
72+
messageActorObject.Reply(message as IResponseMessage);
73+
_rpcEndHandler?.Invoke(this, message);
6774
}
6875
catch (Exception e)
6976
{
7077
Log.Fatal(e);
7178
}
72-
}
73-
m_ExecutionMessageLinkedList.RemoveFirst();
74-
}
75-
}
7679

77-
/// <summary>
78-
/// 处理RPC回复消息。
79-
/// 此方法用于处理接收到的RPC回复消息，并触发相应的结束处理程序。
80-
/// </summary>
81-
/// <param name="message">要处理的消息对象，必须实现IResponseMessage接口。</param>
82-
/// <returns>如果成功处理回复消息，则返回true；否则返回false。</returns>
83-
public bool TryReply(MessageObject message)
84-
{
85-
if (message.GetType().IsImplWithInterface(typeof(IResponseMessage)))
86-
{
87-
if (m_HandlingObjects.TryGetValue(message.UniqueId, out _))
88-
{
89-
m_ExecutionMessageLinkedList.AddLast(message);
9080
return true;
9181
}
9282
}
@@ -103,16 +93,16 @@ public bool TryReply(MessageObject message)
10393
/// <returns>返回一个任务，该任务在收到响应时完成，并返回IResponseMessage。</returns>
10494
public Task<IResponseMessage> Call(MessageObject messageObject)
10595
{
106-
if (m_HandlingObjects.TryGetValue(messageObject.UniqueId, out var messageActorObject))
96+
if (_waitingReplyHandlingObjects.TryGetValue(messageObject.UniqueId, out var messageActorObject))
10797
{
10898
return messageActorObject.Task;
10999
}
110100

111-
var defaultMessageActorObject = RpcMessageData.Create(messageObject as IRequestMessage);
112-
m_HandlingObjects.TryAdd(messageObject.UniqueId, defaultMessageActorObject);
101+
var defaultMessageActorObject = RpcMessageData.Create(messageObject as IRequestMessage, _rpcTimeout);
102+
_waitingReplyHandlingObjects.TryAdd(messageObject.UniqueId, defaultMessageActorObject);
113103
try
114104
{
115-
m_RpcStartHandler?.Invoke(this, messageObject);
105+
_rpcStartHandler?.Invoke(this, messageObject);
116106
}
117107
catch (Exception e)
118108
{
@@ -122,23 +112,26 @@ public Task<IResponseMessage> Call(MessageObject messageObject)
122112
return defaultMessageActorObject.Task;
123113
}
124114

115+
/// <summary>
116+
/// 逻辑更新，处理计时和超时移除任务
117+
/// </summary>
118+
/// <param name="elapseSeconds"></param>
119+
/// <param name="realElapseSeconds"></param>
125120
public void Update(float elapseSeconds, float realElapseSeconds)
126121
{
127-
InvokingReplyRpcMessage();
128-
129-
if (m_HandlingObjects.Count > 0)
122+
if (_waitingReplyHandlingObjects.Count > 0)
130123
{
131124
var elapseSecondsTime = (long)(elapseSeconds * 1000);
132-
m_HandlingObjectIds.Clear();
133-
foreach (var handlingObject in m_HandlingObjects)
125+
_removeReplyHandlingObjectIds.Clear();
126+
foreach (var handlingObject in _waitingReplyHandlingObjects)
134127
{
135128
bool isTimeout = handlingObject.Value.IncrementalElapseTime(elapseSecondsTime);
136129
if (isTimeout)
137130
{
138-
m_HandlingObjectIds.Add(handlingObject.Key);
131+
_removeReplyHandlingObjectIds.Add(handlingObject.Key);
139132
try
140133
{
141-
m_RpcErrorHandler?.Invoke(this, handlingObject.Value.RequestMessage as MessageObject);
134+
_rpcErrorHandler?.Invoke(this, handlingObject.Value.RequestMessage as MessageObject);
142135
}
143136
catch (Exception e)
144137
{
@@ -148,14 +141,14 @@ public void Update(float elapseSeconds, float realElapseSeconds)
148141
}
149142
}
150143

151-
if (m_HandlingObjectIds.Count > 0)
144+
if (_removeReplyHandlingObjectIds.Count > 0)
152145
{
153-
foreach (var objectId in m_HandlingObjectIds)
146+
foreach (var objectId in _removeReplyHandlingObjectIds)
154147
{
155-
m_HandlingObjects.TryRemove(objectId, out _);
148+
_waitingReplyHandlingObjects.TryRemove(objectId, out _);
156149
}
157150

158-
m_HandlingObjectIds.Clear();
151+
_removeReplyHandlingObjectIds.Clear();
159152
}
160153
}
161154

@@ -167,7 +160,7 @@ public void Update(float elapseSeconds, float realElapseSeconds)
167160
public void SetRPCErrorHandler(EventHandler<MessageObject> handler)
168161
{
169162
GameFrameworkGuard.NotNull(handler, nameof(handler));
170-
m_RpcErrorHandler = handler;
163+
_rpcErrorHandler = handler;
171164
}
172165

173166
/// <summary>
@@ -178,7 +171,7 @@ public void SetRPCErrorHandler(EventHandler<MessageObject> handler)
178171
public void SetRPCStartHandler(EventHandler<MessageObject> handler)
179172
{
180173
GameFrameworkGuard.NotNull(handler, nameof(handler));
181-
m_RpcStartHandler = handler;
174+
_rpcStartHandler = handler;
182175
}
183176

184177
/// <summary>
@@ -189,7 +182,7 @@ public void SetRPCStartHandler(EventHandler<MessageObject> handler)
189182
public void SetRPCEndHandler(EventHandler<MessageObject> handler)
190183
{
191184
GameFrameworkGuard.NotNull(handler, nameof(handler));
192-
m_RpcEndHandler = handler;
185+
_rpcEndHandler = handler;
193186
}
194187
}
195188
}

‎Runtime/Network/Network/SystemSocket/NetworkManager.SystemTcpNetworkChannel.cs‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -212,12 +212,8 @@ private bool ProcessPackBody()
212212
}
213213

214214
DebugReceiveLog(messageObject);
215-
216-
var replySuccess = PRpcState.TryReply(messageObject);
217-
if (!replySuccess)
218-
{
219-
InvokeMessageHandler(messageObject);
220-
}
215+
// 将收到的消息加入到链表最后
216+
m_ExecutionMessageLinkedList.AddLast(messageObject);
221217

222218
PReceivedPacketCount++;
223219
PReceiveState.PrepareForPacketHeader();

‎Runtime/Network/Network/WebSocket/NetworkManager.WebSocketNetworkChannel.cs‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -96,7 +96,6 @@ protected override bool ProcessSend()
9696
while (PSendPacketPool.First != null)
9797
{
9898
var messageObject = PSendPacketPool.First.Value;
99-
10099

101100
bool serializeResult;
102101
try
@@ -298,11 +297,8 @@ private void ReceiveCallback(byte[] buffer)
298297
}
299298
}
300299

301-
var replySuccess = PRpcState.TryReply(messageObject);
302-
if (!replySuccess)
303-
{
304-
InvokeMessageHandler(messageObject);
305-
}
300+
// 将收到的消息加入到链表最后
301+
m_ExecutionMessageLinkedList.AddLast(messageObject);
306302

307303
PReceivedPacketCount++;
308304
}

0 commit comments

Comments
 (0)