Speed up allocation during serialization

Add important comment

Make enums more direct

Comments and csharpier

Author: kazimuth

crates/bindings-csharp/BSATN.Codegen/Type.cs

@@ -422,22 +422,12 @@ public Scope.Extensions ToExtensions()
 
         var bsatnDecls = Members.Cast<MemberDeclaration>();
         var fieldNames = bsatnDecls.Select(m => m.Name);
+        var fieldNamesAndIds = fieldNames.Select((name, i) => (name, i));
 
         extensions.BaseTypes.Add($"System.IEquatable<{ShortName}>");
 
         if (Kind is TypeKind.Sum)
         {
-            extensions.Contents.Append(
-                $$"""
-                    private {{ShortName}}() { }
-
-                    internal enum @enum: byte
-                    {
-                        {{string.Join(",\n        ", fieldNames)}}
-                    }
-                
-                """
-            );
             extensions.Contents.Append(
                 string.Join(
                     "\n",
@@ -458,24 +448,24 @@ public override string ToString() =>
             );
 
             read = $$"""
-                    __enumTag.Read(reader) switch {
+                    return reader.ReadByte() switch {
                         {{string.Join(
                             "\n            ",
-                            fieldNames.Select(name =>
-                                $"@enum.{name} => new {name}({name}.Read(reader)),"
+                            fieldNames.Select((name, i) =>
+                                $"{i} => new {name}({name}.Read(reader)),"
                             )
                         )}}
                         _ => throw new System.InvalidOperationException("Invalid tag value, this state should be unreachable.")
-                    }
+                    };
             """;
 
             write = $$"""
             switch (value) {
             {{string.Join(
                 "\n",
-                fieldNames.Select(name => $"""
+                fieldNames.Select((name, i) => $"""
                             case {name}(var inner):
-                                __enumTag.Write(writer, @enum.{name});
+                                writer.Write((byte){i});
                                 {name}.Write(writer, inner);
                                 break;
                 """))}}
@@ -501,10 +491,6 @@ public override string ToString() =>
                         return 0;
                     }
             """;
-
-            bsatnDecls = bsatnDecls.Prepend(
-                new("__enumTag", new ValueUse("@enum", "SpacetimeDB.BSATN.Enum<@enum>"))
-            );
         }
         else
         {
@@ -543,7 +529,14 @@ public override string ToString() =>
             """
             );
 
-            read = $"SpacetimeDB.BSATN.IStructuralReadWrite.Read<{FullName}>(reader)";
+            // Directly allocating the result object here (instead of calling e.g. IStructuralReadWrite.Read<T>, which does the same thing)
+            // avoids generics; we've found that generics often result in reflective code being generated.
+            // Using simple code here hopefully helps IL2CPP and Mono do this faster.
+            read = $$"""
+                    var ___result = new {{FullName}}();
+                    ___result.ReadFields(reader);
+                    return ___result;
+                """;
 
             write = "value.WriteFields(writer);";
 
@@ -559,14 +552,17 @@ public override string ToString() =>
                 """;
         }
 
+        // It's important that the contained struct here is named BSATN: the C# SDK uses reflection to find this type.
         extensions.Contents.Append(
             $$"""
 
                 public readonly partial struct BSATN : SpacetimeDB.BSATN.IReadWrite<{{FullName}}>
                 {
                     {{MemberDeclaration.GenerateBsatnFields(Accessibility.Internal, bsatnDecls)}}
 
-                    public {{FullName}} Read(System.IO.BinaryReader reader) => {{read}};
+                    public {{FullName}} Read(System.IO.BinaryReader reader) {
+                        {{read}}
+                    }
 
                     public void Write(System.IO.BinaryWriter writer, {{FullName}} value) {
                         {{write}}

crates/bindings-csharp/Codegen.Tests/fixtures/client/snapshots/Type#CustomClass.verified.cs

@@ -24,8 +24,12 @@ public override string ToString() =>
         internal static readonly SpacetimeDB.BSATN.I32 IntField = new();
         internal static readonly SpacetimeDB.BSATN.String StringField = new();
 
-        public CustomClass Read(System.IO.BinaryReader reader) =>
-            SpacetimeDB.BSATN.IStructuralReadWrite.Read<CustomClass>(reader);
+        public CustomClass Read(System.IO.BinaryReader reader)
+        {
+            var ___result = new CustomClass();
+            ___result.ReadFields(reader);
+            return ___result;
+        }
 
         public void Write(System.IO.BinaryWriter writer, CustomClass value)
         {

crates/bindings-csharp/Codegen.Tests/fixtures/client/snapshots/Type#CustomStruct.verified.cs

@@ -26,8 +26,12 @@ public override string ToString() =>
         internal static readonly SpacetimeDB.BSATN.I32 IntField = new();
         internal static readonly SpacetimeDB.BSATN.String StringField = new();
 
-        public CustomStruct Read(System.IO.BinaryReader reader) =>
-            SpacetimeDB.BSATN.IStructuralReadWrite.Read<CustomStruct>(reader);
+        public CustomStruct Read(System.IO.BinaryReader reader)
+        {
+            var ___result = new CustomStruct();
+            ___result.ReadFields(reader);
+            return ___result;
+        }
 
         public void Write(System.IO.BinaryWriter writer, CustomStruct value)
         {

crates/bindings-csharp/Codegen.Tests/fixtures/client/snapshots/Type#CustomTaggedEnum.verified.cs

@@ -4,14 +4,6 @@
 
 partial record CustomTaggedEnum : System.IEquatable<CustomTaggedEnum>
 {
-    private CustomTaggedEnum() { }
-
-    internal enum @enum : byte
-    {
-        IntVariant,
-        StringVariant
-    }
-
     public sealed record IntVariant(int IntVariant_) : CustomTaggedEnum
     {
         public override string ToString() =>
@@ -26,31 +18,32 @@ public override string ToString() =>
 
     public readonly partial struct BSATN : SpacetimeDB.BSATN.IReadWrite<CustomTaggedEnum>
     {
-        internal static readonly SpacetimeDB.BSATN.Enum<@enum> __enumTag = new();
         internal static readonly SpacetimeDB.BSATN.I32 IntVariant = new();
         internal static readonly SpacetimeDB.BSATN.String StringVariant = new();
 
-        public CustomTaggedEnum Read(System.IO.BinaryReader reader) =>
-            __enumTag.Read(reader) switch
+        public CustomTaggedEnum Read(System.IO.BinaryReader reader)
+        {
+            return reader.ReadByte() switch
             {
-                @enum.IntVariant => new IntVariant(IntVariant.Read(reader)),
-                @enum.StringVariant => new StringVariant(StringVariant.Read(reader)),
+                0 => new IntVariant(IntVariant.Read(reader)),
+                1 => new StringVariant(StringVariant.Read(reader)),
                 _
                     => throw new System.InvalidOperationException(
                         "Invalid tag value, this state should be unreachable."
                     )
             };
+        }
 
         public void Write(System.IO.BinaryWriter writer, CustomTaggedEnum value)
         {
             switch (value)
             {
                 case IntVariant(var inner):
-                    __enumTag.Write(writer, @enum.IntVariant);
+                    writer.Write((byte)0);
                     IntVariant.Write(writer, inner);
                     break;
                 case StringVariant(var inner):
-                    __enumTag.Write(writer, @enum.StringVariant);
+                    writer.Write((byte)1);
                     StringVariant.Write(writer, inner);
                     break;
             }

crates/bindings-csharp/Codegen.Tests/fixtures/client/snapshots/Type#PublicTable.verified.cs

@@ -100,8 +100,12 @@ internal static readonly SpacetimeDB.BSATN.RefOption<
             SpacetimeDB.BSATN.String
         > NullableReferenceField = new();
 
-        public PublicTable Read(System.IO.BinaryReader reader) =>
-            SpacetimeDB.BSATN.IStructuralReadWrite.Read<PublicTable>(reader);
+        public PublicTable Read(System.IO.BinaryReader reader)
+        {
+            var ___result = new PublicTable();
+            ___result.ReadFields(reader);
+            return ___result;
+        }
 
         public void Write(System.IO.BinaryWriter writer, PublicTable value)
         {