refactor(transports): removing sendAsync from transports

Assets/Mirage/Runtime/INetworkClient.cs

@@ -1,9 +1,8 @@
-using Cysharp.Threading.Tasks;
 using UnityEngine.Events;
 
 namespace Mirage
 {
-    public interface INetworkClient
+    public interface INetworkClient : IMessageSender
     {
 
         /// <summary>
@@ -38,9 +37,5 @@ public interface INetworkClient
         bool IsLocalClient { get; }
 
         void Disconnect();
-
-        void Send<T>(T message, int channelId = Channel.Reliable);
-
-        UniTask SendAsync<T>(T message, int channelId = Channel.Reliable);
     }
 }

Assets/Mirage/Runtime/INetworkConnection.cs

@@ -5,9 +5,19 @@
 namespace Mirage
 {
     /// <summary>
-    /// An object that can send and receive messages
+    /// An object that can send messages
     /// </summary>
-    public interface IMessageHandler
+    public interface IMessageSender
+    {
+        void Send<T>(T msg, int channelId = Channel.Reliable);
+
+        void Send(ArraySegment<byte> segment, int channelId = Channel.Reliable);
+    }
+
+    /// <summary>
+    /// An object that can receive messages
+    /// </summary>
+    public interface IMessageReceiver
     {
         void RegisterHandler<T>(Action<INetworkConnection, T> handler);
 
@@ -17,22 +27,32 @@ public interface IMessageHandler
 
         void ClearHandlers();
 
-        void Send<T>(T msg, int channelId = Channel.Reliable);
-
-        UniTask SendAsync<T>(T msg, int channelId = Channel.Reliable);
-
-        UniTask SendAsync(ArraySegment<byte> segment, int channelId = Channel.Reliable);
-
+        /// <summary>
+        /// ProcessMessages loop, should loop unitil object is closed
+        /// </summary>
+        /// <returns></returns>
         UniTask ProcessMessagesAsync();
+    }
 
+    /// <summary>
+    /// An object that can send notify messages
+    /// </summary>
+    public interface INotifySender
+    {
         /// <summary>
         /// Sends a message, but notify when it is delivered or lost
         /// </summary>
         /// <typeparam name="T">type of message to send</typeparam>
         /// <param name="msg">message to send</param>
         /// <param name="token">a arbitrary object that the sender will receive with their notification</param>
         void SendNotify<T>(T msg, object token, int channelId = Channel.Unreliable);
+    }
 
+    /// <summary>
+    /// An object that can receive notify messages
+    /// </summary>
+    public interface INotifyReceiver
+    {
         /// <summary>
         /// Raised when a message is delivered
         /// </summary>
@@ -44,6 +64,14 @@ public interface IMessageHandler
         event Action<INetworkConnection, object> NotifyLost;
     }
 
+    /// <summary>
+    /// An object that can send and receive messages and notify messages
+    /// </summary>
+    public interface IMessageHandler : IMessageSender, IMessageReceiver, INotifySender, INotifyReceiver
+    {
+
+    }
+
     /// <summary>
     /// An object that can observe NetworkIdentities.
     /// this is useful for interest management

Assets/Mirage/Runtime/NetworkBehaviour.cs

@@ -241,7 +241,7 @@ protected internal void SendServerRpcInternal(Type invokeClass, string cmdName,
                 payload = writer.ToArraySegment()
             };
 
-            Client.SendAsync(message, channelId).Forget();
+            Client.Send(message, channelId);
         }
 
         private void ValidateServerRpc(Type invokeClass, string cmdName, bool requireAuthority)
@@ -284,7 +284,7 @@ protected internal UniTask<T> SendServerRpcWithReturn<T>(Type invokeClass, strin
                 payload = writer.ToArraySegment()
             };
 
-            Client.SendAsync(message, channelId).Forget();
+            Client.Send(message, channelId);
 
             return task;
         }

Assets/Mirage/Runtime/NetworkClient.cs

@@ -253,14 +253,14 @@ public void Disconnect()
         /// <param name="message"></param>
         /// <param name="channelId"></param>
         /// <returns>True if message was sent.</returns>
-        public UniTask SendAsync<T>(T message, int channelId = Channel.Reliable)
+        public void Send<T>(T message, int channelId = Channel.Reliable)
         {
-            return Connection.SendAsync(message, channelId);
+            Connection.Send(message, channelId);
         }
 
-        public void Send<T>(T message, int channelId = Channel.Reliable)
+        public void Send(ArraySegment<byte> segment, int channelId = Channel.Reliable)
         {
-            Connection.SendAsync(message, channelId).Forget();
+            Connection.Send(segment, channelId);
         }
 
         internal void Update()

Assets/Mirage/Runtime/NetworkConnection.cs

@@ -179,18 +179,6 @@ public void ClearHandlers()
             messageHandlers.Clear();
         }
 
-        /// <summary>
-        /// This sends a network message to the connection.
-        /// </summary>
-        /// <typeparam name="T">The message type</typeparam>
-        /// <param name="msg">The message to send</param>
-        /// <param name="channelId">The transport layer channel to send on.</param>
-        /// <returns></returns>
-        public virtual void Send<T>(T msg, int channelId = Channel.Reliable)
-        {
-            SendAsync(msg, channelId).Forget();
-        }
-
         public static void Send<T>(IEnumerable<INetworkConnection> connections, T msg, int channelId = Channel.Reliable)
         {
             using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
@@ -203,7 +191,7 @@ public static void Send<T>(IEnumerable<INetworkConnection> connections, T msg, i
                 foreach (INetworkConnection conn in connections)
                 {
                     // send to all connections, but don't wait for them
-                    conn.SendAsync(segment, channelId).Forget();
+                    conn.Send(segment, channelId);
                     count++;
                 }
 
@@ -212,28 +200,28 @@ public static void Send<T>(IEnumerable<INetworkConnection> connections, T msg, i
         }
 
         /// <summary>
-        /// This sends a network message to the connection. You can await it to check for errors
+        /// This sends a network message to the connection.
         /// </summary>
         /// <typeparam name="T">The message type</typeparam>
         /// <param name="msg">The message to send.</param>
         /// <param name="channelId">The transport layer channel to send on.</param>
         /// <returns></returns>
-        public virtual UniTask SendAsync<T>(T msg, int channelId = Channel.Reliable)
+        public virtual void Send<T>(T msg, int channelId = Channel.Reliable)
         {
             using (PooledNetworkWriter writer = NetworkWriterPool.GetWriter())
             {
                 // pack message and send allocation free
                 MessagePacker.Pack(msg, writer);
                 NetworkDiagnostics.OnSend(msg, channelId, writer.Length, 1);
-                return SendAsync(writer.ToArraySegment(), channelId);
+                Send(writer.ToArraySegment(), channelId);
             }
         }
 
         // internal because no one except Mirage should send bytes directly to
         // the client. they would be detected as a message. send messages instead.
-        public UniTask SendAsync(ArraySegment<byte> segment, int channelId = Channel.Reliable)
+        public void Send(ArraySegment<byte> segment, int channelId = Channel.Reliable)
         {
-            return connection.SendAsync(segment, channelId);
+            connection.Send(segment, channelId);
         }
 
 
@@ -429,7 +417,7 @@ public void SendNotify<T>(T msg, object token, int channelId = Channel.Unreliabl
                 MessagePacker.Pack(notifyPacket, writer);
                 MessagePacker.Pack(msg, writer);
                 NetworkDiagnostics.OnSend(msg, channelId, writer.Length, 1);
-                SendAsync(writer.ToArraySegment(), channelId).Forget();
+                Send(writer.ToArraySegment(), channelId);
                 lastNotifySentTime = Time.unscaledTime;
             }
 

Assets/Mirage/Runtime/Transport/IConnection.cs

@@ -17,7 +17,7 @@ public static class Channel
 
     public interface IConnection
     {
-        UniTask SendAsync(ArraySegment<byte> data, int channel = Channel.Reliable);
+        void Send(ArraySegment<byte> data, int channel = Channel.Reliable);
 
         /// <summary>
         /// reads a message from connection

Assets/Mirage/Runtime/Transport/Kcp/KcpClientConnection.cs

@@ -85,7 +85,7 @@ protected async UniTask HandshakeAsync(int bits)
 
             var data = new ArraySegment<byte>(hello, 0, length);
             // send a greeting and see if the server replies
-            await SendAsync(data);
+            Send(data);
 
             var stream = new MemoryStream();
             try

Assets/Mirage/Runtime/Transport/Kcp/KcpConnection.cs

@@ -192,14 +192,12 @@ private void SendWithChecksum(byte[] data, int length)
             }
         }
 
-        public UniTask SendAsync(ArraySegment<byte> data, int channel = Channel.Reliable)
+        public void Send(ArraySegment<byte> data, int channel = Channel.Reliable)
         {
             if (channel == Channel.Reliable)
                 kcp.Send(data.Array, data.Offset, data.Count);
             else if (channel == Channel.Unreliable)
                 unreliable.Send(data.Array, data.Offset, data.Count);
-
-            return UniTask.CompletedTask;
         }
 
         /// <summary>
@@ -283,7 +281,7 @@ public virtual void Disconnect()
             {
                 try
                 {
-                    SendAsync(Goodby).Forget();
+                    Send(Goodby);
                     kcp.Flush();
                 }
                 catch (SocketException)

Assets/Mirage/Runtime/Transport/Kcp/KcpServerConnection.cs

@@ -20,7 +20,7 @@ public KcpServerConnection(Socket socket, EndPoint remoteEndpoint, KcpDelayMode
         internal async UniTask HandshakeAsync()
         {
             // send a greeting and see if the server replies
-            await SendAsync(Hello);
+            Send(Hello);
             var stream = new MemoryStream();
 
             try

Assets/Mirage/Runtime/Transport/PipeConnection.cs

@@ -79,13 +79,12 @@ public async UniTask<int> ReceiveAsync(MemoryStream buffer)
             return 0;
         }
 
-        public UniTask SendAsync(ArraySegment<byte> data, int channel = Channel.Reliable)
+        public void Send(ArraySegment<byte> data, int channel = Channel.Reliable)
         {
             // add some data to the writer in the connected connection
             // and increase the message count
             connected.writer.WriteBytesAndSizeSegment(data);
             connected.MessageCount.Release();
-            return UniTask.CompletedTask;
         }
     }
 }

Assets/Mirage/Weaver/Processors/ReaderWriterProcessor.cs

@@ -220,19 +220,13 @@ private static bool IsMessageMethod(MethodReference method)
                 method.Is(typeof(MessagePacker), nameof(MessagePacker.Pack)) ||
                 method.Is(typeof(MessagePacker), nameof(MessagePacker.GetId)) ||
                 method.Is(typeof(MessagePacker), nameof(MessagePacker.Unpack)) ||
-                method.Is<IMessageHandler>(nameof(IMessageHandler.Send)) ||
-                method.Is<IMessageHandler>(nameof(IMessageHandler.SendAsync)) ||
-                method.Is<IMessageHandler>(nameof(IMessageHandler.RegisterHandler)) ||
-                method.Is<IMessageHandler>(nameof(IMessageHandler.UnregisterHandler)) ||
-                method.Is<IMessageHandler>(nameof(IMessageHandler.Send)) ||
+                method.Is<IMessageSender>(nameof(IMessageSender.Send)) ||
+                method.Is<IMessageSender>(nameof(IMessageReceiver.RegisterHandler)) ||
+                method.Is<IMessageSender>(nameof(IMessageReceiver.UnregisterHandler)) ||
                 method.Is<NetworkConnection>(nameof(NetworkConnection.Send)) ||
-                method.Is<NetworkConnection>(nameof(NetworkConnection.SendAsync)) ||
                 method.Is<NetworkConnection>(nameof(NetworkConnection.RegisterHandler)) ||
                 method.Is<NetworkConnection>(nameof(NetworkConnection.UnregisterHandler)) ||
-                method.Is<INetworkClient>(nameof(INetworkClient.Send)) ||
-                method.Is<INetworkClient>(nameof(INetworkClient.SendAsync)) ||
                 method.Is<NetworkClient>(nameof(NetworkClient.Send)) ||
-                method.Is<NetworkClient>(nameof(NetworkClient.SendAsync)) ||
                 method.Is<NetworkServer>(nameof(NetworkServer.SendToAll)) ||
                 method.Is<INetworkServer>(nameof(INetworkServer.SendToAll));
         }

Assets/Tests/Editor/PipeConnectionTest.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections;
 using System.IO;
 using System.Net;
@@ -23,9 +23,9 @@ public void Setup()
             (c1, c2) = PipeConnection.CreatePipe();
         }
 
-        private static UniTask SendData(IConnection c, byte[] data)
+        private static void SendData(IConnection c, byte[] data)
         {
-            return c.SendAsync(new ArraySegment<byte>(data));
+            c.Send(new ArraySegment<byte>(data));
         }
 
 
@@ -41,16 +41,16 @@ private static async Task ExpectData(IConnection c, byte[] expected)
         [UnityTest]
         public IEnumerator TestSendAndReceive() => RunAsync(async () =>
         {
-            await SendData(c1, new byte[] { 1, 2, 3, 4 });
+            SendData(c1, new byte[] { 1, 2, 3, 4 });
 
             await ExpectData(c2, new byte[] { 1, 2, 3, 4 });
         });
 
         [UnityTest]
         public IEnumerator TestSendAndReceiveMultiple() => RunAsync(async () =>
         {
-            await SendData(c1, new byte[] { 1, 2, 3, 4 });
-            await SendData(c1, new byte[] { 5, 6, 7, 8 });
+            SendData(c1, new byte[] { 1, 2, 3, 4 });
+            SendData(c1, new byte[] { 5, 6, 7, 8 });
 
             await ExpectData(c2, new byte[] { 1, 2, 3, 4 });
             await ExpectData(c2, new byte[] { 5, 6, 7, 8 });

Assets/Tests/Runtime/Serializers/NetworkConnectionTest.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using NSubstitute;
 using NUnit.Framework;
@@ -38,7 +38,7 @@ void ParsePacket(ArraySegment<byte> data)
                 Array.Copy(data.Array, data.Offset, lastSerializedPacket, 0, data.Count);
             }
 
-            mockTransportConnection.SendAsync(
+            mockTransportConnection.Send(
                 Arg.Do<ArraySegment<byte>>(ParsePacket), Channel.Unreliable);
 
             connection = new NetworkConnection(mockTransportConnection);
@@ -271,4 +271,4 @@ public void NotAcknowledgedYet()
 
         #endregion
     }
-}
+}