IO: Remake BytePayload without RecyclableMemoryStreams. Support custom resize strategies.

Transport: Allow different transports and decouple library logic from ENet entirely.

Work in progress

Author: maverickliberty

Source/Data/IDataHolder.cs

@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 
 namespace EppNet.Data
 {
@@ -23,7 +24,7 @@ public interface IDataHolder : IDisposable
         /// just hide poor memory management.
         /// <br></br>Just make sure you call dispose!
         /// </summary>
-        internal static readonly Dictionary<IDataHolder, Dictionary<string, object>> _globalDataDict = new();
+        internal static readonly ConditionalWeakTable<IDataHolder, Dictionary<string, object>> _globalDataDict = new();
 
         /// <summary>
         /// Tries to get all data associated with a particular <see cref="IDataHolder"/><br></br>

Source/Data/IO/BytePayload.cs

@@ -0,0 +1,262 @@
+///////////////////////////////////////////////////////
+/// Filename: BytePayload.cs
+/// Date: June 8, 2025
+/// Author: Maverick Liberty
+///////////////////////////////////////////////////////
+
+using System;
+
+public sealed class BytePayload : IDisposable
+{
+
+    public int Capacity { internal set; get; }
+
+    public int Length { internal set; get; }
+
+    public DateTime LastUse { internal set; get; }
+
+    public bool IsDestroyed { internal set; get; }
+
+    public byte[] Buffer { internal set; get; }
+
+    public bool IsPooled { internal set; get; }
+
+    public IResizeStrategy ResizeStrategy;
+    private readonly BytePayloadPool _pool;
+
+    internal BytePayload(BytePayloadPool pool, int capacity)
+    {
+        this._pool = pool ?? throw new ArgumentNullException(nameof(pool));
+
+        this.IsDestroyed = IsPooled = false;
+        this.Capacity = capacity;
+        this.Length = 0;
+        this.LastUse = DateTime.Now;
+        this.Buffer = new byte[capacity];
+        this.ResizeStrategy = pool.ResizeStrategy;
+    }
+
+    internal BytePayload(IResizeStrategy resizeStrategy, int capacity)
+    {
+        this._pool = null;
+
+        this.IsDestroyed = IsPooled = false;
+        this.Capacity = capacity;
+        this.Length = 0;
+        this.LastUse = DateTime.Now;
+        this.Buffer = new byte[capacity];
+        this.ResizeStrategy = resizeStrategy ?? throw new ArgumentNullException(nameof(resizeStrategy));
+    }
+
+    public Span<byte> AsSpan() =>
+        new(Buffer, 0, Length);
+
+    public ReadOnlySpan<byte> AsReadOnlySpan() =>
+        new(Buffer, 0, Length);
+
+    public void EnsureCapacity(int neededBytes, bool exact = false)
+    {
+        LastUse = DateTime.Now;
+
+        if (neededBytes < 0)
+            throw new ArgumentOutOfRangeException(nameof(neededBytes));
+
+        if (Length + neededBytes <= Capacity)
+            return;
+
+        int additional = neededBytes - (Capacity - Length);
+        int newSize = exact ? Capacity + additional : ResizeStrategy.Resize(Capacity + additional);
+        Resize(newSize);
+    }
+
+    public void Resize(int newSize)
+    {
+        if (IsDestroyed || newSize <= Capacity)
+            return;
+
+        byte[] newBuffer = new byte[newSize];
+        System.Buffer.BlockCopy(Buffer, 0, newBuffer, 0, Length);
+
+        this.Buffer = newBuffer;
+        this.Capacity = newSize;
+    }
+
+    public void Reset()
+    {
+        if (Buffer is not null)
+            Array.Clear(Buffer, 0, Length);
+
+        Length = 0;
+        LastUse = DateTime.Now;
+    }
+
+    /// <summary>
+    /// Resets this payload and returns it to the pool (if-applicable)
+    /// </summary>
+
+    public void Dispose()
+    {
+        if (IsDestroyed || Buffer is null)
+            return;
+
+        Reset();
+
+        if (_pool is not null)
+        {
+            _pool.Return(this);
+            this.IsPooled = true;
+        }
+    }
+    
+    /// <summary>
+    /// Destroys this payload and frees it memory. It is no longer capable of being pooled.
+    /// </summary>
+    /// <exception cref="InvalidOperationException"></exception>
+
+    public void Destroy()
+    {
+        if (!IsDestroyed && Buffer is not null)
+        {
+            this.Buffer = Array.Empty<byte>();
+            this.Length = this.Capacity = 0;
+            this.IsDestroyed = true;
+            this.IsPooled = false;
+        }
+    }
+
+}
+
+public ref struct BytePayloadWriter
+{
+
+    public int Position
+    {
+        internal set;
+        get;
+    }
+
+    private readonly BytePayload _owner;
+
+    public BytePayloadWriter(BytePayload owner)
+    {
+        if (owner.IsDestroyed)
+            throw new ObjectDisposedException("BytePayload has been disposed!");
+
+        this._owner = owner;
+        this.Position = 0;
+    }
+
+    public BytePayloadWriter(BytePayload owner, int offset)
+    {
+        if (owner.IsDestroyed)
+            throw new ObjectDisposedException("BytePayload has been disposed!");
+
+        if (offset < 0 || offset >= owner.Length)
+            throw new ArgumentOutOfRangeException("Offset is out of bounds!");
+
+        this._owner = owner;
+        this.Position = offset;
+    }
+
+    public void WriteByte(byte value)
+    {
+        #if DEBUG
+        if (_owner.IsDestroyed)
+            throw new ObjectDisposedException("BytePayload has been disposed!");
+        #endif
+        
+        _owner.EnsureCapacity(1);
+        _owner.Buffer[Position++] = value;
+        _owner.Length++;
+    }
+
+    public void WriteBytes(ReadOnlySpan<byte> data)
+    {
+        #if DEBUG
+        if (_owner.IsDestroyed)
+            throw new ObjectDisposedException("BytePayload has been disposed!");
+        #endif
+
+        _owner.EnsureCapacity(data.Length);
+        data.CopyTo(new Span<byte>(_owner.Buffer, Position, data.Length));
+        Position += data.Length;
+
+        // Update buffer length and last use
+        _owner.Length = Math.Max(Position, _owner.Length);
+        _owner.LastUse = DateTime.Now;
+    }
+
+    public Span<byte> Reserve(int count)
+    {
+        #if DEBUG
+        if (_owner.IsDestroyed)
+            throw new ObjectDisposedException("BytePayload has been disposed!");
+        #endif
+        
+        _owner.EnsureCapacity(count);
+        Span<byte> slice = new(_owner.Buffer, Position, count);
+        Position += count;
+
+        // Update buffer length and last use
+        _owner.Length = Math.Max(Position, _owner.Length);
+        _owner.LastUse = DateTime.Now;
+        return slice;
+    }
+
+}
+
+public ref struct BytePayloadReader
+{
+
+    public int Position { internal set; get; }
+
+    private readonly BytePayload _owner;
+
+    public BytePayloadReader(BytePayload owner)
+    {
+        if (owner.IsDestroyed)
+            throw new ObjectDisposedException(nameof(owner));
+
+        this._owner = owner;
+        this.Position = 0;
+    }
+
+    public BytePayloadReader(BytePayload owner, int offset)
+    {
+        if (owner.IsDestroyed)
+            throw new ObjectDisposedException(nameof(owner));
+
+        if (offset < 0 || offset >= owner.Length)
+            throw new ArgumentOutOfRangeException("Offset is out of bounds!");
+
+        this._owner = owner;
+        this.Position = offset;
+    }
+
+    public byte ReadByte()
+    {
+        #if DEBUG
+        if (_owner.IsDestroyed)
+            throw new ObjectDisposedException("BytePayload has been disposed!");
+
+        if (Position >= _owner.Length)
+            throw new IndexOutOfRangeException("Attempted to read beyond buffer length!");
+        #endif
+        return _owner.Buffer[Position++];
+    }
+
+    public ReadOnlySpan<byte> ReadBytes(int count)
+    {
+        #if DEBUG
+        if (_owner.IsDestroyed)
+            throw new ObjectDisposedException("BytePayload has been disposed!");
+
+        if (Position + count > _owner.Length)
+            throw new IndexOutOfRangeException("Attempted to read beyond buffer length!");
+        #endif
+        ReadOnlySpan<byte> span = new(_owner.Buffer, Position, count);
+        Position += count;
+        return span;
+    }
+
+}

Source/Data/IO/BytePayloadPool.cs

@@ -0,0 +1,45 @@
+///////////////////////////////////////////////////////
+/// Filename: BytePayloadPool.cs
+/// Date: June 8, 2025
+/// Author: Maverick Liberty
+///////////////////////////////////////////////////////
+
+using System.Collections.Concurrent;
+using EppNet.Node;
+
+public class BytePayloadPool : INodeDescendant
+{
+    public NetworkNode Node { get; }
+
+    public int DefaultCapacity { get; }
+
+    private readonly ConcurrentBag<BytePayload> _pool;
+
+    public IResizeStrategy ResizeStrategy { get; }
+
+    internal BytePayloadPool(NetworkNode node, int defaultCapacity = 1024)
+    {
+        this.Node = node;
+        this.DefaultCapacity = defaultCapacity;
+        this.ResizeStrategy = new ExponentialResizeStrategy();
+        this._pool = new();
+    }
+
+    public BytePayload Rent(int capacity)
+    {
+        if (!_pool.TryTake(out BytePayload payload) || payload.IsDestroyed)
+            payload = new BytePayload(this, capacity);
+
+        return payload;
+    }
+
+    internal bool Return(BytePayload payload)
+    {
+        if (payload.IsDestroyed)
+            return false;
+
+        _pool.Add(payload);
+        return true;
+    }
+
+}

Source/Data/IO/ExponentialResizeStrategy.cs

@@ -0,0 +1,20 @@
+///////////////////////////////////////////////////////
+/// Filename: ExponentialResizeStrategy.cs
+/// Date: June 9, 2025
+/// Author: Maverick Liberty
+///////////////////////////////////////////////////////
+
+public sealed class ExponentialResizeStrategy : IResizeStrategy
+{
+
+    public int Multiplier { get; }
+
+    public ExponentialResizeStrategy(int multiplier = 2)
+    {
+        this.Multiplier = multiplier;
+    }
+
+    public int Resize(int neededBytes) =>
+        neededBytes * Multiplier;
+
+}

Source/Data/IO/IResizeStrategy.cs

@@ -0,0 +1,12 @@
+///////////////////////////////////////////////////////
+/// Filename: IResizeStrategy.cs
+/// Date: June 9, 2025
+/// Author: Maverick Liberty
+///////////////////////////////////////////////////////
+
+public interface IResizeStrategy
+{
+
+    int Resize(int neededBytes);
+
+}