Enable unsafe code. Channel, ChannelService: Don't copy the buffer, instead, have C++ use the memory from C#.

Author: maverickliberty

Epp Net.csproj

@@ -13,6 +13,7 @@
     <EnableDynamicLoading>true</EnableDynamicLoading>
     <RootNamespace>EppNet</RootNamespace>
 	  <LangVersion>9.0</LangVersion>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="packages\Microsoft.NET.Test.Sdk.17.10.0\**" />

Source/Data/BytePayload.cs

@@ -16,6 +16,7 @@
 /// </summary>
 
 
+using ENet;
 using EppNet.Utilities;
 
 using Microsoft.IO;
@@ -474,10 +475,7 @@ public virtual bool TryWrite<T>(T input)
 
         public virtual byte[] Pack()
         {
-            if (Stream == null)
-                return null;
-
-            if (PackedData == null)
+            if (Stream != null && PackedData != null)
             {
                 this.PackedData = new byte[Stream.Length];
                 Stream.WriteTo(PackedData);
@@ -518,9 +516,8 @@ public virtual void Dispose()
 
         public string ReadString(int length)
         {
-            Span<byte> buffer = stackalloc byte[length];
+            Span<byte> buffer = stackalloc byte[Encoder.GetMaxByteCount(length)];
             int read = Stream.Read(buffer);
-
             return Encoder.GetString(buffer);
         }
 

Source/Messaging/Channel.cs

@@ -5,13 +5,15 @@
 //////////////////////////////////////////////
 
 using ENet;
+using EppNet.Data;
 
 using EppNet.Data.Datagrams;
 using EppNet.Logging;
 using EppNet.Utilities;
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Threading;
 
 namespace EppNet.Messaging
@@ -170,35 +172,82 @@ public void Clear()
             }
         }
 
-        public bool SendTo(Peer peer, byte[] bytes, PacketFlags flags)
+        /// <summary>
+        /// Tries to send an <see cref="ArraySegment"/> of bytes to the specified <see cref="Peer"/> 
+        /// with the specified <see cref="PacketFlags"/>.<br/>
+        /// Length of -1 means the entire buffer will be sent.<br/><br/>
+        /// 
+        /// Return:<br/>
+        /// - 0 -> Success<br/>
+        /// - 1 -> Invalid data<br/>
+        /// - 2 -> An exception occurred<br/>
+        /// </summary>
+        /// <param name="peer"></param>
+        /// <param name="buffer"></param>
+        /// <param name="flags"></param>
+        /// <returns></returns>
+
+        public int TrySendTo(Peer peer, ArraySegment<byte> buffer, PacketFlags flags = PacketFlags.None)
+        {
+            if (buffer.Count < 1)
+                return 1;
+
+            return TrySendTo(peer, buffer.Array, buffer.Offset, buffer.Count, flags);
+        }
+
+        /// <summary>
+        /// Tries to send a byte array to the specified <see cref="Peer"/> 
+        /// with the specified <see cref="PacketFlags"/>.<br/>
+        /// Length of -1 means the entire buffer will be sent.<br/><br/>
+        /// 
+        /// Return:<br/>
+        /// - 0 -> Success<br/>
+        /// - 1 -> Invalid data<br/>
+        /// - 2 -> An exception occurred<br/>
+        /// </summary>
+        /// <param name="peer"></param>
+        /// <param name="buffer"></param>
+        /// <param name="flags"></param>
+        /// <returns></returns>
+
+        public int TrySendTo(Peer peer, byte[] bytes, int offset, int length = -1, PacketFlags flags = PacketFlags.None)
         {
-            // Create an ENet packet
-            Packet packet = new();
+            if (bytes == null)
+                return 1;
+
+            Packet packet = default;
 
             try
             {
-                packet.Create(bytes, flags);
+                unsafe
+                {
+                    fixed (byte* bufferPtr = bytes)
+                    {
+                        IntPtr nativePtr = (IntPtr)(bufferPtr + offset);
+                        packet.Create(nativePtr, length == -1 ? bytes.Length : length, flags);
+                    }
+                }
 
                 // Send the packet to our ENet peer
                 if (peer.Send(Id, ref packet))
                 {
                     Interlocked.Increment(ref _datagramsReceived);
-                    Interlocked.Add(ref _totalBytesSent, bytes.LongLength);
-                    return true;
+                    Interlocked.Add(ref _totalBytesSent, length);
+                    return 0;
                 }
             }
             catch (Exception ex)
             {
-                Notify.Error($"Failed to send Datagram to Peer {peer.ID}. Error {ex.Message}\n{ex.StackTrace}");
+                Notify.Error($"Failed to send data to Peer {peer.ID}. Error {ex.Message}\n{ex.StackTrace}");
             }
             finally
             {
                 // No matter what, dispose of this packet.
                 packet.Dispose();
             }
 
-            // Failed to send the datagram.
-            return false;
+            // An exception occurred.
+            return 2;
         }
 
         /// <summary>

Source/Messaging/ChannelService.cs

@@ -38,23 +38,64 @@ public bool Handle(PacketReceivedEvent @event)
             return true;
         }
 
-        public bool TrySendTo(Peer peer, IDatagram datagram, PacketFlags flags)
+        /// <summary>
+        /// Tries to send a Datagram to the specified <see cref="Peer"/> 
+        /// with the specified <see cref="PacketFlags"/>.<br/><br/>
+        /// 
+        /// Return:<br/>
+        /// - 0 -> Success<br/>
+        /// - 1 -> Invalid data<br/>
+        /// - 2 -> An exception occurred<br/>
+        /// - 3 -> Channel not found
+        /// </summary>
+        /// <param name="peer"></param>
+        /// <param name="buffer"></param>
+        /// <param name="flags"></param>
+        /// <returns></returns>
+
+        public int TrySendTo(Peer peer, Datagram datagram, PacketFlags flags = PacketFlags.None)
         {
 
+            if (datagram is null)
+                return 1;
+
             if (!datagram.Written)
                 datagram.Write();
 
-            Channel channel = GetChannelById(datagram.GetChannelID());
-            return channel?.SendTo(peer, datagram.Pack(), flags) == true;
+            if (!datagram.Stream.TryGetBuffer(out ArraySegment<byte> buffer))
+                return 1;
+
+            return TrySendDataTo(peer, datagram.ChannelID, buffer.Array, buffer.Offset, buffer.Count, flags);
         }
 
-        public bool TrySendDataTo(Peer peer, byte channelId, byte[] bytes, PacketFlags flags)
+        /// <summary>
+        /// Tries to send a byte array to the specified <see cref="Peer"/> 
+        /// with the specified offset, length, and <see cref="PacketFlags"/>.<br/>
+        /// Length of -1 means the entire buffer will be sent.<br/><br/>
+        /// 
+        /// Return:<br/>
+        /// - 0 -> Success<br/>
+        /// - 1 -> Invalid data<br/>
+        /// - 2 -> An exception occurred<br/>
+        /// - 3 -> Channel does not exist
+        /// </summary>
+        /// <param name="peer"></param>
+        /// <param name="buffer"></param>
+        /// <param name="flags"></param>
+        /// <returns></returns>
+
+        public int TrySendDataTo(Peer peer, byte channelId, byte[] bytes, int offset, int length = -1, PacketFlags flags = PacketFlags.None)
         {
             Channel channel = GetChannelById(channelId);
-            return channel?.SendTo(peer, bytes, flags) == true;
+
+            if (channel is not null)
+                return channel.TrySendTo(peer, bytes, offset, length, flags);
+
+            return 3;
         }
 
-        public bool TryAddChannel(byte id) => TryAddChannel(id, out Channel _);
+        public bool TryAddChannel(byte id)
+            => TryAddChannel(id, out Channel _);
 
         public bool TryAddChannel(byte id, out Channel newChannel, ChannelFlags flags = ChannelFlags.None)
         {