Faster deserialization (#315)

## Description of Changes
Leverages clockworklabs/SpacetimeDB#2725 to
speed up row deserialization. Also updates DLLs for recent upstream
fixes.

Changes:
- Uses much simpler code when deserializing enums, avoiding the use of
reflection
- Uses manually monomorphized row deserialization methods, which again
avoid the use of reflection when constructing row objects

## API

 - [ ] This is an API breaking change to the SDK

*If the API is breaking, please state below what will break*

## Requires SpacetimeDB PRs
clockworklabs/SpacetimeDB#2725

## Testsuite

SpacetimeDB branch name: jgilles/perf/faster-allocation

## Testing
*Write instructions for a test that you performed for this PR*

- [x] Blackholio
- [x] Bitcraft (have done a basic test but no in-depth testing)

Author: kazimuth

packages/spacetimedb.bsatn.runtime/1.1.1/analyzers/dotnet/cs/SpacetimeDB.BSATN.Codegen.dll

@@ -3,10 +3,12 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using SpacetimeDB.BSATN;
 using SpacetimeDB.ClientApi;
 
+#nullable enable
 namespace SpacetimeDB
 {
     public abstract class RemoteBase
@@ -50,10 +52,20 @@ public interface IRemoteTableHandle
     }
 
 
+    /// <summary>
+    /// Base class for views of remote tables.
+    /// </summary>
+    /// <typeparam name="EventContext"></typeparam>
+    /// <typeparam name="Row"></typeparam>
     public abstract class RemoteTableHandle<EventContext, Row> : RemoteBase, IRemoteTableHandle
         where EventContext : class, IEventContext
         where Row : class, IStructuralReadWrite, new()
     {
+        // Note: This should really be also parameterized with RowRW: IReadWrite<Row>, but that is a backwards-
+        // incompatible change. Instead, we call (IReadWrite<Row>)((IStructuralReadWrite)new Row()).GetSerializer().
+        // Serializer.Read is faster than IStructuralReadWrite.Read<Row> since it's manually monomorphized
+        // and therefore avoids using reflection when initializing the row object.
+
         public abstract class IndexBase<Column>
             where Column : IEquatable<Column>
         {
@@ -134,16 +146,35 @@ public RemoteTableHandle(IDbConnection conn) : base(conn) { }
         // THE DATA IN THE TABLE.
         // The keys of this map are:
         // - Primary keys, if we have them.
-        // - Byte arrays, if we don't.
+        // - The entire row itself, if we don't.
         // But really, the keys are whatever SpacetimeDBClient chooses to give us.
-        //
-        // We store the BSATN encodings of objects next to their runtime representation.
-        // This is memory-inefficient, but allows us to quickly compare objects when seeing if an update is a "real"
-        // update or just a multiplicity change.
         private readonly MultiDictionary<object, IStructuralReadWrite> Entries = new(EqualityComparer<object>.Default, EqualityComparer<Object>.Default);
 
+        private static IReadWrite<Row>? _serializer;
+
+        /// <summary>
+        /// Serializer for the rows of this table.
+        /// </summary>
+        private static IReadWrite<Row> Serializer
+        {
+            get
+            {
+                // We can't just initialize this statically, because some BitCraft row types have static
+                // methods that read SpacetimeDBService.Conn.Db, and these fail if the connection is not
+                // there on the first load of those types (????).
+                // This should really be considered an error on their part, but for now we delay initializing any Rows until
+                // Serializer is actually read, that is, until a row actually needs to be deserialized --
+                // at which point, the connection should be initialized.
+                if (_serializer == null)
+                {
+                    _serializer = (IReadWrite<Row>)new Row().GetSerializer();
+                }
+                return _serializer;
+            }
+        }
+
         // The function to use for decoding a type value.
-        IStructuralReadWrite IRemoteTableHandle.DecodeValue(BinaryReader reader) => IStructuralReadWrite.Read<Row>(reader);
+        IStructuralReadWrite IRemoteTableHandle.DecodeValue(BinaryReader reader) => Serializer.Read(reader);
 
         public delegate void RowEventHandler(EventContext context, Row row);
         public event RowEventHandler? OnInsert;
@@ -304,3 +335,4 @@ void IRemoteTableHandle.PostApply(IEventContext context)
         }
     }
 }
+#nullable disable