Update Readers/Writers for Buffers & Fixes bugs (#283)

- [X] Renames PacketReader to CircularBufferReader
- [X] Fixes bugs with CircularBufferReader
- [X] Adds CircularBufferWriter
- [X] Adds SpanWriter
- [X] Adds SpanReader

Bumps release version

Projects/Server/Buffers/CircularBufferReader.cs

@@ -0,0 +1,314 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2020 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: PacketReader.cs                                                 *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+using System;
+using System.Buffers.Binary;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace Server.Network
+{
+    public ref struct CircularBufferReader
+    {
+        private readonly ReadOnlySpan<byte> _first;
+        private readonly ReadOnlySpan<byte> _second;
+
+        public int Length { get; }
+        public int Position { get; private set; }
+        public int Remaining => Length - Position;
+
+        public CircularBufferReader(ArraySegment<byte>[] buffers) : this(buffers[0], buffers[1])
+        {
+        }
+
+        public CircularBufferReader(ReadOnlySpan<byte> first, ReadOnlySpan<byte> second)
+        {
+            _first = first;
+            _second = second;
+            Position = 0;
+            Length = first.Length + second.Length;
+        }
+
+        public void Trace(NetState state)
+        {
+            // We don't have data, so nothing to trace
+            if (_first.Length == 0)
+            {
+                return;
+            }
+
+            try
+            {
+                using var sw = new StreamWriter("Packets.log", true);
+
+                sw.WriteLine("Client: {0}: Unhandled packet 0x{1:X2}", state, _first[0]);
+
+                Utility.FormatBuffer(sw, _first.ToArray(), new Memory<byte>(_second.ToArray()));
+
+                sw.WriteLine();
+                sw.WriteLine();
+            }
+            catch
+            {
+                // ignored
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public byte ReadByte()
+        {
+            if (Position < _first.Length)
+            {
+                return _first[Position++];
+            }
+
+            if (Position < Length)
+            {
+                return _second[Position++ - _first.Length];
+            }
+
+            throw new OutOfMemoryException();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool ReadBoolean() => ReadByte() > 0;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public sbyte ReadSByte() => (sbyte)ReadByte();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public short ReadInt16()
+        {
+            short value;
+
+            if (Position < _first.Length)
+            {
+                if (!BinaryPrimitives.TryReadInt16BigEndian(_first.Slice(Position), out value))
+                {
+                    // Not enough space. Split the spans
+                    return (short)((ReadByte() >> 8) | ReadByte());
+                }
+            }
+            else if (!BinaryPrimitives.TryReadInt16BigEndian(_second.Slice(Position - _first.Length), out value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 2;
+            return value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ushort ReadUInt16()
+        {
+            ushort value;
+
+            if (Position < _first.Length)
+            {
+                if (!BinaryPrimitives.TryReadUInt16BigEndian(_first.Slice(Position), out value))
+                {
+                    // Not enough space. Split the spans
+                    return (ushort)((ReadByte() >> 8) | ReadByte());
+                }
+            }
+            else if (!BinaryPrimitives.TryReadUInt16BigEndian(_second.Slice(Position - _first.Length), out value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 2;
+            return value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int ReadInt32()
+        {
+            int value;
+
+            if (Position < _first.Length)
+            {
+                if (!BinaryPrimitives.TryReadInt32BigEndian(_first.Slice(Position), out value))
+                {
+                    // Not enough space. Split the spans
+                    return (ReadByte() >> 24) | (ReadByte() >> 16) | (ReadByte() >> 8) | ReadByte();
+                }
+            }
+            else if (!BinaryPrimitives.TryReadInt32BigEndian(_second.Slice(Position - _first.Length), out value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 4;
+            return value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint ReadUInt32()
+        {
+            uint value;
+
+            if (Position < _first.Length)
+            {
+                if (!BinaryPrimitives.TryReadUInt32BigEndian(_first.Slice(Position), out value))
+                {
+                    // Not enough space. Split the spans
+                    return (uint)((ReadByte() >> 24) | (ReadByte() >> 16) | (ReadByte() >> 8) | ReadByte());
+                }
+            }
+            else if (!BinaryPrimitives.TryReadUInt32BigEndian(_second.Slice(Position - _first.Length), out value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 4;
+            return value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadString(Encoding encoding, bool safeString = false, int fixedLength = -1)
+        {
+            int sizeT = Utility.GetByteLengthForEncoding(encoding);
+
+            bool isFixedLength = fixedLength > -1;
+
+            var remaining = Remaining;
+            int size;
+
+            if (isFixedLength)
+            {
+                size = fixedLength * sizeT;
+                if (size > Remaining)
+                {
+                    throw new OutOfMemoryException();
+                }
+            }
+            else
+            {
+                size = remaining - (remaining & (sizeT - 1));
+            }
+
+            ReadOnlySpan<byte> span;
+            int index;
+
+            if (Position < _first.Length)
+            {
+                var firstLength = Math.Min(_first.Length - Position, size);
+
+                // Find terminator
+                index = Utility.IndexOfTerminator(_first.Slice(Position, firstLength), sizeT);
+
+                if (index < 0)
+                {
+                    remaining = size - firstLength;
+                    // We don't have a terminator, but a fixed size to the end of the first span, so stop there
+                    if (remaining <= 0)
+                    {
+                        index = firstLength;
+                    }
+                    else
+                    {
+                        index = Utility.IndexOfTerminator(_second.Slice(0, remaining), sizeT);
+
+                        int secondLength = index < 0 ? remaining : index;
+                        int length = firstLength + secondLength;
+
+                        // Assume no strings should be too long for the stack
+                        Span<byte> bytes = stackalloc byte[length];
+                        _first.Slice(Position).CopyTo(bytes);
+                        _second.Slice(0, secondLength).CopyTo(bytes.Slice(firstLength));
+
+                        Position += length + (index >= 0 ? sizeT : 0);
+                        return Utility.GetString(bytes, encoding, safeString);
+                    }
+                }
+
+                span = _first.Slice(Position, index);
+            }
+            else
+            {
+                size = Math.Min(remaining, size);
+                span = _second.Slice( Position - _first.Length, size);
+                index = Utility.IndexOfTerminator(span, sizeT);
+
+                if (index >= 0)
+                {
+                    span = span.Slice(0, index);
+                }
+                else
+                {
+                    index = size;
+                }
+            }
+
+            Position += isFixedLength ? size : index + sizeT;
+            return Utility.GetString(span, encoding, safeString);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadLittleUniSafe(int fixedLength) => ReadString(Utility.UnicodeLE, true, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadLittleUniSafe() => ReadString(Utility.UnicodeLE, true);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadLittleUni(int fixedLength) => ReadString(Utility.UnicodeLE, false, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadLittleUni() => ReadString(Utility.UnicodeLE);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadBigUniSafe(int fixedLength) => ReadString(Utility.Unicode, true, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadBigUniSafe() => ReadString(Utility.Unicode, true);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadBigUni(int fixedLength) => ReadString(Utility.Unicode, false, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadBigUni() => ReadString(Utility.Unicode);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadUTF8Safe(int fixedLength) => ReadString(Utility.UTF8, true, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadUTF8Safe() => ReadString(Utility.UTF8, true);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadUTF8() => ReadString(Utility.UTF8);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadAsciiSafe(int fixedLength) => ReadString(Encoding.ASCII, true, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadAsciiSafe() => ReadString(Encoding.ASCII, true);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadAscii(int fixedLength) => ReadString(Encoding.ASCII, false, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadAscii() => ReadString(Encoding.ASCII);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int Seek(int offset, SeekOrigin origin) =>
+            Position = origin switch
+            {
+                SeekOrigin.Begin => offset,
+                SeekOrigin.End   => Length - offset,
+                _                => Position + offset // Current
+            };
+    }
+}

Projects/Server/Buffers/CircularBufferWriter.cs

@@ -0,0 +1,372 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2020 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: CircularBufferWriter.cs                                         *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+using System.Buffers.Binary;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Text;
+using Server;
+
+namespace System.Buffers
+{
+    public ref struct CircularBufferWriter
+    {
+        private readonly Span<byte> _first;
+        private readonly Span<byte> _second;
+
+        public int Length { get; }
+        public int Position { get; private set; }
+
+        public CircularBufferWriter(ArraySegment<byte>[] buffers) : this(buffers[0], buffers[1])
+        {
+        }
+
+        public CircularBufferWriter(Span<byte> first, Span<byte> second)
+        {
+            _first = first;
+            _second = second;
+            Position = 0;
+            Length = first.Length + second.Length;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(byte value)
+        {
+            if (Position < _first.Length)
+            {
+                _first[Position++] = value;
+            }
+            else if (Position < Length)
+            {
+                _second[Position++ - _first.Length] = value;
+            }
+            else
+            {
+                throw new OutOfMemoryException();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(bool value)
+        {
+            if (value)
+            {
+                Write((byte)1);
+            }
+            else
+            {
+                Write((byte)0);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(sbyte value)
+        {
+            Write((byte)value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(short value)
+        {
+            if (Position < _first.Length)
+            {
+                if (!BinaryPrimitives.TryWriteInt16BigEndian(_first.Slice(Position), value))
+                {
+                    // Not enough space. Split the spans
+                    Write((byte)(value >> 8));
+                    Write((byte)value);
+                }
+                else
+                {
+                    Position += 2;
+                }
+            }
+            else if (BinaryPrimitives.TryWriteInt16BigEndian(_second.Slice(Position - _first.Length), value))
+            {
+                Position += 2;
+            }
+            else
+            {
+                throw new OutOfMemoryException();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(ushort value)
+        {
+            if (Position < _first.Length)
+            {
+                if (!BinaryPrimitives.TryWriteUInt16BigEndian(_first.Slice(Position), value))
+                {
+                    // Not enough space. Split the spans
+                    Write((byte)(value >> 8));
+                    Write((byte)value);
+                }
+                else
+                {
+                    Position += 2;
+                }
+            }
+            else if (BinaryPrimitives.TryWriteUInt16BigEndian(_second.Slice(Position - _first.Length), value))
+            {
+                Position += 2;
+            }
+            else
+            {
+                throw new OutOfMemoryException();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(int value)
+        {
+            if (Position < _first.Length)
+            {
+                if (!BinaryPrimitives.TryWriteInt32BigEndian(_first.Slice(Position), value))
+                {
+                    // Not enough space. Split the spans
+                    Write((byte)(value >> 24));
+                    Write((byte)(value >> 16));
+                    Write((byte)(value >> 8));
+                    Write((byte)value);
+                }
+                else
+                {
+                    Position += 4;
+                }
+            }
+            else if (BinaryPrimitives.TryWriteInt32BigEndian(_second.Slice(Position - _first.Length), value))
+            {
+                Position += 4;
+            }
+            else
+            {
+                throw new OutOfMemoryException();
+            }
+        }
+
+        /// <summary>
+        /// Writes a 4-byte unsigned integer value to the underlying stream.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(uint value)
+        {
+            if (Position < _first.Length)
+            {
+                if (!BinaryPrimitives.TryWriteUInt32BigEndian(_first.Slice(Position), value))
+                {
+                    // Not enough space. Split the spans
+                    Write((byte)(value >> 24));
+                    Write((byte)(value >> 16));
+                    Write((byte)(value >> 8));
+                    Write((byte)value);
+                }
+                else
+                {
+                    Position += 4;
+                }
+            }
+            else if (BinaryPrimitives.TryWriteUInt32BigEndian(_second.Slice(Position - _first.Length), value))
+            {
+                Position += 4;
+            }
+            else
+            {
+                throw new OutOfMemoryException();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(ReadOnlySpan<byte> buffer)
+        {
+            if (Position + buffer.Length > Length)
+            {
+                throw new OutOfMemoryException();
+            }
+
+            if (Position < _first.Length)
+            {
+                var sz = Math.Min(buffer.Length, _first.Length - Position);
+                buffer.CopyTo(_first.Slice(Position));
+                buffer.Slice(sz).CopyTo(_second);
+                Position += buffer.Length;
+            }
+            else if (Position < Length)
+            {
+                buffer.CopyTo(_second.Slice(Position - _first.Length));
+            }
+            else
+            {
+                throw new OutOfMemoryException();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteString(ReadOnlySpan<char> value, Encoding encoding)
+        {
+            var byteCount = encoding.GetByteCount(value);
+
+            if (Position + byteCount > Length)
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Span<byte> bytes = stackalloc byte[byteCount];
+            encoding.GetBytes(value, bytes);
+
+            int count;
+            if (Position < _first.Length)
+            {
+                count = Math.Min(_first.Length - Position, byteCount);
+                bytes.Slice(0, count).CopyTo(_first.Slice(Position));
+                byteCount -= count;
+                Position += count;
+            }
+            else
+            {
+                count = 0;
+            }
+
+            if (byteCount > 0)
+            {
+                bytes.Slice(count).CopyTo(_second.Slice(Math.Max(0, Position - _first.Length)));
+                Position += byteCount;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteLittleUni(string value, int fixedLength = -1)
+        {
+            if (fixedLength < 0) { fixedLength = value.Length; }
+
+            WriteString(value.AsSpan(0, Math.Min(fixedLength, value.Length)), Utility.UnicodeLE);
+            var count = fixedLength - value.Length;
+            if (count > 0)
+            {
+                Clear(count * 2);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteLittleUniNull(string value)
+        {
+            WriteString(value, Utility.UnicodeLE);
+            Write((ushort)0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteBigUni(string value, int fixedLength = -1)
+        {
+            if (fixedLength < 0) { fixedLength = value.Length; }
+
+            WriteString(value.AsSpan(0, Math.Min(fixedLength, value.Length)), Utility.Unicode);
+            var count = fixedLength - value.Length;
+            if (count > 0)
+            {
+                Clear(count * 2);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteBigUniNull(string value)
+        {
+            WriteString(value, Utility.Unicode);
+            Write((ushort)0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteUTF8(string value) => WriteString(value, Utility.UTF8);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteUTF8Null(string value)
+        {
+            WriteString(value, Utility.UTF8);
+            Write((byte)0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteAscii(string value, int fixedLength = -1)
+        {
+            if (fixedLength < 0) { fixedLength = value.Length; }
+
+            WriteString(value.AsSpan(0, Math.Min(fixedLength, value.Length)), Encoding.ASCII);
+            var count = fixedLength - value.Length;
+            if (count > 0)
+            {
+                Clear(count);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteAsciiNull(string value)
+        {
+            WriteString(value, Encoding.ASCII);
+            Write((byte)0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear()
+        {
+            if (Position < _first.Length)
+            {
+                _first.Slice(Position).Clear();
+                _second.Clear();
+            }
+            else
+            {
+                _second.Slice(Position - _first.Length).Clear();
+            }
+
+            Position = Length;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear(int amount)
+        {
+            if (Position + amount > Length)
+            {
+                throw new OutOfMemoryException();
+            }
+
+            int count;
+            if (Position < _first.Length)
+            {
+                count = Math.Min(amount, _first.Length - Position);
+                _first.Slice(Position, count).Clear();
+                count = amount - count;
+            }
+            else
+            {
+                count = amount;
+            }
+
+            if (count > 0)
+            {
+                _second.Slice(Position - _first.Length, count).Clear();
+            }
+
+            Position += amount;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int Seek(int offset, SeekOrigin origin) =>
+            Position = origin switch
+            {
+                SeekOrigin.Begin => offset,
+                SeekOrigin.End   => Length - offset,
+                _                => Position + offset // Current
+            };
+    }
+}

Projects/Server/Buffers/SpanReader.cs

@@ -0,0 +1,187 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2020 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: SpanReader.cs                                                   *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+using System;
+using System.Buffers.Binary;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace Server.Buffers
+{
+    ref struct SpanReader
+    {
+        private readonly ReadOnlySpan<byte> _buffer;
+
+        public int Length { get; }
+        public int Position { get; private set; }
+        public int Remaining => Length - Position;
+
+        public SpanReader(ReadOnlySpan<byte> span)
+        {
+            _buffer = span;
+            Position = 0;
+            Length = span.Length;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public byte ReadByte()
+        {
+            if (Position >= Length)
+            {
+                throw new OutOfMemoryException();
+            }
+
+            return _buffer[Position++];
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool ReadBoolean() => ReadByte() > 0;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public sbyte ReadSByte() => (sbyte)ReadByte();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public short ReadInt16()
+        {
+            if (!BinaryPrimitives.TryReadInt16BigEndian(_buffer.Slice(Position), out var value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 2;
+            return value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ushort ReadUInt16()
+        {
+            if (!BinaryPrimitives.TryReadUInt16BigEndian(_buffer.Slice(Position), out var value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 2;
+            return value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int ReadInt32()
+        {
+            if (!BinaryPrimitives.TryReadInt32BigEndian(_buffer.Slice(Position), out var value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 4;
+            return value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint ReadUInt32()
+        {
+            if (!BinaryPrimitives.TryReadUInt32BigEndian(_buffer.Slice(Position), out var value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 4;
+            return value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadString(Encoding encoding, bool safeString = false, int fixedLength = -1)
+        {
+            int sizeT = Utility.GetByteLengthForEncoding(encoding);
+
+            bool isFixedLength = fixedLength > -1;
+
+            var remaining = Remaining;
+            int size;
+
+            if (isFixedLength)
+            {
+                size = fixedLength * sizeT;
+                if (size > Remaining)
+                {
+                    throw new OutOfMemoryException();
+                }
+            }
+            else
+            {
+                size = remaining - (remaining & (sizeT - 1));
+            }
+
+            int index = Utility.IndexOfTerminator(_buffer.Slice(Position, size), sizeT);
+
+            Position += isFixedLength || index < 0 ? size : index + sizeT;
+            return Utility.GetString(_buffer.Slice(Position, index < 0 ? size : index), encoding, safeString);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadLittleUniSafe(int fixedLength) => ReadString(Utility.UnicodeLE, true, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadLittleUniSafe() => ReadString(Utility.UnicodeLE, true);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadLittleUni(int fixedLength) => ReadString(Utility.UnicodeLE, false, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadLittleUni() => ReadString(Utility.UnicodeLE);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadBigUniSafe(int fixedLength) => ReadString(Utility.Unicode, true, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadBigUniSafe() => ReadString(Utility.Unicode, true);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadBigUni(int fixedLength) => ReadString(Utility.Unicode, false, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadBigUni() => ReadString(Utility.Unicode);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadUTF8Safe(int fixedLength) => ReadString(Utility.UTF8, true, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadUTF8Safe() => ReadString(Utility.UTF8, true);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadUTF8() => ReadString(Utility.UTF8);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadAsciiSafe(int fixedLength) => ReadString(Encoding.ASCII, true, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadAsciiSafe() => ReadString(Encoding.ASCII, true);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadAscii(int fixedLength) => ReadString(Encoding.ASCII, false, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ReadAscii() => ReadString(Encoding.ASCII);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int Seek(int offset, SeekOrigin origin) =>
+            Position = origin switch
+            {
+                SeekOrigin.Begin => offset,
+                SeekOrigin.End   => Length - offset,
+                _                => Position + offset // Current
+            };
+    }
+}

Projects/Server/Buffers/SpanWriter.cs

@@ -0,0 +1,244 @@
+/*************************************************************************
+ * ModernUO                                                              *
+ * Copyright 2019-2020 - ModernUO Development Team                       *
+ * Email: hi@modernuo.com                                                *
+ * File: SpanWriter.cs                                                   *
+ *                                                                       *
+ * This program is free software: you can redistribute it and/or modify  *
+ * it under the terms of the GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3 of the License, or     *
+ * (at your option) any later version.                                   *
+ *                                                                       *
+ * You should have received a copy of the GNU General Public License     *
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
+ *************************************************************************/
+
+using System;
+using System.Buffers.Binary;
+using System.Data;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace Server.Buffers
+{
+    public ref struct SpanWriter
+    {
+        private readonly Span<byte> _buffer;
+
+        public int Length => _buffer.Length;
+
+        public ReadOnlySpan<byte> Span => _buffer.Slice(0, Position);
+
+        public int Position { get; private set; }
+
+        public SpanWriter(Span<byte> span)
+        {
+            _buffer = span;
+            Position = 0;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void Write(bool value)
+        {
+            if (Position >= Length)
+            {
+                throw new OutOfMemoryException();
+            }
+
+            _buffer[Position++] = *(byte*) & value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(byte value)
+        {
+            _buffer[Position++] = value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(sbyte value)
+        {
+            _buffer[Position++] = (byte)value;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(short value)
+        {
+            if (!BinaryPrimitives.TryWriteInt16BigEndian(_buffer.Slice(Position), value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 2;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(ushort value)
+        {
+            if (!BinaryPrimitives.TryWriteUInt16BigEndian(_buffer.Slice(Position), value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 2;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(int value)
+        {
+            if (!BinaryPrimitives.TryWriteInt32BigEndian(_buffer.Slice(Position), value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 4;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(uint value)
+        {
+            if (!BinaryPrimitives.TryWriteUInt32BigEndian(_buffer.Slice(Position), value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 4;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(long value)
+        {
+            if (!BinaryPrimitives.TryWriteInt64BigEndian(_buffer.Slice(Position), value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 8;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write(ulong value)
+        {
+            if (!BinaryPrimitives.TryWriteUInt64BigEndian(_buffer.Slice(Position), value))
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += 8;
+        }
+
+        public void Write(ReadOnlySpan<byte> buffer)
+        {
+            var size = buffer.Length;
+            if (Position + size > Length)
+            {
+                throw new OutOfMemoryException();
+            }
+
+            buffer.Slice(0, size).CopyTo(_buffer.Slice(Position));
+            Position += size;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteString<T>(string value, Encoding encoding, int fixedLength = -1) where T : struct, IEquatable<T>
+        {
+            int sizeT = Unsafe.SizeOf<T>();
+
+            if (sizeT > 2)
+            {
+                throw new InvalidConstraintException("WriteString only accepts byte, sbyte, char, short, and ushort as a constraint");
+            }
+
+            value ??= string.Empty;
+
+            var charLength = Math.Min(fixedLength > -1 ? fixedLength : value.Length, value.Length);
+            var src = value.AsSpan(0, charLength);
+
+            var byteCount = fixedLength > -1 ? fixedLength * sizeT : encoding.GetByteCount(value);
+
+            if (Position + byteCount > Length)
+            {
+                throw new OutOfMemoryException();
+            }
+
+            Position += encoding.GetBytes(src, _buffer.Slice(Position));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteLittleUni(string value) => WriteString<char>(value, Utility.UnicodeLE);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteLittleUniNull(string value)
+        {
+            WriteString<char>(value, Utility.UnicodeLE);
+            Write((ushort)0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteLittleUni(string value, int fixedLength) => WriteString<char>(value, Utility.UnicodeLE, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteBigUni(string value) => WriteString<char>(value, Utility.Unicode);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteBigUniNull(string value)
+        {
+            WriteString<char>(value, Utility.Unicode);
+            Write((ushort)0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteBigUni(string value, int fixedLength) => WriteString<char>(value, Utility.Unicode, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteUTF8(string value) => WriteString<byte>(value, Utility.UTF8);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteUTF8Null(string value)
+        {
+            WriteString<byte>(value, Utility.UTF8);
+            Write((byte)0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteAscii(string value) => WriteString<byte>(value, Encoding.ASCII);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteAsciiNull(string value)
+        {
+            WriteString<byte>(value, Encoding.ASCII);
+            Write((byte)0);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WriteAscii(string value, int fixedLength) => WriteString<byte>(value, Encoding.ASCII, fixedLength);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear()
+        {
+            _buffer.Slice(Position).Clear();
+            Position = Length;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear(int amount)
+        {
+            if (Position + amount > Length)
+            {
+                throw new OutOfMemoryException();
+            }
+
+            _buffer.Slice(Position, amount).Clear();
+            Position += amount;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int Seek(int offset, SeekOrigin origin) =>
+            Position = origin switch
+            {
+                SeekOrigin.Begin => offset,
+                SeekOrigin.End   => Length - offset,
+                _                => Position + offset // Current
+            };
+    }
+}