diff --git a/.gitignore b/.gitignore
index f4faab088a..b8b277c7c3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,3 +39,5 @@ MODULE.bazel
MODULE.bazel.lock
.DS_Store
**/.DS_Store
+csharp/**/bin
+csharp/**/obj
diff --git a/csharp/.csharpierrc.yaml b/csharp/.csharpierrc.yaml
new file mode 100644
index 0000000000..ef96c2d0a0
--- /dev/null
+++ b/csharp/.csharpierrc.yaml
@@ -0,0 +1 @@
+printWidth: 160
diff --git a/csharp/Fury.Testing/Fury.Testing.csproj b/csharp/Fury.Testing/Fury.Testing.csproj
new file mode 100644
index 0000000000..353da2b7d7
--- /dev/null
+++ b/csharp/Fury.Testing/Fury.Testing.csproj
@@ -0,0 +1,33 @@
+
+
+
+
+ net8.0
+ enable
+ enable
+ 12
+ false
+ true
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/csharp/Fury.Testing/MetaStringTest.cs b/csharp/Fury.Testing/MetaStringTest.cs
new file mode 100644
index 0000000000..1316e75239
--- /dev/null
+++ b/csharp/Fury.Testing/MetaStringTest.cs
@@ -0,0 +1,253 @@
+using System.Text;
+using Bogus;
+using Fury.Context;
+using Fury.Meta;
+
+namespace Fury.Testing;
+
+public sealed class MetaStringTest
+{
+ public static readonly IEnumerable Lengths = Enumerable.Range(0, 9).Select(i => new object[] { i });
+
+ private static readonly string LowerSpecialChars = Enumerable
+ .Range(0, 1 << AbstractLowerSpecialEncoding.BitsPerChar)
+ .Select(i => (AbstractLowerSpecialEncoding.TryDecodeByte((byte)i, out var c), c))
+ .Where(t => t.Item1)
+ .Aggregate(new StringBuilder(), (builder, t) => builder.Append(t.c))
+ .ToString();
+
+ private static readonly string AllToLowerSpecialChars = Enumerable
+ .Range(0, 1 << AbstractLowerSpecialEncoding.BitsPerChar)
+ .Select(i => (AbstractLowerSpecialEncoding.TryDecodeByte((byte)i, out var c), c))
+ .Where(t => t.Item1 && t.c != AllToLowerSpecialEncoding.UpperCaseFlag)
+ .Aggregate(new StringBuilder(), (builder, t) => builder.Append(t.c).Append(char.ToUpperInvariant(t.c)))
+ .ToString();
+
+ private static readonly string TypeNameLowerUpperDigitSpecialChars = Enumerable
+ .Range(0, 1 << LowerUpperDigitSpecialEncoding.BitsPerChar)
+ .Select(i => (MetaStringStorage.NameEncoding.LowerUpperDigit.TryDecodeByte((byte)i, out var c), c))
+ .Where(t => t.Item1 && char.IsLetterOrDigit(t.c))
+ .Aggregate(new StringBuilder(), (builder, t) => builder.Append(t.c))
+ .ToString();
+
+ private static readonly string NamespaceLowerUpperDigitSpecialChars = Enumerable
+ .Range(0, 1 << LowerUpperDigitSpecialEncoding.BitsPerChar)
+ .Select(i => (MetaStringStorage.NamespaceEncoding.LowerUpperDigit.TryDecodeByte((byte)i, out var c), c))
+ .Where(t => t.Item1 && char.IsLetterOrDigit(t.c))
+ .Aggregate(new StringBuilder(), (builder, t) => builder.Append(t.c))
+ .ToString();
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void LowerSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, LowerSpecialChars);
+
+ var bufferLength = LowerSpecialEncoding.Instance.GetByteCount(stubString);
+ Span buffer = stackalloc byte[bufferLength];
+ LowerSpecialEncoding.Instance.GetBytes(stubString, buffer);
+ var output = LowerSpecialEncoding.Instance.GetString(buffer);
+
+ Assert.Equal(stubString, output);
+ }
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void LowerSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, LowerSpecialChars);
+
+ var bufferLength = LowerSpecialEncoding.Instance.GetByteCount(stubString);
+ Span bytes = stackalloc byte[bufferLength];
+ Span chars = stackalloc char[stubString.Length];
+ LowerSpecialEncoding.Instance.GetBytes(stubString, bytes);
+ var decoder = LowerSpecialEncoding.Instance.GetDecoder();
+ var emptyChars = chars;
+ for (var i = 0; i < bytes.Length; i++)
+ {
+ var slicedBytes = bytes.Slice(i, 1);
+ decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+ emptyChars = emptyChars.Slice(charsUsed);
+ }
+
+ var output = chars.ToString();
+
+ Assert.Equal(stubString, output);
+ }
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void FirstToLowerSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, LowerSpecialChars);
+ if (stubString.Length > 0 && char.IsLower(stubString[0]))
+ {
+ Span stubSpan = stackalloc char[stubString.Length];
+ stubString.AsSpan().CopyTo(stubSpan);
+ stubSpan[0] = char.ToUpperInvariant(stubSpan[0]);
+ stubString = stubSpan.ToString();
+ }
+
+ var bufferLength = FirstToLowerSpecialEncoding.Instance.GetByteCount(stubString);
+ Span buffer = stackalloc byte[bufferLength];
+ FirstToLowerSpecialEncoding.Instance.GetBytes(stubString, buffer);
+ var output = FirstToLowerSpecialEncoding.Instance.GetString(buffer);
+
+ Assert.Equal(stubString, output);
+ }
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void FirstToLowerSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, LowerSpecialChars);
+ if (stubString.Length > 0 && char.IsLower(stubString[0]))
+ {
+ Span stubSpan = stackalloc char[stubString.Length];
+ stubString.AsSpan().CopyTo(stubSpan);
+ stubSpan[0] = char.ToUpperInvariant(stubSpan[0]);
+ stubString = stubSpan.ToString();
+ }
+
+ var bufferLength = FirstToLowerSpecialEncoding.Instance.GetByteCount(stubString);
+ Span bytes = stackalloc byte[bufferLength];
+ Span chars = stackalloc char[stubString.Length];
+ FirstToLowerSpecialEncoding.Instance.GetBytes(stubString, bytes);
+ var decoder = FirstToLowerSpecialEncoding.Instance.GetDecoder();
+ var emptyChars = chars;
+ for (var i = 0; i < bytes.Length; i++)
+ {
+ var slicedBytes = bytes.Slice(i, 1);
+ decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+ emptyChars = emptyChars.Slice(charsUsed);
+ }
+
+ var output = chars.ToString();
+
+ Assert.Equal(stubString, output);
+ }
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void AllToLowerSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, AllToLowerSpecialChars);
+
+ var bufferLength = AllToLowerSpecialEncoding.Instance.GetByteCount(stubString);
+ Span buffer = stackalloc byte[bufferLength];
+ AllToLowerSpecialEncoding.Instance.GetBytes(stubString, buffer);
+ var output = AllToLowerSpecialEncoding.Instance.GetString(buffer);
+
+ Assert.Equal(stubString, output);
+ }
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void AllToLowerSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, AllToLowerSpecialChars);
+
+ var bufferLength = AllToLowerSpecialEncoding.Instance.GetByteCount(stubString);
+ Span bytes = stackalloc byte[bufferLength];
+ Span chars = stackalloc char[stubString.Length];
+ AllToLowerSpecialEncoding.Instance.GetBytes(stubString, bytes);
+ var decoder = AllToLowerSpecialEncoding.Instance.GetDecoder();
+ var emptyChars = chars;
+ for (var i = 0; i < bytes.Length; i++)
+ {
+ var slicedBytes = bytes.Slice(i, 1);
+ decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+ emptyChars = emptyChars.Slice(charsUsed);
+ }
+
+ var output = chars.ToString();
+
+ Assert.Equal(stubString, output);
+ }
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void TypeNameLowerUpperDigitSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, TypeNameLowerUpperDigitSpecialChars);
+
+ var bufferLength = MetaStringStorage.NameEncoding.LowerUpperDigit.GetByteCount(stubString);
+ Span buffer = stackalloc byte[bufferLength];
+ MetaStringStorage.NameEncoding.LowerUpperDigit.GetBytes(stubString, buffer);
+ var output = MetaStringStorage.NameEncoding.LowerUpperDigit.GetString(buffer);
+
+ Assert.Equal(stubString, output);
+ }
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void TypeNameLowerUpperDigitSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, TypeNameLowerUpperDigitSpecialChars);
+
+ var bufferLength = MetaStringStorage.NameEncoding.LowerUpperDigit.GetByteCount(stubString);
+ Span bytes = stackalloc byte[bufferLength];
+ Span chars = stackalloc char[stubString.Length];
+ MetaStringStorage.NameEncoding.LowerUpperDigit.GetBytes(stubString, bytes);
+ var decoder = MetaStringStorage.NameEncoding.LowerUpperDigit.GetDecoder();
+ var emptyChars = chars;
+ for (var i = 0; i < bytes.Length; i++)
+ {
+ var slicedBytes = bytes.Slice(i, 1);
+ decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+ emptyChars = emptyChars.Slice(charsUsed);
+ }
+
+ var output = chars.ToString();
+
+ Assert.Equal(stubString, output);
+ }
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void NamespaceLowerUpperDigitSpecialEncoding_InputString_ShouldReturnTheSame(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, NamespaceLowerUpperDigitSpecialChars);
+
+ var bufferLength = MetaStringStorage.NamespaceEncoding.LowerUpperDigit.GetByteCount(stubString);
+ Span buffer = stackalloc byte[bufferLength];
+ MetaStringStorage.NamespaceEncoding.LowerUpperDigit.GetBytes(stubString, buffer);
+ var output = MetaStringStorage.NamespaceEncoding.LowerUpperDigit.GetString(buffer);
+
+ Assert.Equal(stubString, output);
+ }
+
+ [Theory]
+ [MemberData(nameof(Lengths))]
+ public void NamespaceLowerUpperDigitSpecialEncoding_InputSeparatedBytes_ShouldReturnConcatenatedString(int length)
+ {
+ var faker = new Faker();
+ var stubString = faker.Random.String2(length, NamespaceLowerUpperDigitSpecialChars);
+
+ var bufferLength = MetaStringStorage.NamespaceEncoding.LowerUpperDigit.GetByteCount(stubString);
+ Span bytes = stackalloc byte[bufferLength];
+ Span chars = stackalloc char[stubString.Length];
+ MetaStringStorage.NamespaceEncoding.LowerUpperDigit.GetBytes(stubString, bytes);
+ var decoder = MetaStringStorage.NamespaceEncoding.LowerUpperDigit.GetDecoder();
+ var emptyChars = chars;
+ for (var i = 0; i < bytes.Length; i++)
+ {
+ var slicedBytes = bytes.Slice(i, 1);
+ decoder.Convert(slicedBytes, emptyChars, i == bytes.Length - 1, out _, out var charsUsed, out _);
+ emptyChars = emptyChars.Slice(charsUsed);
+ }
+
+ var output = chars.ToString();
+
+ Assert.Equal(stubString, output);
+ }
+}
diff --git a/csharp/Fury.slnx b/csharp/Fury.slnx
new file mode 100644
index 0000000000..9379444e0a
--- /dev/null
+++ b/csharp/Fury.slnx
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/csharp/Fury/Backports/ArrayBufferWriter.cs b/csharp/Fury/Backports/ArrayBufferWriter.cs
new file mode 100644
index 0000000000..0a8c83941f
--- /dev/null
+++ b/csharp/Fury/Backports/ArrayBufferWriter.cs
@@ -0,0 +1,254 @@
+#if NETSTANDARD2_0
+using System.Diagnostics;
+using Fury;
+
+namespace System.Buffers;
+
+///
+/// Represents a heap-based, array-backed output sink into which data can be written.
+///
+internal sealed class ArrayBufferWriter : IBufferWriter
+{
+ // Copy of Array.MaxLength.
+ // Used by projects targeting .NET Framework.
+ private const int ArrayMaxLength = 0x7FFFFFC7;
+
+ private const int DefaultInitialBufferSize = 256;
+
+ private T[] _buffer;
+ private int _index;
+
+ ///
+ /// Creates an instance of an , in which data can be written to,
+ /// with the default initial capacity.
+ ///
+ public ArrayBufferWriter()
+ {
+ _buffer = Array.Empty();
+ _index = 0;
+ }
+
+ ///
+ /// Creates an instance of an , in which data can be written to,
+ /// with an initial capacity specified.
+ ///
+ /// The minimum capacity with which to initialize the underlying buffer.
+ ///
+ /// Thrown when is not positive (i.e. less than or equal to 0).
+ ///
+ public ArrayBufferWriter(int initialCapacity)
+ {
+ if (initialCapacity <= 0)
+ {
+ ThrowHelper.ThrowArgumentException(null, nameof(initialCapacity));
+ }
+
+ _buffer = new T[initialCapacity];
+ _index = 0;
+ }
+
+ ///
+ /// Returns the data written to the underlying buffer so far, as a .
+ ///
+ public ReadOnlyMemory WrittenMemory => _buffer.AsMemory(0, _index);
+
+ ///
+ /// Returns the data written to the underlying buffer so far, as a .
+ ///
+ public ReadOnlySpan WrittenSpan => _buffer.AsSpan(0, _index);
+
+ ///
+ /// Returns the amount of data written to the underlying buffer so far.
+ ///
+ public int WrittenCount => _index;
+
+ ///
+ /// Returns the total amount of space within the underlying buffer.
+ ///
+ public int Capacity => _buffer.Length;
+
+ ///
+ /// Returns the amount of space available that can still be written into without forcing the underlying buffer to grow.
+ ///
+ public int FreeCapacity => _buffer.Length - _index;
+
+ ///
+ /// Clears the data written to the underlying buffer.
+ ///
+ ///
+ ///
+ /// You must reset or clear the before trying to re-use it.
+ ///
+ ///
+ /// The method is faster since it only sets to zero the writer's index
+ /// while the method additionally zeroes the content of the underlying buffer.
+ ///
+ ///
+ ///
+ public void Clear()
+ {
+ Debug.Assert(_buffer.Length >= _index);
+ _buffer.AsSpan(0, _index).Clear();
+ _index = 0;
+ }
+
+ ///
+ /// Resets the data written to the underlying buffer without zeroing its content.
+ ///
+ ///
+ ///
+ /// You must reset or clear the before trying to re-use it.
+ ///
+ ///
+ /// If you reset the writer using the method, the underlying buffer will not be cleared.
+ ///
+ ///
+ ///
+ public void ResetWrittenCount() => _index = 0;
+
+ ///
+ /// Notifies that amount of data was written to the output /
+ ///
+ ///
+ /// Thrown when is negative.
+ ///
+ ///
+ /// Thrown when attempting to advance past the end of the underlying buffer.
+ ///
+ ///
+ /// You must request a new buffer after calling Advance to continue writing more data and cannot write to a previously acquired buffer.
+ ///
+ public void Advance(int count)
+ {
+ if (count < 0)
+ {
+ ThrowHelper.ThrowArgumentException(null, nameof(count));
+ }
+
+ if (_index > _buffer.Length - count)
+ {
+ ThrowInvalidOperationException_AdvancedTooFar(_buffer.Length);
+ }
+
+ _index += count;
+ }
+
+ ///
+ /// Returns a to write to that is at least the requested length (specified by ).
+ /// If no is provided (or it's equal to 0), some non-empty buffer is returned.
+ ///
+ ///
+ /// Thrown when is negative.
+ ///
+ ///
+ ///
+ /// This will never return an empty .
+ ///
+ ///
+ /// There is no guarantee that successive calls will return the same buffer or the same-sized buffer.
+ ///
+ ///
+ /// You must request a new buffer after calling Advance to continue writing more data and cannot write to a previously acquired buffer.
+ ///
+ ///
+ /// If you reset the writer using the method, this method may return a non-cleared .
+ ///
+ ///
+ /// If you clear the writer using the method, this method will return a with its content zeroed.
+ ///
+ ///
+ public Memory GetMemory(int sizeHint = 0)
+ {
+ CheckAndResizeBuffer(sizeHint);
+ Debug.Assert(_buffer.Length > _index);
+ return _buffer.AsMemory(_index);
+ }
+
+ ///
+ /// Returns a to write to that is at least the requested length (specified by ).
+ /// If no is provided (or it's equal to 0), some non-empty buffer is returned.
+ ///
+ ///
+ /// Thrown when is negative.
+ ///
+ ///
+ ///
+ /// This will never return an empty .
+ ///
+ ///
+ /// There is no guarantee that successive calls will return the same buffer or the same-sized buffer.
+ ///
+ ///
+ /// You must request a new buffer after calling Advance to continue writing more data and cannot write to a previously acquired buffer.
+ ///
+ ///
+ /// If you reset the writer using the method, this method may return a non-cleared .
+ ///
+ ///
+ /// If you clear the writer using the method, this method will return a with its content zeroed.
+ ///
+ ///
+ public Span GetSpan(int sizeHint = 0)
+ {
+ CheckAndResizeBuffer(sizeHint);
+ Debug.Assert(_buffer.Length > _index);
+ return _buffer.AsSpan(_index);
+ }
+
+ private void CheckAndResizeBuffer(int sizeHint)
+ {
+ if (sizeHint < 0)
+ {
+ ThrowHelper.ThrowArgumentException(null, nameof(sizeHint));
+ }
+
+ if (sizeHint == 0)
+ {
+ sizeHint = 1;
+ }
+
+ if (sizeHint > FreeCapacity)
+ {
+ int currentLength = _buffer.Length;
+
+ // Attempt to grow by the larger of the sizeHint and double the current size.
+ int growBy = Math.Max(sizeHint, currentLength);
+
+ if (currentLength == 0)
+ {
+ growBy = Math.Max(growBy, DefaultInitialBufferSize);
+ }
+
+ int newSize = currentLength + growBy;
+
+ if ((uint)newSize > int.MaxValue)
+ {
+ // Attempt to grow to ArrayMaxLength.
+ uint needed = (uint)(currentLength - FreeCapacity + sizeHint);
+ Debug.Assert(needed > currentLength);
+
+ if (needed > ArrayMaxLength)
+ {
+ ThrowOutOfMemoryException(needed);
+ }
+
+ newSize = ArrayMaxLength;
+ }
+
+ Array.Resize(ref _buffer, newSize);
+ }
+
+ Debug.Assert(FreeCapacity > 0 && FreeCapacity >= sizeHint);
+ }
+
+ private static void ThrowInvalidOperationException_AdvancedTooFar(int capacity)
+ {
+ throw new InvalidOperationException($"Cannot advance past the end of the underlying buffer which has a capacity of {capacity}.");
+ }
+
+ private static void ThrowOutOfMemoryException(uint capacity)
+ {
+ throw new OutOfMemoryException($"Cannot allocate an array of {capacity} elements.");
+ }
+}
+#endif
diff --git a/csharp/Fury/Backports/BitOperations.cs b/csharp/Fury/Backports/BitOperations.cs
new file mode 100644
index 0000000000..89577ba955
--- /dev/null
+++ b/csharp/Fury/Backports/BitOperations.cs
@@ -0,0 +1,21 @@
+#if !NET8_0_OR_GREATER
+using System.Runtime.CompilerServices;
+
+// ReSharper disable once CheckNamespace
+namespace System.Numerics;
+
+internal static class BitOperations
+{
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static ulong RotateLeft(ulong value, int offset) => (value << offset) | (value >> (64 - offset));
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static uint RotateLeft(uint value, int offset) => (value << offset) | (value >> (32 - offset));
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static ulong RotateRight(ulong value, int offset) => (value >> offset) | (value << (64 - offset));
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static uint RotateRight(uint value, int offset) => (value >> offset) | (value << (32 - offset));
+}
+#endif
diff --git a/csharp/Fury/Backports/EncodingExtensions.cs b/csharp/Fury/Backports/EncodingExtensions.cs
new file mode 100644
index 0000000000..b51a7f654a
--- /dev/null
+++ b/csharp/Fury/Backports/EncodingExtensions.cs
@@ -0,0 +1,64 @@
+#if !NET8_0_OR_GREATER
+using System;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace Fury;
+
+internal static class EncodingExtensions
+{
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static unsafe void Convert(
+ this Encoder encoder,
+ ReadOnlySpan chars,
+ Span bytes,
+ bool flush,
+ out int charsUsed,
+ out int bytesUsed,
+ out bool completed
+ )
+ {
+ fixed (char* pChars = chars)
+ fixed (byte* pBytes = bytes)
+ {
+ encoder.Convert(
+ pChars,
+ chars.Length,
+ pBytes,
+ bytes.Length,
+ flush,
+ out charsUsed,
+ out bytesUsed,
+ out completed
+ );
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static unsafe void Convert(
+ this Decoder decoder,
+ ReadOnlySpan bytes,
+ Span chars,
+ bool flush,
+ out int bytesUsed,
+ out int charsUsed,
+ out bool completed
+ )
+ {
+ fixed (byte* pBytes = bytes)
+ fixed (char* pChars = chars)
+ {
+ decoder.Convert(
+ pBytes,
+ bytes.Length,
+ pChars,
+ chars.Length,
+ flush,
+ out bytesUsed,
+ out charsUsed,
+ out completed
+ );
+ }
+ }
+}
+#endif
diff --git a/csharp/Fury/Backports/Lock.cs b/csharp/Fury/Backports/Lock.cs
new file mode 100644
index 0000000000..a7baefa777
--- /dev/null
+++ b/csharp/Fury/Backports/Lock.cs
@@ -0,0 +1,5 @@
+#if !NET9_0_OR_GREATER
+namespace System.Threading;
+
+internal sealed class Lock;
+#endif
diff --git a/csharp/Fury/Backports/MethodInfoExtensions.cs b/csharp/Fury/Backports/MethodInfoExtensions.cs
new file mode 100644
index 0000000000..46ab35150b
--- /dev/null
+++ b/csharp/Fury/Backports/MethodInfoExtensions.cs
@@ -0,0 +1,13 @@
+#if !NET5_0_OR_GREATER
+using System;
+using System.Reflection;
+
+namespace Fury;
+
+internal static class MethodInfoExtensions
+{
+
+ /// Creates a delegate of the given type 'T' from this method.
+ public static T CreateDelegate(this MethodInfo methodInfo) where T : Delegate => (T)methodInfo.CreateDelegate(typeof(T));
+}
+#endif
diff --git a/csharp/Fury/Backports/NotReturnAttributes.cs b/csharp/Fury/Backports/NotReturnAttributes.cs
new file mode 100644
index 0000000000..8b12c14c81
--- /dev/null
+++ b/csharp/Fury/Backports/NotReturnAttributes.cs
@@ -0,0 +1,7 @@
+#if !NET8_0_OR_GREATER
+// ReSharper disable once CheckNamespace
+namespace System.Diagnostics.CodeAnalysis;
+
+[AttributeUsage(AttributeTargets.Method, Inherited = false)]
+internal class DoesNotReturnAttribute : Attribute;
+#endif
diff --git a/csharp/Fury/Backports/NullableAttributes.cs b/csharp/Fury/Backports/NullableAttributes.cs
new file mode 100644
index 0000000000..63ee28754b
--- /dev/null
+++ b/csharp/Fury/Backports/NullableAttributes.cs
@@ -0,0 +1,64 @@
+#if NETSTANDARD
+// ReSharper disable once CheckNamespace
+namespace System.Diagnostics.CodeAnalysis;
+
+/// Specifies that when a method returns , the parameter will not be even if the corresponding type allows it.
+[AttributeUsage(AttributeTargets.Parameter)]
+internal sealed class NotNullWhenAttribute : Attribute
+{
+ /// Initializes the attribute with the specified return value condition.
+ /// The return value condition. If the method returns this value, the associated parameter will not be .
+ public NotNullWhenAttribute(bool returnValue) => this.ReturnValue = returnValue;
+
+ /// Gets the return value condition.
+ /// The return value condition. If the method returns this value, the associated parameter will not be .
+ public bool ReturnValue { get; }
+}
+
+/// Specifies that the method will not return if the associated parameter is passed the specified value.
+[AttributeUsage(AttributeTargets.Parameter)]
+internal sealed class DoesNotReturnIfAttribute : Attribute
+{
+ /// Initializes a new instance of the class with the specified parameter value.
+ /// The condition parameter value. Code after the method is considered unreachable by diagnostics if the argument to the associated parameter matches this value.
+ public DoesNotReturnIfAttribute(bool parameterValue) => this.ParameterValue = parameterValue;
+
+ /// Gets the condition parameter value.
+ /// The condition parameter value. Code after the method is considered unreachable by diagnostics if the argument to the associated parameter matches this value.
+ public bool ParameterValue { get; }
+}
+
+/// Specifies that the method or property will ensure that the listed field and property members have not-null values.
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
+internal sealed class MemberNotNullAttribute : Attribute
+{
+ /// Initializes the attribute with a field or property member.
+ ///
+ /// The field or property member that is promised to be not-null.
+ ///
+ public MemberNotNullAttribute(string member) => Members = new[] { member };
+
+ /// Initializes the attribute with the list of field and property members.
+ ///
+ /// The list of field and property members that are promised to be not-null.
+ ///
+ public MemberNotNullAttribute(params string[] members) => Members = members;
+
+ /// Gets field or property member names.
+ public string[] Members { get; }
+}
+
+/// Specifies that when a method returns , the parameter may be null even if the corresponding type disallows it.
+[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+internal sealed class MaybeNullWhenAttribute : Attribute
+{
+ /// Initializes the attribute with the specified return value condition.
+ ///
+ /// The return value condition. If the method returns this value, the associated parameter may be null.
+ ///
+ public MaybeNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
+
+ /// Gets the return value condition.
+ public bool ReturnValue { get; }
+}
+#endif
diff --git a/csharp/Fury/Backports/SequenceReader.cs b/csharp/Fury/Backports/SequenceReader.cs
new file mode 100644
index 0000000000..3658556b23
--- /dev/null
+++ b/csharp/Fury/Backports/SequenceReader.cs
@@ -0,0 +1,463 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// Copied and modified from System.Buffers.SequenceReader
+
+#if NETSTANDARD2_0
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+// ReSharper disable once CheckNamespace
+namespace System.Buffers;
+
+public ref struct SequenceReader
+ where T : unmanaged, IEquatable
+{
+ private SequencePosition _currentPosition;
+ private SequencePosition _nextPosition;
+ private bool _moreData;
+ private readonly long _length;
+
+ ///
+ /// Create a over the given .
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public SequenceReader(ReadOnlySequence sequence)
+ {
+ CurrentSpanIndex = 0;
+ Consumed = 0;
+ Sequence = sequence;
+ _currentPosition = sequence.Start;
+ _length = -1;
+
+ CurrentSpan = sequence.First.Span;
+ _nextPosition = sequence.GetPosition(CurrentSpan.Length);
+ _moreData = CurrentSpan.Length > 0;
+
+ if (!_moreData && !sequence.IsSingleSegment)
+ {
+ _moreData = true;
+ GetNextSpan();
+ }
+ }
+
+ ///
+ /// True when there is no more data in the .
+ ///
+ public readonly bool End => !_moreData;
+
+ ///
+ /// The underlying for the reader.
+ ///
+ public ReadOnlySequence Sequence { get; }
+
+ ///
+ /// Gets the unread portion of the .
+ ///
+ ///
+ /// The unread portion of the .
+ ///
+ public readonly ReadOnlySequence UnreadSequence => Sequence.Slice(Position);
+
+ ///
+ /// The current position in the .
+ ///
+ public readonly SequencePosition Position => Sequence.GetPosition(CurrentSpanIndex, _currentPosition);
+
+ ///
+ /// The current segment in the as a span.
+ ///
+ public ReadOnlySpan CurrentSpan { get; private set; }
+
+ ///
+ /// The index in the .
+ ///
+ public int CurrentSpanIndex { get; private set; }
+
+ ///
+ /// The unread portion of the .
+ ///
+ public readonly ReadOnlySpan UnreadSpan
+ {
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ get => CurrentSpan.Slice(CurrentSpanIndex);
+ }
+
+ ///
+ /// The total number of 's processed by the reader.
+ ///
+ public long Consumed { get; private set; }
+
+ ///
+ /// Remaining 's in the reader's .
+ ///
+ public readonly long Remaining => Length - Consumed;
+
+ ///
+ /// Count of in the reader's .
+ ///
+ public readonly long Length
+ {
+ get
+ {
+ if (_length < 0)
+ {
+ // Cast-away readonly to initialize lazy field
+ Unsafe.AsRef(in _length) = Sequence.Length;
+ }
+ return _length;
+ }
+ }
+
+ ///
+ /// Peeks at the next value without advancing the reader.
+ ///
+ /// The next value or default if at the end.
+ /// False if at the end of the reader.
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public readonly bool TryPeek(out T value)
+ {
+ if (_moreData)
+ {
+ value = CurrentSpan[CurrentSpanIndex];
+ return true;
+ }
+ else
+ {
+ value = default;
+ return false;
+ }
+ }
+
+ ///
+ /// Peeks at the next value at specific offset without advancing the reader.
+ ///
+ /// The offset from current position.
+ /// The next value, or the default value if at the end of the reader.
+ /// true if the reader is not at its end and the peek operation succeeded; false if at the end of the reader.
+ public readonly bool TryPeek(long offset, out T value)
+ {
+ if (offset < 0)
+ {
+ throw new ArgumentOutOfRangeException(nameof(offset));
+ }
+
+ // If we've got data and offset is not out of bounds
+ if (!_moreData || Remaining <= offset)
+ {
+ value = default;
+ return false;
+ }
+
+ // Sum CurrentSpanIndex + offset could overflow as is but the value of offset should be very large
+ // because we check Remaining <= offset above so to overflow we should have a ReadOnlySequence close to 8 exabytes
+ Debug.Assert(CurrentSpanIndex + offset >= 0);
+
+ // If offset doesn't fall inside current segment move to next until we find correct one
+ if ((CurrentSpanIndex + offset) <= CurrentSpan.Length - 1)
+ {
+ Debug.Assert(offset <= int.MaxValue);
+
+ value = CurrentSpan[CurrentSpanIndex + (int)offset];
+ return true;
+ }
+ else
+ {
+ long remainingOffset = offset - (CurrentSpan.Length - CurrentSpanIndex);
+ SequencePosition nextPosition = _nextPosition;
+ ReadOnlyMemory currentMemory;
+
+ while (Sequence.TryGet(ref nextPosition, out currentMemory, advance: true))
+ {
+ // Skip empty segment
+ if (currentMemory.Length > 0)
+ {
+ if (remainingOffset >= currentMemory.Length)
+ {
+ // Subtract current non consumed data
+ remainingOffset -= currentMemory.Length;
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+
+ value = currentMemory.Span[(int)remainingOffset];
+ return true;
+ }
+ }
+
+ ///
+ /// Read the next value and advance the reader.
+ ///
+ /// The next value or default if at the end.
+ /// False if at the end of the reader.
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public bool TryRead(out T value)
+ {
+ if (End)
+ {
+ value = default;
+ return false;
+ }
+
+ value = CurrentSpan[CurrentSpanIndex];
+ CurrentSpanIndex++;
+ Consumed++;
+
+ if (CurrentSpanIndex >= CurrentSpan.Length)
+ {
+ GetNextSpan();
+ }
+
+ return true;
+ }
+
+ ///
+ /// Move the reader back the specified number of items.
+ ///
+ ///
+ /// Thrown if trying to rewind a negative amount or more than .
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public void Rewind(long count)
+ {
+ if ((ulong)count > (ulong)Consumed)
+ {
+ throw new ArgumentOutOfRangeException(nameof(count));
+ }
+
+ if (count == 0)
+ {
+ return;
+ }
+
+ Consumed -= count;
+
+ if (CurrentSpanIndex >= count)
+ {
+ CurrentSpanIndex -= (int)count;
+ _moreData = true;
+ }
+ else
+ {
+ // Current segment doesn't have enough data, scan backward through segments
+ RetreatToPreviousSpan(Consumed);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private void RetreatToPreviousSpan(long consumed)
+ {
+ ResetReader();
+ Advance(consumed);
+ }
+
+ private void ResetReader()
+ {
+ CurrentSpanIndex = 0;
+ Consumed = 0;
+ _currentPosition = Sequence.Start;
+ _nextPosition = _currentPosition;
+
+ if (Sequence.TryGet(ref _nextPosition, out ReadOnlyMemory memory, advance: true))
+ {
+ _moreData = true;
+
+ if (memory.Length == 0)
+ {
+ CurrentSpan = default;
+ // No data in the first span, move to one with data
+ GetNextSpan();
+ }
+ else
+ {
+ CurrentSpan = memory.Span;
+ }
+ }
+ else
+ {
+ // No data in any spans and at end of sequence
+ _moreData = false;
+ CurrentSpan = default;
+ }
+ }
+
+ ///
+ /// Get the next segment with available data, if any.
+ ///
+ private void GetNextSpan()
+ {
+ if (!Sequence.IsSingleSegment)
+ {
+ SequencePosition previousNextPosition = _nextPosition;
+ while (Sequence.TryGet(ref _nextPosition, out ReadOnlyMemory memory, advance: true))
+ {
+ _currentPosition = previousNextPosition;
+ if (memory.Length > 0)
+ {
+ CurrentSpan = memory.Span;
+ CurrentSpanIndex = 0;
+ return;
+ }
+ else
+ {
+ CurrentSpan = default;
+ CurrentSpanIndex = 0;
+ previousNextPosition = _nextPosition;
+ }
+ }
+ }
+ _moreData = false;
+ }
+
+ ///
+ /// Move the reader ahead the specified number of items.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public void Advance(long count)
+ {
+ const long TooBigOrNegative = unchecked((long)0xFFFFFFFF80000000);
+ if ((count & TooBigOrNegative) == 0 && CurrentSpan.Length - CurrentSpanIndex > (int)count)
+ {
+ CurrentSpanIndex += (int)count;
+ Consumed += count;
+ }
+ else
+ {
+ // Can't satisfy from the current span
+ AdvanceToNextSpan(count);
+ }
+ }
+
+ ///
+ /// Unchecked helper to avoid unnecessary checks where you know count is valid.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ internal void AdvanceCurrentSpan(long count)
+ {
+ Debug.Assert(count >= 0);
+
+ Consumed += count;
+ CurrentSpanIndex += (int)count;
+ if (CurrentSpanIndex >= CurrentSpan.Length)
+ GetNextSpan();
+ }
+
+ ///
+ /// Only call this helper if you know that you are advancing in the current span
+ /// with valid count and there is no need to fetch the next one.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ internal void AdvanceWithinSpan(long count)
+ {
+ Debug.Assert(count >= 0);
+
+ Consumed += count;
+ CurrentSpanIndex += (int)count;
+
+ Debug.Assert(CurrentSpanIndex < CurrentSpan.Length);
+ }
+
+ private void AdvanceToNextSpan(long count)
+ {
+ if (count < 0)
+ {
+ throw new ArgumentOutOfRangeException(nameof(count));
+ }
+
+ Consumed += count;
+ while (_moreData)
+ {
+ int remaining = CurrentSpan.Length - CurrentSpanIndex;
+
+ if (remaining > count)
+ {
+ CurrentSpanIndex += (int)count;
+ count = 0;
+ break;
+ }
+
+ // As there may not be any further segments we need to
+ // push the current index to the end of the span.
+ CurrentSpanIndex += remaining;
+ count -= remaining;
+ Debug.Assert(count >= 0);
+
+ GetNextSpan();
+
+ if (count == 0)
+ {
+ break;
+ }
+ }
+
+ if (count != 0)
+ {
+ // Not enough data left- adjust for where we actually ended and throw
+ Consumed -= count;
+ throw new ArgumentOutOfRangeException(nameof(count));
+ }
+ }
+
+ ///
+ /// Copies data from the current to the given span if there
+ /// is enough data to fill it.
+ ///
+ ///
+ /// This API is used to copy a fixed amount of data out of the sequence if possible. It does not advance
+ /// the reader. To look ahead for a specific stream of data can be used.
+ ///
+ /// Destination span to copy to.
+ /// True if there is enough data to completely fill the span.
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public readonly bool TryCopyTo(Span destination)
+ {
+ // This API doesn't advance to facilitate conditional advancement based on the data returned.
+ // We don't provide an advance option to allow easier utilizing of stack allocated destination spans.
+ // (Because we can make this method readonly we can guarantee that we won't capture the span.)
+
+ ReadOnlySpan firstSpan = UnreadSpan;
+ if (firstSpan.Length >= destination.Length)
+ {
+ firstSpan.Slice(0, destination.Length).CopyTo(destination);
+ return true;
+ }
+
+ // Not enough in the current span to satisfy the request, fall through to the slow path
+ return TryCopyMultisegment(destination);
+ }
+
+ internal readonly bool TryCopyMultisegment(Span destination)
+ {
+ // If we don't have enough to fill the requested buffer, return false
+ if (Remaining < destination.Length)
+ return false;
+
+ ReadOnlySpan firstSpan = UnreadSpan;
+ Debug.Assert(firstSpan.Length < destination.Length);
+ firstSpan.CopyTo(destination);
+ int copied = firstSpan.Length;
+
+ SequencePosition next = _nextPosition;
+ while (Sequence.TryGet(ref next, out ReadOnlyMemory nextSegment, true))
+ {
+ if (nextSegment.Length > 0)
+ {
+ ReadOnlySpan nextSpan = nextSegment.Span;
+ int toCopy = Math.Min(nextSpan.Length, destination.Length - copied);
+ nextSpan.Slice(0, toCopy).CopyTo(destination.Slice(copied));
+ copied += toCopy;
+ if (copied >= destination.Length)
+ {
+ break;
+ }
+ }
+ }
+
+ return true;
+ }
+}
+#endif
diff --git a/csharp/Fury/Backports/SpanAction.cs b/csharp/Fury/Backports/SpanAction.cs
new file mode 100644
index 0000000000..15c878cde2
--- /dev/null
+++ b/csharp/Fury/Backports/SpanAction.cs
@@ -0,0 +1,5 @@
+#if !NET5_0_OR_GREATER && !NETSTANDARD2_1
+// ReSharper disable once CheckNamespace
+namespace System.Buffers;
+internal delegate void SpanAction(Span span, TArg arg);
+#endif
diff --git a/csharp/Fury/Buffers/ObjectPool.cs b/csharp/Fury/Buffers/ObjectPool.cs
new file mode 100644
index 0000000000..4a97778f13
--- /dev/null
+++ b/csharp/Fury/Buffers/ObjectPool.cs
@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+
+namespace Fury.Buffers;
+
+// Copy and modify from Microsoft.Extensions.ObjectPool.DefaultObjectPool
+
+///
+/// The type to pool objects for.
+///
+///
+/// This implementation keeps a cache of retained objects.
+/// This means that if objects are returned when the pool has already reached
+/// "maximumRetained" objects they will be available to be Garbage Collected.
+///
+internal sealed class ObjectPool : IDisposable
+ where T : class
+{
+ private readonly Func _factory;
+
+ private readonly int _maxCapacity;
+ private int _numItems;
+
+ private readonly ConcurrentQueue _items = new();
+ private T? _fastItem;
+
+ ///
+ /// Creates an instance of .
+ ///
+ public ObjectPool(Func factory)
+ : this(factory, Environment.ProcessorCount * 2) { }
+
+ ///
+ /// Creates an instance of .
+ ///
+ ///
+ /// The factory method to create new instances of .
+ ///
+ ///
+ /// The maximum number of objects to retain in the pool.
+ ///
+ public ObjectPool(Func factory, int maximumRetained)
+ {
+ _factory = factory;
+ _maxCapacity = maximumRetained - 1; // -1 to account for _fastItem
+ }
+
+ public void Return(T obj)
+ {
+ if (_fastItem == null && Interlocked.CompareExchange(ref _fastItem, obj, null) == null)
+ {
+ return;
+ }
+
+ if (Interlocked.Increment(ref _numItems) <= _maxCapacity)
+ {
+ _items.Enqueue(obj);
+ }
+
+ // no room, clean up the count and drop the object on the floor
+ Interlocked.Decrement(ref _numItems);
+ }
+
+ public T Rent()
+ {
+ var item = _fastItem;
+ if (item != null && Interlocked.CompareExchange(ref _fastItem, null, item) == item)
+ {
+ return item;
+ }
+
+ if (_items.TryDequeue(out item))
+ {
+ Interlocked.Decrement(ref _numItems);
+ return item;
+ }
+
+ return _factory();
+ }
+
+ public void Dispose()
+ {
+ if (_fastItem is IDisposable disposableFastItem)
+ {
+ disposableFastItem.Dispose();
+ }
+
+ while (_items.TryDequeue(out var item))
+ {
+ if (item is IDisposable disposableItem)
+ {
+ disposableItem.Dispose();
+ }
+ }
+ }
+}
diff --git a/csharp/Fury/Buffers/UnmanagedToByteArrayMemoryManager.cs b/csharp/Fury/Buffers/UnmanagedToByteArrayMemoryManager.cs
new file mode 100644
index 0000000000..7c073dfc21
--- /dev/null
+++ b/csharp/Fury/Buffers/UnmanagedToByteArrayMemoryManager.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Buffers;
+using System.Runtime.InteropServices;
+
+namespace Fury.Buffers;
+
+internal sealed class UnmanagedToByteArrayMemoryManager(TElement[] array) : MemoryManager
+ where TElement : unmanaged
+{
+ protected override void Dispose(bool disposing) { }
+
+ public override Span GetSpan()
+ {
+ return MemoryMarshal.AsBytes(array.AsSpan());
+ }
+
+ public override MemoryHandle Pin(int elementIndex = 0)
+ {
+ throw new InvalidOperationException();
+ }
+
+ public override void Unpin()
+ {
+ throw new InvalidOperationException();
+ }
+}
diff --git a/csharp/Fury/Buffers/UnmanagedToByteListMemoryManager.cs b/csharp/Fury/Buffers/UnmanagedToByteListMemoryManager.cs
new file mode 100644
index 0000000000..899b32fecb
--- /dev/null
+++ b/csharp/Fury/Buffers/UnmanagedToByteListMemoryManager.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Fury.Buffers;
+
+#if NET5_0_OR_GREATER
+internal sealed class UnmanagedToByteListMemoryManager : MemoryManager
+ where TElement : unmanaged
+{
+ public List? List;
+
+ protected override void Dispose(bool disposing) { }
+
+ public override Span GetSpan()
+ {
+ return MemoryMarshal.AsBytes(CollectionsMarshal.AsSpan(List));
+ }
+
+ public override MemoryHandle Pin(int elementIndex = 0)
+ {
+ throw new InvalidOperationException();
+ }
+
+ public override void Unpin()
+ {
+ throw new InvalidOperationException();
+ }
+}
+#endif
diff --git a/csharp/Fury/Collections/AutoIncrementIdDictionary.cs b/csharp/Fury/Collections/AutoIncrementIdDictionary.cs
new file mode 100644
index 0000000000..a5ea2d7143
--- /dev/null
+++ b/csharp/Fury/Collections/AutoIncrementIdDictionary.cs
@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace Fury.Collections;
+
+internal sealed class AutoIncrementIdDictionary
+ where TValue : notnull
+{
+ private readonly Dictionary _valueToId = new();
+ private readonly SpannableList _idToValue = [];
+
+ public int this[TValue key] => _valueToId[key];
+
+ public TValue this[int id]
+ {
+ get
+ {
+ if (id < 0 || id >= _idToValue.Count)
+ {
+ ThrowHelper.ThrowArgumentOutOfRangeException(nameof(id));
+ }
+ return _idToValue[id];
+ }
+ set
+ {
+ if (id < 0 || id >= _idToValue.Count)
+ {
+ ThrowHelper.ThrowArgumentOutOfRangeException(nameof(id));
+ }
+
+ if (_valueToId.ContainsKey(value))
+ {
+ ThrowArgumentException_ValueAlreadyExists(value);
+ }
+ _idToValue[id] = value;
+ }
+ }
+
+ [DoesNotReturn]
+ private void ThrowArgumentException_ValueAlreadyExists(TValue value)
+ {
+ ThrowHelper.ThrowArgumentException(
+ $"The value '{value}' already exists in the {nameof(AutoIncrementIdDictionary)}.",
+ nameof(value)
+ );
+ }
+
+ public int GetOrAdd(in TValue value, out bool exists)
+ {
+ var nextId = _idToValue.Count;
+ var id = _valueToId.GetOrAdd(value, nextId, out exists);
+ if (!exists)
+ {
+ _idToValue.Add(value);
+ }
+
+ return id;
+ }
+
+ public bool Remove(TValue item)
+ {
+ ThrowHelper.ThrowNotSupportedException();
+ return false;
+ }
+
+ public void Clear()
+ {
+ _valueToId.Clear();
+ _idToValue.Clear();
+ }
+
+ public bool ContainsKey(TValue key)
+ {
+ return _valueToId.ContainsKey(key);
+ }
+
+ public bool ContainsKey(int key)
+ {
+ return key >= 0 && key < _idToValue.Count;
+ }
+
+ public void CopyTo(TValue[] array, int arrayIndex)
+ {
+ _idToValue.CopyTo(array, arrayIndex);
+ }
+
+ public bool TryGetValue(TValue key, out int value)
+ {
+ return _valueToId.TryGetValue(key, out value);
+ }
+
+ public bool TryGetValue(int key, out TValue value)
+ {
+ if (ContainsKey(key))
+ {
+ value = _idToValue[key];
+ return true;
+ }
+
+ value = default!;
+ return false;
+ }
+
+ public ref TValue GetValueRefOrNullRef(int key)
+ {
+ if (ContainsKey(key))
+ {
+ var values = _idToValue.AsSpan();
+ return ref values[key];
+ }
+
+ return ref Unsafe.NullRef();
+ }
+
+ public Enumerator GetEnumerator()
+ {
+ return new Enumerator(this);
+ }
+
+ public ref struct Enumerator(AutoIncrementIdDictionary idDictionary)
+ {
+ private int _index = -1;
+ private readonly Span _entries = idDictionary._idToValue.AsSpan();
+
+ public bool MoveNext()
+ {
+ return ++_index < _entries.Length;
+ }
+
+ public void Reset()
+ {
+ _index = -1;
+ }
+
+ public KeyValuePair Current => new(_index, _entries[_index]);
+ }
+}
diff --git a/csharp/Fury/Collections/DictionaryExtensions.cs b/csharp/Fury/Collections/DictionaryExtensions.cs
new file mode 100644
index 0000000000..4483f63dd3
--- /dev/null
+++ b/csharp/Fury/Collections/DictionaryExtensions.cs
@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Fury.Collections;
+
+internal static class DictionaryExtensions
+{
+ public static TValue GetOrAdd(
+ this Dictionary dictionary,
+ TKey key,
+ TValue value,
+ out bool exists
+ )
+ where TKey : notnull
+ where TValue : notnull
+ {
+#if NET8_0_OR_GREATER
+ ref var existingValue = ref CollectionsMarshal.GetValueRefOrAddDefault(dictionary, key, out exists);
+#else
+ exists = dictionary.TryGetValue(key, out var existingValue);
+#endif
+ if (exists)
+ {
+ return existingValue!;
+ }
+#if NET8_0_OR_GREATER
+ existingValue = value;
+#else
+ dictionary[key] = value;
+#endif
+ return value;
+ }
+
+ public static TValue GetOrAdd(
+ this Dictionary dictionary,
+ TKey key,
+ Func factory,
+ in TArg arg,
+ out bool exists
+ )
+ where TKey : notnull
+ where TValue : notnull
+ {
+#if NET8_0_OR_GREATER
+ ref var existingValue = ref CollectionsMarshal.GetValueRefOrAddDefault(dictionary, key, out exists);
+#else
+ exists = dictionary.TryGetValue(key, out var existingValue);
+#endif
+ if (!exists)
+ {
+ existingValue = factory(key, arg);
+#if !NET8_0_OR_GREATER
+ dictionary[key] = existingValue;
+#endif
+ }
+ return existingValue!;
+ }
+
+ public static TValue GetOrAdd(
+ this Dictionary dictionary,
+ TKey key,
+ Func factory,
+ out bool exists
+ )
+ where TKey : notnull
+ where TValue : notnull
+ {
+#if NET8_0_OR_GREATER
+ ref var existingValue = ref CollectionsMarshal.GetValueRefOrAddDefault(dictionary, key, out exists);
+#else
+ exists = dictionary.TryGetValue(key, out var existingValue);
+#endif
+ if (!exists)
+ {
+ existingValue = factory(key);
+#if !NET8_0_OR_GREATER
+ dictionary[key] = existingValue;
+#endif
+ }
+ return existingValue!;
+ }
+
+ public static TValue AddAndModify(
+ this Dictionary dictionary,
+ TKey key,
+ Func modifier,
+ in TState state,
+ out bool exists
+ )
+ where TKey : notnull
+ where TValue : notnull
+ {
+#if NET8_0_OR_GREATER
+ ref var existingValue = ref CollectionsMarshal.GetValueRefOrAddDefault(dictionary, key, out exists);
+ existingValue = modifier(key, existingValue, state);
+#else
+ exists = dictionary.TryGetValue(key, out var existingValue);
+ existingValue = modifier(key, existingValue, state);
+ dictionary[key] = existingValue;
+#endif
+ return existingValue;
+ }
+}
diff --git a/csharp/Fury/Collections/EnumerableExtensions.cs b/csharp/Fury/Collections/EnumerableExtensions.cs
new file mode 100644
index 0000000000..03f6cb38be
--- /dev/null
+++ b/csharp/Fury/Collections/EnumerableExtensions.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using JetBrains.Annotations;
+#if NET8_0_OR_GREATER
+using System.Collections.Immutable;
+using System.Runtime.InteropServices;
+#endif
+
+namespace Fury.Collections;
+
+internal static class EnumerableExtensions
+{
+#if !NET8_0_OR_GREATER
+ public static bool TryGetNonEnumeratedCount([NoEnumeration] this IEnumerable enumerable, out int count)
+ {
+ switch (enumerable)
+ {
+ case ICollection typedCollection:
+ count = typedCollection.Count;
+ return true;
+ case ICollection collection:
+ count = collection.Count;
+ return true;
+ case IReadOnlyCollection readOnlyCollection:
+ count = readOnlyCollection.Count;
+ return true;
+ default:
+ count = 0;
+ return false;
+ }
+ }
+#endif
+ public static bool TryGetSpan([NoEnumeration] this IEnumerable enumerable, out Span span)
+ {
+ switch (enumerable)
+ {
+ case T[] elements:
+ span = elements;
+ return true;
+#if NET8_0_OR_GREATER
+ case List elements:
+ span = CollectionsMarshal.AsSpan(elements);
+ return true;
+ case ImmutableArray elements:
+ span = ImmutableCollectionsMarshal.AsArray(elements);
+ return true;
+#endif
+ case PooledList elements:
+ span = elements.AsSpan();
+ return true;
+ default:
+ span = Span.Empty;
+ return false;
+ }
+ }
+}
diff --git a/csharp/Fury/Collections/PooledList.cs b/csharp/Fury/Collections/PooledList.cs
new file mode 100644
index 0000000000..6a36b584fb
--- /dev/null
+++ b/csharp/Fury/Collections/PooledList.cs
@@ -0,0 +1,217 @@
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Fury.Helpers;
+
+namespace Fury.Collections;
+
+///
+/// A list that uses pooled arrays to reduce allocations.
+///
+internal sealed class PooledList : IList, IDisposable
+{
+ private static readonly bool NeedClear = TypeHelper.IsReferenceOrContainsReferences;
+
+ private readonly ArrayPool _pool = ArrayPool.Shared;
+ private TElement[] _elements = [];
+ public int Count { get; private set; }
+
+ public PooledList() { }
+
+ public PooledList(int capacity)
+ {
+ _elements = _pool.Rent(capacity);
+ }
+
+ public PooledList(IEnumerable enumerable)
+ {
+ AddRange(enumerable);
+ }
+
+ private void EnsureCapacity(int capacity)
+ {
+ if (_elements.Length < capacity)
+ {
+ var newElements = _pool.Rent(capacity);
+ _elements.CopyTo(newElements, 0);
+ ClearElementsIfNeeded();
+ _pool.Return(_elements);
+ _elements = newElements;
+ }
+ }
+
+ public Enumerator GetEnumerator() => new(this);
+
+ public void Add(TElement item)
+ {
+ EnsureCapacity(Count + 1);
+ _elements[Count++] = item;
+ }
+
+ public void AddRange(IEnumerable elements)
+ {
+ if (elements.TryGetSpan(out var span))
+ {
+ AddRange(span);
+ return;
+ }
+
+ if (elements.TryGetNonEnumeratedCount(out var count))
+ {
+ EnsureCapacity(Count + count);
+ }
+ foreach (var element in elements)
+ {
+ Add(element);
+ }
+ }
+
+ public void AddRange(Span elements)
+ {
+ EnsureCapacity(Count + elements.Length);
+ elements.CopyTo(_elements.AsSpan(Count));
+ Count += elements.Length;
+ }
+
+ public void Clear()
+ {
+ ClearElementsIfNeeded();
+ Count = 0;
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private void ClearElementsIfNeeded()
+ {
+ if (NeedClear)
+ {
+ Array.Clear(_elements, 0, _elements.Length);
+ }
+ }
+
+ public bool Contains(TElement item) => Array.IndexOf(_elements, item) != -1;
+
+ public void CopyTo(TElement[] array, int arrayIndex) => _elements.CopyTo(array, arrayIndex);
+
+ public bool Remove(TElement item)
+ {
+ var index = Array.IndexOf(_elements, item);
+ if (index == -1)
+ {
+ return false;
+ }
+
+ RemoveAt(index);
+ return true;
+ }
+
+ public bool IsReadOnly => _elements.IsReadOnly;
+
+ public int IndexOf(TElement item) => Array.IndexOf(_elements, item);
+
+ public void Insert(int index, TElement item)
+ {
+ if (index < 0 || index > Count)
+ {
+ ThrowHelper.ThrowArgumentOutOfRangeException(nameof(index), index);
+ }
+
+ var length = _elements.Length;
+ if (Count == length)
+ {
+ var newLength = Math.Max(length * 2, StaticConfigs.BuiltInListDefaultCapacity);
+ var newElements = _pool.Rent(newLength);
+ _elements.CopyTo(newElements, 0);
+ Array.Copy(_elements, 0, newElements, 0, index);
+ newElements[index] = item;
+ Array.Copy(_elements, index, newElements, index + 1, Count - index);
+ ClearElementsIfNeeded();
+ _pool.Return(_elements);
+ _elements = newElements;
+ }
+ else
+ {
+ Array.Copy(_elements, index, _elements, index + 1, Count - index);
+ _elements[index] = item;
+ }
+ Count++;
+ }
+
+ public void RemoveAt(int index)
+ {
+ ThrowIfOutOfRange(index, nameof(index));
+
+ if (index < Count - 1)
+ {
+ Array.Copy(_elements, index + 1, _elements, index, Count - index - 1);
+ }
+ Count--;
+ _elements[Count] = default!;
+ }
+
+ public TElement this[int index]
+ {
+ get
+ {
+ ThrowIfOutOfRange(index, nameof(index));
+ return _elements[index];
+ }
+ set
+ {
+ ThrowIfOutOfRange(index, nameof(index));
+ _elements[index] = value;
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private void ThrowIfOutOfRange(int index, string paramName)
+ {
+ if (index < 0 || index >= Count)
+ {
+ ThrowHelper.ThrowArgumentOutOfRangeException(paramName, index);
+ }
+ }
+
+ IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+ IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+ public struct Enumerator(PooledList list) : IEnumerator
+ {
+ private int _count = list.Count;
+ private int _current = 0;
+
+ public bool MoveNext()
+ {
+ return _current++ < _count;
+ }
+
+ public void Reset()
+ {
+ _count = list.Count;
+ _current = 0;
+ }
+
+ public TElement Current => list._elements[_current];
+
+ object IEnumerator.Current => Current!;
+
+ public void Dispose() { }
+ }
+
+ public void Dispose()
+ {
+ if (_elements.Length <= 0)
+ {
+ return;
+ }
+
+ ClearElementsIfNeeded();
+ _pool.Return(_elements);
+ _elements = [];
+ }
+
+ public Span AsSpan() => _elements.AsSpan(0, Count);
+}
diff --git a/csharp/Fury/Collections/SpannableList.cs b/csharp/Fury/Collections/SpannableList.cs
new file mode 100644
index 0000000000..14fa9b2c61
--- /dev/null
+++ b/csharp/Fury/Collections/SpannableList.cs
@@ -0,0 +1,172 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Fury.Helpers;
+
+namespace Fury.Collections;
+
+internal sealed class SpannableList : IList, IReadOnlyList
+{
+ private static readonly bool NeedsClear = TypeHelper.IsReferenceOrContainsReferences;
+
+ private T[] _items = [];
+
+ public int Count { get; private set; }
+ public bool IsReadOnly => false;
+
+ public SpannableList() { }
+
+ public SpannableList(int capacity)
+ {
+ _items = new T[capacity];
+ }
+
+ public Enumerator GetEnumerator() => new(this);
+
+ IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+ IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+ private void EnsureCapacity(int requiredCapacity)
+ {
+ if (requiredCapacity <= _items.Length)
+ {
+ return;
+ }
+
+ var newCapacity = Math.Max(_items.Length * 2, requiredCapacity);
+ Array.Resize(ref _items, newCapacity);
+ }
+
+ void ICollection.Add(T item) => Add(in item);
+
+ public void Add(in T item)
+ {
+ EnsureCapacity(Count + 1);
+ _items[Count++] = item;
+ }
+
+ public void Clear()
+ {
+ if (NeedsClear)
+ {
+ Array.Clear(_items, 0, Count);
+ }
+ Count = 0;
+ }
+
+ public bool Contains(T item) => IndexOf(item) != -1;
+
+ public void CopyTo(T[] array, int arrayIndex)
+ {
+ Array.Copy(_items, 0, array, arrayIndex, Count);
+ }
+
+ bool ICollection.Remove(T item) => Remove(in item);
+
+ public bool Remove(in T item)
+ {
+ var index = IndexOf(item);
+ if (index == -1)
+ {
+ return false;
+ }
+
+ RemoveAt(index);
+ return true;
+ }
+
+ int IList.IndexOf(T item) => IndexOf(item);
+
+ public int IndexOf(in T item)
+ {
+ for (var i = 0; i < Count; i++)
+ {
+ if (EqualityComparer.Default.Equals(_items[i], item))
+ {
+ return i;
+ }
+ }
+
+ return -1;
+ }
+
+ void IList.Insert(int index, T item) => Insert(index, in item);
+
+ public void Insert(int index, in T item)
+ {
+ EnsureCapacity(Count + 1);
+ Array.Copy(_items, index, _items, index + 1, Count - index);
+ _items[index] = item;
+ Count++;
+ }
+
+ public void RemoveAt(int index)
+ {
+ if (NeedsClear)
+ {
+ _items[index] = default!;
+ }
+
+ Count--;
+ if (index < Count)
+ {
+ Array.Copy(_items, index + 1, _items, index, Count - index);
+ }
+ }
+
+ public ref T this[int index]
+ {
+ get
+ {
+ if (index < 0 || index >= Count)
+ {
+ ThrowHelper.ThrowIndexOutOfRangeException();
+ }
+
+ return ref _items[index];
+ }
+ }
+
+ T IReadOnlyList.this[int index] => this[index];
+
+ T IList.this[int index]
+ {
+ get => this[index];
+ set => this[index] = value;
+ }
+
+ public Span AsSpan() => new(_items, 0, Count);
+
+ public struct Enumerator() : IEnumerator
+ {
+ private int _index = -1;
+ private readonly SpannableList _list;
+ T IEnumerator.Current => _list[_index];
+ public ref T Current => ref _list[_index];
+
+ internal Enumerator(SpannableList list)
+ : this()
+ {
+ _list = list;
+ }
+
+ public bool MoveNext()
+ {
+ _index++;
+ return _index < _list.Count;
+ }
+
+ public void Reset()
+ {
+ _index = -1;
+ }
+
+ object? IEnumerator.Current => Current;
+
+ public void Dispose()
+ {
+ }
+ }
+}
diff --git a/csharp/Fury/Config.cs b/csharp/Fury/Config.cs
new file mode 100644
index 0000000000..82ac17dbc5
--- /dev/null
+++ b/csharp/Fury/Config.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using Fury.Serialization;
+
+namespace Fury;
+
+public sealed record FuryConfig(ITypeRegistrationProvider RegistrationProvider, TimeSpan LockTimeOut);
+
+public sealed record SerializationConfig(
+ bool ReferenceTracking,
+ IEnumerable PreferredStringEncodings,
+ bool WriteUtf16ByteCountForUtf8Encoding
+)
+{
+ public static readonly SerializationConfig Default = new(false, [StringEncoding.UTF8], false);
+};
+
+public sealed record DeserializationConfig(bool ReadUtf16ByteCountForUtf8Encoding)
+{
+ public static readonly DeserializationConfig Default = new(false);
+};
diff --git a/csharp/Fury/Context/BatchReader.cs b/csharp/Fury/Context/BatchReader.cs
new file mode 100644
index 0000000000..c7710de0c0
--- /dev/null
+++ b/csharp/Fury/Context/BatchReader.cs
@@ -0,0 +1,278 @@
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.IO.Pipelines;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Fury.Context;
+
+///
+/// The result of read operation.
+///
+///
+/// Indicates if the deserialization operation was successful.
+/// If true, the property will contain the deserialized value and
+/// the bytes will be consumed.
+/// Otherwise, the property will be the default value of and
+/// the bytes will be examined.
+///
+///
+/// The deserialized value. If is false, this will be the default value of .
+///
+///
+/// The type of the deserialized value.
+///
+public readonly struct ReadValueResult
+{
+ ///
+ /// Indicates if the deserialization operation was successful.
+ /// If true, the property will contain the deserialized value and
+ /// the bytes will be consumed.
+ /// Otherwise, the property will be the default value of and
+ /// the bytes will be examined.
+ ///
+ public bool IsSuccess { get; }
+
+ ///
+ /// The deserialized value. If is false, this will be the default value of .
+ ///
+ public TValue Value { get; }
+
+ public ReadValueResult()
+ {
+ IsSuccess = false;
+ Value = default!;
+ }
+
+ public ReadValueResult(in TValue value)
+ {
+ IsSuccess = true;
+ Value = value;
+ }
+
+ ///
+ /// Creates a successful with the provided value.
+ ///
+ ///
+ ///
+ public static ReadValueResult FromValue(in TValue value)
+ {
+ return new ReadValueResult(in value);
+ }
+
+ ///
+ /// A failed instance with the default value of .
+ ///
+ public static ReadValueResult Failed { get; } = new();
+}
+
+// ///
+// ///
+// /// The state of read operation.
+// /// Some read operations may read part of the data even if they fail, this can be used to resume the read operation.
+// ///
+// ///
+// /// The type of the deserialized value.
+// ///
+// ///
+// /// The type of the reading state.
+// ///
+// public readonly record struct ReadValueResult(
+// bool IsSuccess,
+// in TValue? Value,
+// in TState? ReadingState
+// )
+// {
+// ///
+// /// Creates a successful with the provided value.
+// ///
+// ///
+// /// The deserialized value.
+// ///
+// ///
+// /// A successful instance with the provided value.
+// ///
+// public static ReadValueResult Success(in TValue? value)
+// {
+// return new ReadValueResult(true, in value, default);
+// }
+//
+// ///
+// /// A failed instance with the default value of .
+// ///
+// ///
+// /// The minimum required bytes to complete the current read operation.
+// /// This will be 0 if the write operation is successful.
+// ///
+// ///
+// /// The state of read operation.
+// ///
+// ///
+// /// A failed instance with the default value of
+// /// and the provided reading state.
+// ///
+// public static ReadValueResult Failure(int minRequiredBytes, in TState? readingState) =>
+// new(false, default, in readingState);
+// }
+//
+// ///
+// /// Result of read byte sequence operation.
+// ///
+// public readonly struct ReadBytesResult
+// {
+// private readonly ResultFlags _flags;
+// public ReadOnlySequence Buffer { get; }
+//
+// ///
+// /// Indicates if the of is greater than or equal to
+// /// the provided "sizeHint".
+// ///
+// public bool IsSuccess => (_flags & ResultFlags.IsSuccess) != 0;
+//
+// ///
+// /// Indicates if all remaining data has been returned and there is no more data to read.
+// ///
+// public bool IsCompleted => (_flags & ResultFlags.IsCompleted) != 0;
+//
+// internal ReadBytesResult(bool isSuccess, bool isCompleted, in ReadOnlySequence buffer)
+// {
+// _flags = ResultFlags.None;
+// if (isSuccess)
+// {
+// _flags |= ResultFlags.IsSuccess;
+// }
+// if (isCompleted)
+// {
+// _flags |= ResultFlags.IsCompleted;
+// }
+// Buffer = buffer;
+// }
+//
+// [Flags]
+// private enum ResultFlags
+// {
+// None = 0,
+// IsSuccess = 1,
+// IsCompleted = 2,
+// }
+// }
+
+internal sealed class BatchReader
+{
+ private PipeReader _innerReader = null!;
+ private ReadOnlySequence _currentBuffer;
+ private ReadOnlySequence _uncomsumedBuffer;
+ private ReadOnlySequence _unexaminedBuffer;
+
+ internal int Version { get; private set; }
+
+ private bool _isInnerReaderCompleted;
+ private bool _isLastReadCanceled;
+
+ internal void Reset()
+ {
+ _innerReader = null!;
+ }
+
+ [MemberNotNull(nameof(_innerReader))]
+ internal void Initialize(PipeReader reader)
+ {
+ _innerReader = reader;
+ _currentBuffer = ReadOnlySequence.Empty;
+ _uncomsumedBuffer = ReadOnlySequence.Empty;
+ _unexaminedBuffer = ReadOnlySequence.Empty;
+ _isInnerReaderCompleted = false;
+ Version = 0;
+ }
+
+ public void AdvanceTo(SequencePosition consumed)
+ {
+ Version++;
+ _uncomsumedBuffer = _uncomsumedBuffer.Slice(consumed);
+ if (_uncomsumedBuffer.Length < _unexaminedBuffer.Length)
+ {
+ _unexaminedBuffer = _uncomsumedBuffer;
+ }
+ }
+
+ public void AdvanceTo(SequencePosition consumed, SequencePosition examined)
+ {
+ Version++;
+ _uncomsumedBuffer = _uncomsumedBuffer.Slice(consumed);
+ _unexaminedBuffer = _unexaminedBuffer.Slice(examined);
+ }
+
+ private void Flush()
+ {
+ // Check if the AdvanceTo call is necessary to reduce virtual calls.
+ var consumed = _uncomsumedBuffer.Start;
+ var examined = _unexaminedBuffer.Start;
+ var start = _currentBuffer.Start;
+ if (!consumed.Equals(start) || !examined.Equals(start))
+ {
+ _innerReader.AdvanceTo(consumed, examined);
+ _currentBuffer = _uncomsumedBuffer;
+ }
+ }
+
+ public ReadResult Read(int sizeHint = 0)
+ {
+ if (sizeHint < 0)
+ {
+ ThrowHelper.ThrowArgumentOutOfRangeException(nameof(sizeHint), sizeHint);
+ }
+
+ if (sizeHint > _uncomsumedBuffer.Length)
+ {
+ Flush();
+ if (_innerReader.TryRead(out var innerResult))
+ {
+ PopulateNewData(in innerResult);
+ }
+ }
+
+ return new ReadResult(_uncomsumedBuffer, _isInnerReaderCompleted, _isLastReadCanceled);
+ }
+
+ public async ValueTask ReadAsync(int sizeHint, CancellationToken cancellationToken = default)
+ {
+ if (sizeHint < 0)
+ {
+ ThrowHelper.ThrowArgumentOutOfRangeException(nameof(sizeHint), sizeHint);
+ }
+
+ if (sizeHint is 0)
+ {
+ if (_unexaminedBuffer.IsEmpty)
+ {
+ Flush();
+ var innerResult = await _innerReader.ReadAsync(cancellationToken);
+ PopulateNewData(in innerResult);
+ }
+ }
+ else if (sizeHint > _uncomsumedBuffer.Length || _unexaminedBuffer.IsEmpty)
+ {
+ Flush();
+ var innerResult = await _innerReader.ReadAtLeastAsync(sizeHint, cancellationToken);
+ PopulateNewData(in innerResult);
+ }
+
+ return new ReadResult(_uncomsumedBuffer, _isInnerReaderCompleted, _isLastReadCanceled);
+ }
+
+ private void PopulateNewData(in ReadResult result)
+ {
+ Version++;
+ var examined = _uncomsumedBuffer.Length - _unexaminedBuffer.Length;
+ _currentBuffer = result.Buffer;
+ _uncomsumedBuffer = result.Buffer;
+ _unexaminedBuffer = result.Buffer.Slice(examined);
+ _isInnerReaderCompleted = result.IsCompleted;
+ _isLastReadCanceled = result.IsCanceled;
+ }
+}
diff --git a/csharp/Fury/Context/BatchWriter.cs b/csharp/Fury/Context/BatchWriter.cs
new file mode 100644
index 0000000000..252c0e822d
--- /dev/null
+++ b/csharp/Fury/Context/BatchWriter.cs
@@ -0,0 +1,93 @@
+using System;
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.IO.Pipelines;
+using JetBrains.Annotations;
+
+namespace Fury.Context;
+
+// This is used to reduce the virtual call overhead of the PipeWriter
+
+internal sealed class BatchWriter : IBufferWriter, IDisposable
+{
+ private PipeWriter _innerWriter = null!;
+ private Memory _cachedMemory;
+
+ public int Version { get; private set; }
+ internal int Consumed { get; private set; }
+ internal Memory Buffer => _cachedMemory;
+
+ public Memory UnconsumedBuffer => _cachedMemory.Slice(Consumed);
+ public Memory UnflushedConsumedBuffer => _cachedMemory.Slice(0, Consumed);
+
+ [MemberNotNull(nameof(_innerWriter))]
+ internal void Initialize(PipeWriter writer)
+ {
+ _innerWriter = writer;
+ Consumed = 0;
+ Version = 0;
+ }
+
+ internal void Reset()
+ {
+ _innerWriter = null!;
+ Consumed = 0;
+ Version = 0;
+ }
+
+ public void Flush()
+ {
+ if (Consumed > 0)
+ {
+ _innerWriter.Advance(Consumed);
+ Consumed = 0;
+ }
+ _cachedMemory = Memory.Empty;
+ Version++;
+ }
+
+ public void Advance(int bytes)
+ {
+ if (bytes + Consumed > _cachedMemory.Length)
+ {
+ ThrowHelper.ThrowArgumentOutOfRangeException_AttemptedToAdvanceFurtherThanBufferLength(
+ nameof(bytes),
+ _cachedMemory.Length,
+ bytes
+ );
+ }
+
+ Consumed += bytes;
+ Version++;
+ }
+
+ [MustUseReturnValue]
+ public Memory GetMemory(int sizeHint = 0)
+ {
+ var result = UnconsumedBuffer;
+ if (result.Length < sizeHint)
+ {
+ if (Consumed > 0)
+ {
+ _innerWriter.Advance(Consumed);
+ Consumed = 0;
+ }
+ _cachedMemory = _innerWriter.GetMemory(sizeHint);
+ Version++;
+ result = UnconsumedBuffer;
+ }
+
+ return result;
+ }
+
+ [MustUseReturnValue]
+ public Span GetSpan(int sizeHint = 0)
+ {
+ return GetMemory(sizeHint).Span;
+ }
+
+ public void Dispose()
+ {
+ Flush();
+ }
+}
diff --git a/csharp/Fury/Context/DeserializationReader.cs b/csharp/Fury/Context/DeserializationReader.cs
new file mode 100644
index 0000000000..6392451fd9
--- /dev/null
+++ b/csharp/Fury/Context/DeserializationReader.cs
@@ -0,0 +1,825 @@
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.IO.Pipelines;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Fury.Collections;
+using Fury.Helpers;
+using Fury.Meta;
+using Fury.Serialization;
+using Fury.Serialization.Meta;
+using JetBrains.Annotations;
+
+namespace Fury.Context;
+
+public sealed class DeserializationReader
+{
+ private sealed class Frame
+ {
+ public object? Value;
+ public TypeRegistration? Registration;
+ public RefMetadata? RefMetadata;
+ public IDeserializer? Deserializer;
+
+ public void Reset()
+ {
+ Debug.Assert(Registration is not null || Deserializer is null);
+ if (Registration is not null && Deserializer is not null)
+ {
+ Registration.ReturnDeserializer(Deserializer);
+ }
+ Value = null;
+ Registration = null;
+ RefMetadata = null;
+ Deserializer = null;
+ }
+ }
+
+ public TypeRegistry TypeRegistry { get; }
+ internal MetaStringStorage MetaStringStorage { get; }
+
+ public DeserializationConfig Config { get; private set; } = DeserializationConfig.Default;
+ private readonly BatchReader _innerReader = new();
+
+ private readonly HeaderDeserializer _headerDeserializer = new();
+ private readonly ReferenceMetaDeserializer _referenceMetaDeserializer = new();
+ private readonly TypeMetaDeserializer _typeMetaDeserializer;
+
+ internal AutoIncrementIdDictionary MetaStringContext { get; } = new();
+ private readonly FrameStack _frameStack = new();
+
+ internal DeserializationReader(TypeRegistry registry, MetaStringStorage metaStringStorage)
+ {
+ TypeRegistry = registry;
+ MetaStringStorage = metaStringStorage;
+ _typeMetaDeserializer = new TypeMetaDeserializer();
+ _typeMetaDeserializer.Initialize(TypeRegistry, MetaStringStorage, MetaStringContext);
+ }
+
+ internal void Reset()
+ {
+ _innerReader.Reset();
+ _headerDeserializer.Reset();
+ ResetCurrent();
+ foreach (var frame in _frameStack.Frames)
+ {
+ frame.Reset();
+ }
+ _frameStack.Reset();
+ }
+
+ private void ResetCurrent()
+ {
+ _referenceMetaDeserializer.ResetCurrent();
+ _typeMetaDeserializer.ResetCurrent();
+ }
+
+ internal void Initialize(PipeReader pipeReader, DeserializationConfig config)
+ {
+ Config = config;
+ _innerReader.Initialize(pipeReader);
+ }
+
+ private void OnCurrentDeserializationCompleted(bool isSuccess)
+ {
+ if (isSuccess)
+ {
+ ResetCurrent();
+ _frameStack.PopFrame().Reset();
+ }
+ else
+ {
+ _frameStack.MoveLast();
+ }
+ }
+
+ internal ValueTask> ReadHeader(bool isAsync, CancellationToken cancellationToken)
+ {
+ return _headerDeserializer.Read(this, isAsync, cancellationToken);
+ }
+
+ [MustUseReturnValue]
+ public ReadValueResult Read(TypeRegistration? registrationHint = null)
+ {
+ var task = Read(registrationHint, ObjectMetaOption.ReferenceMeta | ObjectMetaOption.TypeMeta, false, CancellationToken.None);
+ Debug.Assert(task.IsCompleted);
+ return task.Result;
+ }
+
+ [MustUseReturnValue]
+ public ValueTask> ReadAsync(TypeRegistration? registrationHint = null, CancellationToken cancellationToken = default)
+ {
+ return Read(registrationHint, ObjectMetaOption.ReferenceMeta | ObjectMetaOption.TypeMeta, true, cancellationToken);
+ }
+
+ [MustUseReturnValue]
+ internal async ValueTask> Read(
+ TypeRegistration? registrationHint,
+ ObjectMetaOption metaOption,
+ bool isAsync,
+ CancellationToken cancellationToken
+ )
+ {
+ _frameStack.MoveNext();
+ var currentFrame = _frameStack.CurrentFrame;
+ var isSuccess = false;
+ try
+ {
+ if ((metaOption & ObjectMetaOption.ReferenceMeta) != 0)
+ {
+ isSuccess = await ReadRefMeta(currentFrame, isAsync, cancellationToken);
+ if (!isSuccess)
+ {
+ return ReadValueResult.Failed;
+ }
+ }
+ else
+ {
+ // If reading RefFlag is not required, it should be equivalent to RefFlag.NotNullValue.
+ currentFrame.RefMetadata = new RefMetadata(RefFlag.NotNullValue);
+ }
+
+ var valueResult = await ReadCommon(currentFrame, metaOption, registrationHint, isAsync, cancellationToken);
+ isSuccess = valueResult.IsSuccess;
+ return valueResult;
+ }
+ finally
+ {
+ OnCurrentDeserializationCompleted(isSuccess);
+ }
+ }
+
+ [MustUseReturnValue]
+ public ReadValueResult ReadNullable(TypeRegistration? registrationHint = null)
+ where TTarget : struct
+ {
+ var task = ReadNullable(registrationHint, ObjectMetaOption.ReferenceMeta | ObjectMetaOption.TypeMeta, false, CancellationToken.None);
+ Debug.Assert(task.IsCompleted);
+ return task.Result;
+ }
+
+ [MustUseReturnValue]
+ public async ValueTask> ReadNullableAsync(
+ TypeRegistration? registrationHint = null,
+ CancellationToken cancellationToken = default
+ )
+ where TTarget : struct
+ {
+ return await ReadNullable(registrationHint, ObjectMetaOption.ReferenceMeta | ObjectMetaOption.TypeMeta, true, cancellationToken);
+ }
+
+ [MustUseReturnValue]
+ internal async ValueTask> ReadNullable(
+ TypeRegistration? registrationHint,
+ ObjectMetaOption metaOption,
+ bool isAsync,
+ CancellationToken cancellationToken
+ )
+ where TTarget : struct
+ {
+ _frameStack.MoveNext();
+ var currentFrame = _frameStack.CurrentFrame;
+ var isSuccess = false;
+ try
+ {
+ var refMetaResult = await ReadRefMeta(currentFrame, isAsync, cancellationToken);
+ if (!refMetaResult)
+ {
+ return ReadValueResult.Failed;
+ }
+
+ if (currentFrame.RefMetadata is { RefFlag: RefFlag.Null })
+ {
+ return ReadValueResult.FromValue(null);
+ }
+
+ var valueResult = await ReadCommon(currentFrame, metaOption, registrationHint, isAsync, cancellationToken);
+ isSuccess = valueResult.IsSuccess;
+ if (!isSuccess)
+ {
+ return ReadValueResult.Failed;
+ }
+
+ return ReadValueResult.FromValue(valueResult.Value);
+ }
+ finally
+ {
+ OnCurrentDeserializationCompleted(isSuccess);
+ }
+ }
+
+ private async ValueTask ReadRefMeta(Frame currentFrame, bool isAsync, CancellationToken cancellationToken)
+ {
+ if (currentFrame.RefMetadata is not null)
+ {
+ return true;
+ }
+ var readResult = await _referenceMetaDeserializer.Read(this, isAsync, cancellationToken);
+ if (!readResult.IsSuccess)
+ {
+ return false;
+ }
+ currentFrame.RefMetadata = readResult.Value;
+ return true;
+ }
+
+ private async ValueTask> ReadCommon(
+ Frame currentFrame,
+ ObjectMetaOption metaOption,
+ TypeRegistration? registrationHint,
+ bool isAsync,
+ CancellationToken cancellationToken
+ )
+ {
+ if (currentFrame.RefMetadata is not { } refMeta)
+ {
+ ThrowHelper.ThrowArgumentException(nameof(metaOption));
+ return ReadValueResult.Failed;
+ }
+
+ if (refMeta is { RefFlag: RefFlag.Null })
+ {
+ // Maybe we should throw an exception here for value types
+ return ReadValueResult.FromValue(default);
+ }
+
+ if (refMeta is { RefFlag: RefFlag.Ref, RefId: var refId })
+ {
+ _referenceMetaDeserializer.GetReadValue(refId, out var readValue);
+ return ReadValueResult.FromValue((TTarget)readValue);
+ }
+
+ if (refMeta is { RefFlag: RefFlag.RefValue })
+ {
+ if (!await ReadTypeMeta(currentFrame, metaOption, typeof(TTarget), registrationHint, isAsync, cancellationToken))
+ {
+ return ReadValueResult.Failed;
+ }
+
+ if (!await ReadReferenceable(currentFrame, isAsync, cancellationToken))
+ {
+ return ReadValueResult.Failed;
+ }
+
+ return ReadValueResult.FromValue((TTarget?)currentFrame.Value);
+ }
+
+ if (refMeta is { RefFlag: RefFlag.NotNullValue })
+ {
+ if (!await ReadTypeMeta(currentFrame, metaOption, typeof(TTarget), registrationHint, isAsync, cancellationToken))
+ {
+ return ReadValueResult.Failed;
+ }
+
+ return (await ReadUnreferenceable(currentFrame, isAsync, cancellationToken))!;
+ }
+
+ ThrowBadDeserializationInputExceptionException_InvalidRefFlag(refMeta.RefFlag);
+ return ReadValueResult.Failed;
+ }
+
+ [DoesNotReturn]
+ private static void ThrowBadDeserializationInputExceptionException_InvalidRefFlag(RefFlag refFlag)
+ {
+ throw new BadDeserializationInputException($"Invalid RefFlag: {refFlag}");
+ }
+
+ [DoesNotReturn]
+ private static void ThrowArgumentNullException_RegistrationHintIsNull([InvokerParameterName] string paramName)
+ {
+ throw new ArgumentNullException(paramName, $"When type meta is not read, the {paramName} must not be null.");
+ }
+
+ [DoesNotReturn]
+ private static void ThrowArgumentException_RegistrationHintDoesNotMatch(
+ Type declaredType,
+ TypeRegistration registrationHint,
+ [InvokerParameterName] string paramName
+ )
+ {
+ throw new ArgumentException(
+ $"Provided registration hint's target type `{registrationHint.TargetType}` cannot be assigned to `{declaredType}`.",
+ paramName
+ );
+ }
+
+ private async ValueTask ReadTypeMeta(
+ Frame currentFrame,
+ ObjectMetaOption metaOption,
+ Type declaredType,
+ TypeRegistration? registrationHint,
+ bool isAsync,
+ CancellationToken cancellationToken
+ )
+ {
+ if ((metaOption & ObjectMetaOption.TypeMeta) != 0)
+ {
+ var typeMetaResult = await _typeMetaDeserializer.Read(this, declaredType, registrationHint, isAsync, cancellationToken);
+ if (!typeMetaResult.IsSuccess)
+ {
+ return false;
+ }
+ currentFrame.Registration = typeMetaResult.Value;
+ }
+ else
+ {
+ if (registrationHint is null)
+ {
+ ThrowArgumentNullException_RegistrationHintIsNull(nameof(registrationHint));
+ }
+
+ if (!declaredType.IsAssignableFrom(registrationHint.TargetType))
+ {
+ ThrowArgumentException_RegistrationHintDoesNotMatch(declaredType, registrationHint, nameof(registrationHint));
+ }
+
+ currentFrame.Registration = registrationHint;
+ }
+
+ return true;
+ }
+
+ private async ValueTask ReadReferenceable(Frame currentFrame, bool isAsync, CancellationToken cancellationToken)
+ {
+ if (currentFrame.Value is not null)
+ {
+ return true;
+ }
+
+ Debug.Assert(currentFrame.Registration is not null);
+ var deserializer = currentFrame.Deserializer ?? currentFrame.Registration.RentDeserializer();
+
+ var createResult = ReadValueResult