feat(网络): 为RPC调用添加忽略错误码选项

在INetworkChannel接口和实现中新增isIgnoreErrorCode参数，用于控制是否忽略RPC调用的错误码。当设置为true时，不会抛出异常且会忽略错误码回调。

Author: AlianBlank

Runtime/Network/Interface/INetworkChannel.cs

@@ -235,9 +235,9 @@ public interface INetworkChannel
         /// <summary>
         /// 向远程主机发送消息包
         /// </summary>
-        /// <param name="messageObject"></param>
-        /// <typeparam name="T">发送的消息类型</typeparam>
-        /// <typeparam name="TResult">返回的消息类型</typeparam>
-        Task<TResult> Call<TResult>(MessageObject messageObject) where TResult : MessageObject, IResponseMessage;
+        /// <param name="messageObject">要发送的消息包。</param>
+        /// <param name="isIgnoreErrorCode">是否忽略错误码，默认值为 false。如果为 true，则在调用时不会抛出异常。和RPC的错误码回调也会忽略错误码。</param>
+        /// <typeparam name="TResult"></typeparam>
+        Task<TResult> Call<TResult>(MessageObject messageObject, bool isIgnoreErrorCode = false) where TResult : MessageObject, IResponseMessage;
     }
 }

Runtime/Network/Network/NetworkManager.NetworkChannelBase.cs

@@ -758,14 +758,15 @@ public virtual void Close(string reason, ushort code = 0)
             /// <summary>
             /// 向远程主机发送消息包
             /// </summary>
-            /// <param name="messageObject"></param>
+            /// <param name="messageObject">要发送的消息包。</param>
+            /// <param name="isIgnoreErrorCode">是否忽略错误码，默认值为 false。如果为 true，则在调用时不会抛出异常。和RPC的错误码回调也会忽略错误码。</param>
             /// <typeparam name="TResult"></typeparam>
             [UnityEngine.Scripting.Preserve]
-            public async Task<TResult> Call<TResult>(MessageObject messageObject) where TResult : MessageObject, IResponseMessage
+            public async Task<TResult> Call<TResult>(MessageObject messageObject, bool isIgnoreErrorCode = false) where TResult : MessageObject, IResponseMessage
             {
                 GameFrameworkGuard.NotNull(messageObject, nameof(messageObject));
                 Send(messageObject);
-                var result = await PRpcState.Call(messageObject);
+                var result = await PRpcState.Call(messageObject, isIgnoreErrorCode);
                 return result as TResult;
             }
 

Runtime/Network/Network/NetworkManager.RpcState.RpcMessageData.cs

@@ -26,6 +26,11 @@ internal sealed class RpcMessageData : IDisposable
                 /// </summary>
                 public long ElapseTime { get; private set; }
 
+                /// <summary>
+                /// 是否忽略错误码
+                /// </summary>
+                public bool IsIgnoreErrorCode { get; private set; }
+
                 /// <summary>
                 /// 请求消息
                 /// </summary>
@@ -73,23 +78,26 @@ internal bool IncrementalElapseTime(long time)
                 /// </summary>
                 /// <param name="actorRequestMessage"></param>
                 /// <param name="timeout"></param>
+                /// <param name="isIgnoreErrorCode"></param>
                 /// <returns></returns>
                 [UnityEngine.Scripting.Preserve]
-                internal static RpcMessageData Create(IRequestMessage actorRequestMessage, int timeout = 5000)
+                internal static RpcMessageData Create(IRequestMessage actorRequestMessage, int timeout = 5000, bool isIgnoreErrorCode = false)
                 {
-                    var defaultMessageActorObject = new RpcMessageData(actorRequestMessage, timeout);
+                    var defaultMessageActorObject = new RpcMessageData(actorRequestMessage, timeout, isIgnoreErrorCode);
                     return defaultMessageActorObject;
                 }
 
-                private RpcMessageData(IRequestMessage requestMessage, int timeout)
+                private RpcMessageData(IRequestMessage requestMessage, int timeout, bool isIgnoreErrorCode)
                 {
                     CreatedTime = TimerHelper.UnixTimeMilliseconds();
                     RequestMessage = requestMessage;
                     Timeout = timeout;
+                    IsIgnoreErrorCode = isIgnoreErrorCode;
                     UniqueId = ((MessageObject)requestMessage).UniqueId;
                     m_Tcs = new TaskCompletionSource<IResponseMessage>();
                 }
 
+
                 private readonly TaskCompletionSource<IResponseMessage> m_Tcs;
 
                 public Task<IResponseMessage> Task

Runtime/Network/Network/NetworkManager.RpcState.cs

@@ -97,7 +97,7 @@ public bool TryReply(MessageObject message)
                             var responseMessage = message as IResponseMessage;
                             messageActorObject.Reply(responseMessage);
                             _rpcEndHandler?.Invoke(this, message);
-                            if (responseMessage?.ErrorCode != 0)
+                            if (responseMessage?.ErrorCode != 0 && !messageActorObject.IsIgnoreErrorCode)
                             {
                                 _rpcErrorCodeHandler?.Invoke(this, message);
                             }
@@ -120,15 +120,16 @@ public bool TryReply(MessageObject message)
             /// 可能会引发超时异常。
             /// </summary>
             /// <param name="messageObject">要发送的消息对象，必须实现IRequestMessage接口。</param>
+            /// <param name="isIgnoreErrorCode"></param>
             /// <returns>返回一个任务，该任务在收到响应时完成，并返回IResponseMessage。</returns>
-            public Task<IResponseMessage> Call(MessageObject messageObject)
+            public Task<IResponseMessage> Call(MessageObject messageObject, bool isIgnoreErrorCode)
             {
                 if (_waitingReplyHandlingObjects.TryGetValue(messageObject.UniqueId, out var messageActorObject))
                 {
                     return messageActorObject.Task;
                 }
 
-                var defaultMessageActorObject = RpcMessageData.Create(messageObject as IRequestMessage, _rpcTimeout);
+                var defaultMessageActorObject = RpcMessageData.Create(messageObject as IRequestMessage, _rpcTimeout, isIgnoreErrorCode);
                 _waitingReplyHandlingObjects.TryAdd(messageObject.UniqueId, defaultMessageActorObject);
                 try
                 {