新增两个 send 方法

src/SuperSocket.Channel/ChannelBase.cs

@@ -20,6 +20,10 @@ public abstract class ChannelBase<TPackageInfo> : IChannel<TPackageInfo>, IChann
 
         public abstract ValueTask SendAsync(Action<PipeWriter> write);
 
+        public abstract ValueTask<int> Send(ReadOnlyMemory<byte> buffer); 
+
+        public abstract ValueTask<int> Send<TPackage>(IPackageEncoder<TPackage> packageEncoder, TPackage package);
+
         public bool IsClosed { get; private set; }
 
         public EndPoint RemoteEndPoint { get; protected set; }

src/SuperSocket.Channel/IChannel.cs

@@ -17,6 +17,11 @@ public interface IChannel
 
         ValueTask SendAsync(Action<PipeWriter> write);
 
+        ValueTask<int> Send(ReadOnlyMemory<byte> data);
+
+        ValueTask<int> Send<TPackage>(IPackageEncoder<TPackage> packageEncoder, TPackage package);
+
+
         ValueTask CloseAsync(CloseReason closeReason);
 
         event EventHandler<CloseEventArgs> Closed;

src/SuperSocket.Channel/PipeChannel.cs

@@ -358,6 +358,20 @@ public override async ValueTask SendAsync(Action<PipeWriter> write)
             }
         }
 
+        public override async ValueTask<int> Send(ReadOnlyMemory<byte> buffer)
+        {
+           return await SendOverIOAsync(new ReadOnlySequence<byte>(buffer), CancellationToken.None);
+        }
+
+        public override async ValueTask<int> Send<TPackage>(IPackageEncoder<TPackage> packageEncoder, TPackage package)
+        {
+            ArrayBufferWriter<byte> arrayBufferWriter = new ArrayBufferWriter<byte>();
+
+            WritePackageWithEncoder(arrayBufferWriter, packageEncoder, package);
+
+            return await SendOverIOAsync(new  ReadOnlySequence<byte>(arrayBufferWriter.WrittenMemory), CancellationToken.None);
+        }
+
         protected void WritePackageWithEncoder<TPackage>(IBufferWriter<byte> writer, IPackageEncoder<TPackage> packageEncoder, TPackage package)
         {
             CheckChannelOpen();

src/SuperSocket.Channel/TcpPipeChannel.cs

@@ -59,7 +59,7 @@ protected override async ValueTask<int> SendOverIOAsync(ReadOnlySequence<byte> b
                 _segmentsForSend.Clear();
             }
 
-            var segments = _segmentsForSend;
+            //var segments = _segmentsForSend;
 
             foreach (var piece in buffer)
             {

src/SuperSocket.Channel/UdpPipeChannel.cs

@@ -11,9 +11,9 @@ namespace SuperSocket.Channel
 {
     public class UdpPipeChannel<TPackageInfo> : VirtualChannel<TPackageInfo>, IChannelWithSessionIdentifier
     {
-        private Socket _socket;
+        private readonly Socket _socket;
 
-        private bool _enableSendingPipe;
+        private readonly bool _enableSendingPipe;
 
         public UdpPipeChannel(Socket socket, IPipelineFilter<TPackageInfo> pipelineFilter, ChannelOptions options, IPEndPoint remoteEndPoint)
             : this(socket, pipelineFilter, options, remoteEndPoint, $"{remoteEndPoint.Address}:{remoteEndPoint.Port}")
@@ -60,8 +60,8 @@ protected override async ValueTask<int> SendOverIOAsync(ReadOnlySequence<byte> b
             var destBuffer = pool.Rent((int)buffer.Length);
 
             try
-            {                
-                MergeBuffer(ref buffer, destBuffer);
+            {
+                UdpPipeChannel<TPackageInfo>.MergeBuffer(ref buffer, destBuffer);
                 return await _socket.SendToAsync(new ArraySegment<byte>(destBuffer, 0, (int)buffer.Length), SocketFlags.None, RemoteEndPoint);       
             }
             finally
@@ -78,7 +78,7 @@ protected override Task ProcessSends()
             return Task.CompletedTask;
         }
 
-        private void MergeBuffer(ref ReadOnlySequence<byte> buffer, byte[] destBuffer)
+        private static void MergeBuffer(ref ReadOnlySequence<byte> buffer, byte[] destBuffer)
         {
             Span<byte> destSpan = destBuffer;
 
@@ -88,7 +88,7 @@ private void MergeBuffer(ref ReadOnlySequence<byte> buffer, byte[] destBuffer)
             {
                 piece.Span.CopyTo(destSpan);
                 total += piece.Length;
-                destSpan = destSpan.Slice(piece.Length);                
+                destSpan = destSpan[piece.Length..];                
             }
         }
 

src/SuperSocket.Client/EasyClient.cs

@@ -86,14 +86,8 @@ public EasyClient(IPipelineFilter<TReceivePackage> pipelineFilter, ILogger logge
 
         public EasyClient(IPipelineFilter<TReceivePackage> pipelineFilter, ChannelOptions options)
         {
-            if (pipelineFilter == null)
-                throw new ArgumentNullException(nameof(pipelineFilter));
-
-            if (options == null)
-                throw new ArgumentNullException(nameof(options));
-
-            _pipelineFilter = pipelineFilter;
-            Options = options;
+            _pipelineFilter = pipelineFilter ?? throw new ArgumentNullException(nameof(pipelineFilter));
+            Options = options ?? throw new ArgumentNullException(nameof(options));
             Logger = options.Logger;
         }
 
@@ -318,6 +312,16 @@ protected virtual async ValueTask SendAsync<TSendPackage>(IPackageEncoder<TSendP
             await Channel.SendAsync(packageEncoder, package);
         }
 
+        public ValueTask<int> Send(ReadOnlyMemory<byte> data)
+        {
+            return Channel.Send(data);
+        }
+
+        public ValueTask<int> Send<TSendPackage>(IPackageEncoder<TSendPackage> packageEncoder, TSendPackage package)
+        {
+            return Channel.Send<TSendPackage>(packageEncoder, package);
+        }
+
         public event EventHandler Closed;
 
         public virtual async ValueTask CloseAsync()

src/SuperSocket.Client/IEasyClient.cs

@@ -30,6 +30,10 @@ public interface IEasyClient<TReceivePackage>
 
         ValueTask SendAsync<TSendPackage>(IPackageEncoder<TSendPackage> packageEncoder, TSendPackage package);
 
+        ValueTask<int> Send(ReadOnlyMemory<byte> data);
+
+        ValueTask<int> Send<TSendPackage>(IPackageEncoder<TSendPackage> packageEncoder, TSendPackage package);
+
         event EventHandler Closed;
 
         event PackageHandler<TReceivePackage> PackageHandler;