Full duplex Ws transfer using channels

.editorconfig

@@ -20,7 +20,7 @@ csharp_style_var_for_built_in_types = false:none
 csharp_style_var_when_type_is_apparent = false:none
 dotnet_naming_rule.constants_rule.import_to_resharper = as_predefined
 dotnet_naming_rule.constants_rule.severity = warning
-dotnet_naming_rule.constants_rule.style = all_upper_style
+dotnet_naming_rule.constants_rule.style = upper_camel_case_style
 dotnet_naming_rule.constants_rule.symbols = constants_symbols
 dotnet_naming_rule.private_constants_rule.import_to_resharper = as_predefined
 dotnet_naming_rule.private_constants_rule.resharper_style = AaBb, NUM_ + AA_BB

src/Common/ArrayBuilder.cs

@@ -4,6 +4,7 @@
 
 // Modified for generic types and not backed by a pool
 
+using System.Buffers;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -63,12 +64,6 @@ public ref T this[int index]
         }
     }
 
-    public override string ToString()
-    {
-        string s = Raw.Slice(0, _pos).ToString();
-        return s;
-    }
-
     /// <summary>Returns the underlying storage of the builder.</summary>
     public Span<T> Raw => _array.AsSpan();
 
@@ -185,3 +180,208 @@ private void Grow(int additionalCapacityBeyondPos)
         _array = newArray;
     }
 }
+
+internal ref struct PoolArrayBuilder<T>
+{
+    private T[]? _array;
+    private Span<T> _raw;
+    private int _pos;
+
+    public PoolArrayBuilder(Span<T> initialBuffer)
+    {
+        _array = null;
+        _raw = initialBuffer;
+        _pos = 0;
+    }
+
+    public PoolArrayBuilder(int initialCapacity)
+    {
+        _array = ArrayPool<T>.Shared.Rent(initialCapacity);
+        _raw = _array;
+        _pos = 0;
+    }
+
+    public int Length
+    {
+        get => _pos;
+        set
+        {
+            Debug.Assert(value >= 0);
+            Debug.Assert(value <= _raw.Length);
+            _pos = value;
+        }
+    }
+
+    public bool IsEmpty => 0 >= (uint)_pos;
+
+    public bool IsDefault => _raw.IsEmpty && _array is null && _pos == 0;
+
+    public int Capacity => _raw.Length;
+
+    public void EnsureCapacity(int capacity)
+    {
+        // This is not expected to be called this with negative capacity
+        Debug.Assert(capacity >= 0);
+
+        if ((uint)capacity > (uint)_raw.Length)
+            Grow(capacity - _pos);
+    }
+
+    /// <summary>
+    /// Get a pinnable reference to the builder.
+    /// Does not ensure there is a null char after <see cref="Length"/>
+    /// This overload is pattern matched in the C# 7.3+ compiler so you can omit
+    /// the explicit method call, and write eg "fixed (char* c = builder)"
+    /// </summary>
+    public ref T GetPinnableReference()
+    {
+        return ref MemoryMarshal.GetReference(_raw);
+    }
+
+    public ref T this[int index]
+    {
+        get
+        {
+            Debug.Assert(index < _pos);
+            return ref _raw[index];
+        }
+    }
+
+    /// <summary>Returns the underlying storage of the builder.</summary>
+    public Span<T> Raw => _raw;
+
+    public ReadOnlySpan<T> AsSpan() => _raw.Slice(0, _pos);
+    public ReadOnlySpan<T> AsSpan(int start) => _raw.Slice(start, _pos - start);
+    public ReadOnlySpan<T> AsSpan(int start, int length) => _raw.Slice(start, length);
+
+    public ArraySegment<T> AsSegment() => new(_array ?? Array.Empty<T>());
+    public ArraySegment<T> AsSegment(int start) => new(_array ?? Array.Empty<T>(), start, _pos - start);
+    public ArraySegment<T> AsSegment(int start, int length) => new(_array ?? Array.Empty<T>(), start, length);
+
+    public bool TryCopyTo(Span<T> destination, out int written) {
+        if (_raw.Slice(0, _pos).TryCopyTo(destination))
+        {
+            written = _pos;
+            return true;
+        }
+
+        written = 0;
+        return false;
+    }
+
+    public void Insert(int index, in T value, int count)
+    {
+        if (_pos > _raw.Length - count)
+        {
+            Grow(count);
+        }
+
+        int remaining = _pos - index;
+        _raw.Slice(index, remaining).CopyTo(_raw.Slice(index + count));
+        _raw.Slice(index, count).Fill(value);
+        _pos += count;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Append(T c)
+    {
+        int pos = _pos;
+        if ((uint)pos < (uint)_raw.Length)
+        {
+            _raw[pos] = c;
+            _pos = pos + 1;
+        }
+        else
+        {
+            GrowAndAppend(c);
+        }
+    }
+
+    public void Append(in T c, int count)
+    {
+        if (_pos > _raw.Length - count)
+        {
+            Grow(count);
+        }
+
+        Span<T> dst = _raw.Slice(_pos, count);
+        for (int i = 0; i < dst.Length; i++)
+        {
+            dst[i] = c;
+        }
+        _pos += count;
+    }
+
+    public void Append(ReadOnlySpan<T> value)
+    {
+        int pos = _pos;
+        if (pos > _raw.Length - value.Length)
+        {
+            Grow(value.Length);
+        }
+
+        value.CopyTo(_raw.Slice(_pos));
+        _pos += value.Length;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Span<T> AppendSpan(int length)
+    {
+        int origPos = _pos;
+        if (origPos > _raw.Length - length)
+        {
+            Grow(length);
+        }
+
+        _pos = origPos + length;
+        return _raw.Slice(origPos, length);
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void GrowAndAppend(T c)
+    {
+        Grow(1);
+        Append(c);
+    }
+
+    /// <summary>
+    /// Resize the internal buffer either by doubling current buffer size or
+    /// by adding <paramref name="additionalCapacityBeyondPos"/> to
+    /// <see cref="_pos"/> whichever is greater.
+    /// </summary>
+    /// <param name="additionalCapacityBeyondPos">
+    /// Number of chars requested beyond current position.
+    /// </param>
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void Grow(int additionalCapacityBeyondPos)
+    {
+        Debug.Assert(additionalCapacityBeyondPos > 0);
+        Debug.Assert(_pos > _raw.Length - additionalCapacityBeyondPos, "Grow called incorrectly, no resize is needed.");
+
+        T[] newArray = ArrayPool<T>.Shared.Rent(
+            (int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), (uint)_raw.Length * 2)
+        );
+        _raw.Slice(0, _pos).CopyTo(newArray);
+        _raw = newArray;
+        if (_array is not null) {
+            ArrayPool<T>.Shared.Return(_array);
+        }
+        _array = newArray;
+    }
+
+    public void Dispose() {
+        var array = _array;
+        _array = null;
+        _raw = default;
+        if (array is not null) {
+            ArrayPool<T>.Shared.Return(array);
+        }
+    }
+
+    public T[] ToArray() {
+        var array = new T[_pos];
+        _raw.Slice(0, _pos).CopyTo(array.AsSpan(0, _pos));
+        Dispose();
+        return array;
+    }
+}

src/Common/AssemblyInfo.cs

@@ -1,5 +1,6 @@
 using System.Runtime.CompilerServices;
 
+[assembly: CLSCompliant(true)]
 [assembly: InternalsVisibleTo("SurrealDB.Abstractions")]
 [assembly: InternalsVisibleTo("SurrealDB.Configuration")]
 [assembly: InternalsVisibleTo("SurrealDB.Driver.Rest")]