diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 942a2a1695..a78931c8e0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -142,6 +142,72 @@ jobs:
shell: bash
run: python ./ci/run_ci.py java --version windows_java21
+ csharp:
+ name: C# CI
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v5
+ - name: Set up .NET 8
+ uses: actions/setup-dotnet@v4
+ with:
+ dotnet-version: "8.0.x"
+ cache: true
+ cache-dependency-path: |
+ csharp/**/*.csproj
+ csharp/Fory.sln
+ - name: Restore C# dependencies
+ run: |
+ cd csharp
+ dotnet restore Fory.sln
+ - name: Build C# solution
+ run: |
+ cd csharp
+ dotnet build Fory.sln -c Release --no-restore
+ - name: Run C# tests
+ run: |
+ cd csharp
+ dotnet test tests/Fory.Tests/Fory.Tests.csproj -c Release --no-build
+
+ csharp_xlang:
+ name: C# Xlang Test
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v5
+ - name: Set up .NET 8
+ uses: actions/setup-dotnet@v4
+ with:
+ dotnet-version: "8.0.x"
+ cache: true
+ cache-dependency-path: |
+ csharp/**/*.csproj
+ csharp/Fory.sln
+ - name: Set up JDK 21
+ uses: actions/setup-java@v4
+ with:
+ java-version: 21
+ distribution: "temurin"
+ - name: Cache Maven local repository
+ uses: actions/cache@v4
+ with:
+ path: ~/.m2/repository
+ key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+ restore-keys: |
+ ${{ runner.os }}-maven-
+ - name: Restore and build C# xlang peer
+ run: |
+ cd csharp
+ dotnet restore tests/Fory.XlangPeer/Fory.XlangPeer.csproj
+ dotnet build tests/Fory.XlangPeer/Fory.XlangPeer.csproj -c Debug --no-restore
+ - name: Run C# Xlang Test
+ env:
+ FORY_CSHARP_JAVA_CI: "1"
+ ENABLE_FORY_DEBUG_OUTPUT: "1"
+ run: |
+ cd java
+ mvn -T16 --no-transfer-progress clean install -DskipTests
+ cd fory-core
+ mvn -T16 --no-transfer-progress test -Dtest=org.apache.fory.xlang.CSharpXlangTest
+
swift:
name: Swift CI
runs-on: macos-latest
diff --git a/.gitignore b/.gitignore
index db9be7edff..2c0f134e6b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -106,4 +106,13 @@ benchmarks/**/report/
ignored/**
ci-logs/**
**/*.log
-swift/.build
\ No newline at end of file
+swift/.build
+
+csharp/src/Fory.Generator/bin/
+csharp/src/Fory.Generator/obj/
+csharp/src/Fory/bin/
+csharp/src/Fory/obj/
+csharp/tests/Fory.Tests/bin/
+csharp/tests/Fory.Tests/obj/
+csharp/tests/Fory.XlangPeer/bin/
+csharp/tests/Fory.XlangPeer/obj/
\ No newline at end of file
diff --git a/csharp/Fory.sln b/csharp/Fory.sln
new file mode 100644
index 0000000000..b2f9edf7b1
--- /dev/null
+++ b/csharp/Fory.sln
@@ -0,0 +1,50 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{C3FE93C6-2294-475C-88DD-BE1FFFADC4D6}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Fory", "src\Fory\Fory.csproj", "{309709EA-773D-449D-AE12-D1C2B9518793}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Fory.Generator", "src\Fory.Generator\Fory.Generator.csproj", "{4DBAD732-2820-4B15-B655-19384F100997}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{02DC4D41-0522-42EA-B643-471F4BB0747E}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Fory.Tests", "tests\Fory.Tests\Fory.Tests.csproj", "{65701195-E254-4D93-9CD0-F587FDFCE769}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Fory.XlangPeer", "tests\Fory.XlangPeer\Fory.XlangPeer.csproj", "{8E1D5E47-AF72-46FF-B60F-B1C6210654A4}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {309709EA-773D-449D-AE12-D1C2B9518793}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {309709EA-773D-449D-AE12-D1C2B9518793}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {309709EA-773D-449D-AE12-D1C2B9518793}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {309709EA-773D-449D-AE12-D1C2B9518793}.Release|Any CPU.Build.0 = Release|Any CPU
+ {4DBAD732-2820-4B15-B655-19384F100997}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {4DBAD732-2820-4B15-B655-19384F100997}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {4DBAD732-2820-4B15-B655-19384F100997}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {4DBAD732-2820-4B15-B655-19384F100997}.Release|Any CPU.Build.0 = Release|Any CPU
+ {65701195-E254-4D93-9CD0-F587FDFCE769}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {65701195-E254-4D93-9CD0-F587FDFCE769}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {65701195-E254-4D93-9CD0-F587FDFCE769}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {65701195-E254-4D93-9CD0-F587FDFCE769}.Release|Any CPU.Build.0 = Release|Any CPU
+ {8E1D5E47-AF72-46FF-B60F-B1C6210654A4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {8E1D5E47-AF72-46FF-B60F-B1C6210654A4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {8E1D5E47-AF72-46FF-B60F-B1C6210654A4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {8E1D5E47-AF72-46FF-B60F-B1C6210654A4}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(NestedProjects) = preSolution
+ {309709EA-773D-449D-AE12-D1C2B9518793} = {C3FE93C6-2294-475C-88DD-BE1FFFADC4D6}
+ {4DBAD732-2820-4B15-B655-19384F100997} = {C3FE93C6-2294-475C-88DD-BE1FFFADC4D6}
+ {65701195-E254-4D93-9CD0-F587FDFCE769} = {02DC4D41-0522-42EA-B643-471F4BB0747E}
+ {8E1D5E47-AF72-46FF-B60F-B1C6210654A4} = {02DC4D41-0522-42EA-B643-471F4BB0747E}
+ EndGlobalSection
+EndGlobal
diff --git a/csharp/README.md b/csharp/README.md
new file mode 100644
index 0000000000..a3300bee6c
--- /dev/null
+++ b/csharp/README.md
@@ -0,0 +1 @@
+# Apache Fory™ C\#
diff --git a/csharp/src/Fory.Generator/Fory.Generator.csproj b/csharp/src/Fory.Generator/Fory.Generator.csproj
new file mode 100644
index 0000000000..48864e20cf
--- /dev/null
+++ b/csharp/src/Fory.Generator/Fory.Generator.csproj
@@ -0,0 +1,16 @@
+
+
+ netstandard2.0
+ 12.0
+ enable
+ enable
+ true
+ true
+ false
+
+
+
+
+
+
+
diff --git a/csharp/src/Fory.Generator/ForyObjectGenerator.cs b/csharp/src/Fory.Generator/ForyObjectGenerator.cs
new file mode 100644
index 0000000000..6cb40c931c
--- /dev/null
+++ b/csharp/src/Fory.Generator/ForyObjectGenerator.cs
@@ -0,0 +1,1546 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+using System.Collections.Immutable;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Apache.Fory.Generator;
+
+[Generator(LanguageNames.CSharp)]
+public sealed class ForyObjectGenerator : IIncrementalGenerator
+{
+ private static readonly SymbolDisplayFormat FullNameFormat =
+ SymbolDisplayFormat.FullyQualifiedFormat.WithMiscellaneousOptions(
+ SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);
+
+ private static readonly DiagnosticDescriptor GenericTypeNotSupported = new(
+ id: "FORY001",
+ title: "Generic types are not supported by ForyObject generator",
+ messageFormat: "Type '{0}' is generic and is not supported by [ForyObject].",
+ category: "Fory",
+ defaultSeverity: DiagnosticSeverity.Error,
+ isEnabledByDefault: true);
+
+ private static readonly DiagnosticDescriptor MissingCtor = new(
+ id: "FORY002",
+ title: "Missing parameterless constructor",
+ messageFormat: "Class '{0}' must declare an accessible parameterless constructor for [ForyObject].",
+ category: "Fory",
+ defaultSeverity: DiagnosticSeverity.Error,
+ isEnabledByDefault: true);
+
+ private static readonly DiagnosticDescriptor UnsupportedEncoding = new(
+ id: "FORY003",
+ title: "Unsupported Field encoding",
+ messageFormat: "Member '{0}' uses unsupported [Field] encoding for type '{1}'.",
+ category: "Fory",
+ defaultSeverity: DiagnosticSeverity.Error,
+ isEnabledByDefault: true);
+
+ public void Initialize(IncrementalGeneratorInitializationContext context)
+ {
+ IncrementalValuesProvider typeModels = context.SyntaxProvider
+ .ForAttributeWithMetadataName(
+ "Apache.Fory.ForyObjectAttribute",
+ static (node, _) => node is TypeDeclarationSyntax || node is EnumDeclarationSyntax,
+ static (syntaxContext, ct) => BuildTypeModel(syntaxContext, ct))
+ .Where(static m => m is not null);
+
+ context.RegisterSourceOutput(
+ typeModels.Collect(),
+ static (spc, models) => Emit(spc, models));
+ }
+
+ private static void Emit(SourceProductionContext context, ImmutableArray maybeModels)
+ {
+ if (maybeModels.IsDefaultOrEmpty)
+ {
+ return;
+ }
+
+ Dictionary models = new(StringComparer.Ordinal);
+ foreach (TypeModel? maybeModel in maybeModels)
+ {
+ if (maybeModel is null)
+ {
+ continue;
+ }
+
+ models[maybeModel.TypeName] = maybeModel;
+ }
+
+ if (models.Count == 0)
+ {
+ return;
+ }
+
+ StringBuilder sb = new();
+ sb.AppendLine("// ");
+ sb.AppendLine("#nullable enable");
+ sb.AppendLine("namespace Apache.Fory.Generated;");
+ sb.AppendLine();
+
+ foreach (KeyValuePair entry in models.OrderBy(kv => kv.Key, StringComparer.Ordinal))
+ {
+ TypeModel model = entry.Value;
+ if (model.Kind == DeclKind.Struct || model.Kind == DeclKind.Class)
+ {
+ EmitObjectSerializer(sb, model);
+ sb.AppendLine();
+ }
+ }
+
+ sb.AppendLine("internal static class __ForyGeneratedModuleInitializer");
+ sb.AppendLine("{");
+ sb.AppendLine(" [global::System.Runtime.CompilerServices.ModuleInitializer]");
+ sb.AppendLine(" internal static void Register()");
+ sb.AppendLine(" {");
+ foreach (KeyValuePair entry in models.OrderBy(kv => kv.Key, StringComparer.Ordinal))
+ {
+ TypeModel model = entry.Value;
+ if (model.Kind == DeclKind.Enum)
+ {
+ sb.AppendLine(
+ $" global::Apache.Fory.TypeResolver.RegisterGenerated<{model.TypeName}, global::Apache.Fory.EnumSerializer<{model.TypeName}>>();");
+ }
+ else
+ {
+ sb.AppendLine(
+ $" global::Apache.Fory.TypeResolver.RegisterGenerated<{model.TypeName}, {model.SerializerName}>();");
+ }
+ }
+
+ sb.AppendLine(" }");
+ sb.AppendLine("}");
+
+ context.AddSource("Fory.GeneratedSerializers.g.cs", SourceText.From(sb.ToString(), Encoding.UTF8));
+ }
+
+ private static void EmitObjectSerializer(StringBuilder sb, TypeModel model)
+ {
+ sb.AppendLine($"file sealed class {model.SerializerName} : global::Apache.Fory.Serializer<{model.TypeName}>");
+ sb.AppendLine("{");
+ sb.AppendLine(" private static global::Apache.Fory.RefMode __ForyRefMode(bool nullable, bool trackRef)");
+ sb.AppendLine(" {");
+ sb.AppendLine(" if (trackRef)");
+ sb.AppendLine(" {");
+ sb.AppendLine(" return global::Apache.Fory.RefMode.Tracking;");
+ sb.AppendLine(" }");
+ sb.AppendLine();
+ sb.AppendLine(" return nullable ? global::Apache.Fory.RefMode.NullOnly : global::Apache.Fory.RefMode.None;");
+ sb.AppendLine(" }");
+ sb.AppendLine();
+ sb.AppendLine(" private static bool __ForyNeedsTypeInfoForField(global::Apache.Fory.TypeId typeId)");
+ sb.AppendLine(" {");
+ sb.AppendLine(" return typeId switch");
+ sb.AppendLine(" {");
+ sb.AppendLine(" global::Apache.Fory.TypeId.Struct or");
+ sb.AppendLine(" global::Apache.Fory.TypeId.CompatibleStruct or");
+ sb.AppendLine(" global::Apache.Fory.TypeId.NamedStruct or");
+ sb.AppendLine(" global::Apache.Fory.TypeId.NamedCompatibleStruct or");
+ sb.AppendLine(" global::Apache.Fory.TypeId.Ext or");
+ sb.AppendLine(" global::Apache.Fory.TypeId.NamedExt or");
+ sb.AppendLine(" global::Apache.Fory.TypeId.Unknown => true,");
+ sb.AppendLine(" _ => false,");
+ sb.AppendLine(" };");
+ sb.AppendLine(" }");
+ sb.AppendLine();
+ sb.AppendLine(" private static uint __ForySchemaHash(bool trackRef, global::Apache.Fory.TypeResolver typeResolver)");
+ sb.AppendLine(" {");
+ sb.Append(" return global::Apache.Fory.SchemaHash.StructHash32(");
+ sb.Append(BuildSchemaFingerprintExpression(model.Members));
+ sb.AppendLine(");");
+ sb.AppendLine(" }");
+ sb.AppendLine();
+ sb.AppendLine(" public override global::Apache.Fory.TypeId StaticTypeId => global::Apache.Fory.TypeId.Struct;");
+ if (model.Kind == DeclKind.Class)
+ {
+ sb.AppendLine(" public override bool IsNullableType => true;");
+ sb.AppendLine(" public override bool IsReferenceTrackableType => true;");
+ sb.AppendLine($" public override {model.TypeName} DefaultValue => null!;");
+ sb.AppendLine($" public override bool IsNone(in {model.TypeName} value) => value is null;");
+ }
+ else
+ {
+ sb.AppendLine($" public override {model.TypeName} DefaultValue => new {model.TypeName}();");
+ }
+
+ sb.AppendLine();
+ sb.AppendLine(" public override global::System.Collections.Generic.IReadOnlyList CompatibleTypeMetaFields(bool trackRef)");
+ sb.AppendLine(" {");
+ if (model.SortedMembers.Length == 0)
+ {
+ sb.AppendLine(" return global::System.Array.Empty();");
+ }
+ else
+ {
+ sb.AppendLine(" return new global::Apache.Fory.TypeMetaFieldInfo[]");
+ sb.AppendLine(" {");
+ foreach (MemberModel member in model.SortedMembers)
+ {
+ sb.AppendLine(
+ $" new global::Apache.Fory.TypeMetaFieldInfo(null, \"{EscapeString(member.Name)}\", {BuildCompatibleTypeMetaExpression(member.TypeMeta, "trackRef")}),");
+ }
+
+ sb.AppendLine(" };");
+ }
+
+ sb.AppendLine(" }");
+ sb.AppendLine();
+ sb.AppendLine(
+ $" public override void WriteData(ref global::Apache.Fory.WriteContext context, in {model.TypeName} value, bool hasGenerics)");
+ sb.AppendLine(" {");
+ sb.AppendLine(" _ = hasGenerics;");
+ sb.AppendLine(" if (context.Compatible)");
+ sb.AppendLine(" {");
+ if (model.SortedMembers.Length == 0)
+ {
+ sb.AppendLine(" return;");
+ }
+ else
+ {
+ foreach (MemberModel member in model.SortedMembers)
+ {
+ EmitWriteMember(sb, member, true);
+ }
+
+ sb.AppendLine(" return;");
+ }
+
+ sb.AppendLine(" }");
+ sb.AppendLine();
+ sb.AppendLine(" context.Writer.WriteInt32(unchecked((int)__ForySchemaHash(context.TrackRef, context.TypeResolver)));");
+ foreach (MemberModel member in model.SortedMembers)
+ {
+ EmitWriteMember(sb, member, false);
+ }
+
+ sb.AppendLine(" }");
+ sb.AppendLine();
+ sb.AppendLine($" public override {model.TypeName} ReadData(ref global::Apache.Fory.ReadContext context)");
+ sb.AppendLine(" {");
+ sb.AppendLine(" if (context.Compatible)");
+ sb.AppendLine(" {");
+ sb.AppendLine($" global::Apache.Fory.TypeMeta typeMeta = context.ConsumeCompatibleTypeMeta(typeof({model.TypeName}));");
+ sb.AppendLine($" {model.TypeName} value = new {model.TypeName}();");
+ if (model.Kind == DeclKind.Class)
+ {
+ sb.AppendLine(" context.BindPendingReference(value);");
+ }
+
+ sb.AppendLine(" foreach (global::Apache.Fory.TypeMetaFieldInfo remoteField in typeMeta.Fields)");
+ sb.AppendLine(" {");
+ sb.AppendLine(" global::Apache.Fory.RefMode remoteRefMode = __ForyRefMode(remoteField.FieldType.Nullable, remoteField.FieldType.TrackRef);");
+ sb.AppendLine(" bool remoteReadTypeInfo = __ForyNeedsTypeInfoForField((global::Apache.Fory.TypeId)remoteField.FieldType.TypeId);");
+ sb.AppendLine(" switch (remoteField.FieldName)");
+ sb.AppendLine(" {");
+ foreach (MemberModel member in model.SortedMembers)
+ {
+ sb.AppendLine($" case \"{EscapeString(member.FieldIdentifier)}\":");
+ sb.AppendLine(" {");
+ EmitReadMemberAssignment(sb, member, "remoteRefMode", "remoteReadTypeInfo", "value", "Compat", 7, false);
+ sb.AppendLine(" break;");
+ sb.AppendLine(" }");
+ }
+
+ sb.AppendLine(" default:");
+ sb.AppendLine(" global::Apache.Fory.FieldSkipper.SkipFieldValue(ref context, remoteField.FieldType);");
+ sb.AppendLine(" break;");
+ sb.AppendLine(" }");
+ sb.AppendLine(" }");
+ sb.AppendLine(" return value;");
+ sb.AppendLine(" }");
+ sb.AppendLine();
+ sb.AppendLine(" uint schemaHash = unchecked((uint)context.Reader.ReadInt32());");
+ sb.AppendLine(" uint expectedHash = __ForySchemaHash(context.TrackRef, context.TypeResolver);");
+ sb.AppendLine(" if (schemaHash != expectedHash)");
+ sb.AppendLine(" {");
+ sb.AppendLine(" throw new global::Apache.Fory.InvalidDataException($\"class version hash mismatch: expected {expectedHash}, got {schemaHash}\");");
+ sb.AppendLine(" }");
+ sb.AppendLine();
+ sb.AppendLine($" {model.TypeName} valueSchema = new {model.TypeName}();");
+ if (model.Kind == DeclKind.Class)
+ {
+ sb.AppendLine(" context.BindPendingReference(valueSchema);");
+ }
+
+ foreach (MemberModel member in model.SortedMembers)
+ {
+ EmitReadMemberAssignment(sb, member, BuildWriteRefModeExpression(member), "false", "valueSchema", "Schema", 2, true);
+ }
+
+ sb.AppendLine(" return valueSchema;");
+ sb.AppendLine(" }");
+ sb.AppendLine("}");
+ }
+
+ private static void EmitWriteMember(StringBuilder sb, MemberModel member, bool compatibleMode)
+ {
+ string refModeExpr = BuildWriteRefModeExpression(member);
+ string memberAccess = $"value.{member.Name}";
+ string hasGenerics = member.IsCollection ? "true" : "false";
+ string writeTypeInfo = compatibleMode
+ ? $"__ForyNeedsTypeInfoForField(context.TypeResolver.GetTypeInfo<{member.TypeName}>().StaticTypeId)"
+ : "false";
+
+ switch (member.DynamicAnyKind)
+ {
+ case DynamicAnyKind.AnyValue:
+ sb.AppendLine(
+ $" global::Apache.Fory.DynamicAnyCodec.WriteAny(ref context, {memberAccess}, {refModeExpr}, true, false);");
+ return;
+ case DynamicAnyKind.None:
+ break;
+ default:
+ throw new InvalidOperationException($"unsupported dynamic any kind {member.DynamicAnyKind}");
+ }
+
+ if (!member.IsNullable && TryBuildDirectFieldWrite(member, memberAccess, out string? directWriteCode))
+ {
+ sb.AppendLine($" {directWriteCode}");
+ return;
+ }
+
+ if (TryBuildNullableFixedTaggedFieldWrite(member, memberAccess, out string? nullableWriteCode))
+ {
+ sb.AppendLine($" {nullableWriteCode}");
+ return;
+ }
+
+ sb.AppendLine(
+ $" context.TypeResolver.GetSerializer<{member.TypeName}>().Write(ref context, {memberAccess}, {refModeExpr}, {writeTypeInfo}, {hasGenerics});");
+ }
+
+ private static void EmitReadMemberAssignment(
+ StringBuilder sb,
+ MemberModel member,
+ string refModeExpr,
+ string readTypeInfoExpr,
+ string valueVar,
+ string variableSuffix,
+ int indentLevel,
+ bool allowDirectRead)
+ {
+ string indent = new(' ', indentLevel * 2);
+ string assignmentTarget = $"{valueVar}.{member.Name}";
+ string typeOfTypeName = StripNullableForTypeOf(member.TypeName);
+ switch (member.DynamicAnyKind)
+ {
+ case DynamicAnyKind.AnyValue:
+ sb.AppendLine(
+ $"{indent}{assignmentTarget} = ({member.TypeName})global::Apache.Fory.DynamicAnyCodec.CastAnyDynamicValue(global::Apache.Fory.DynamicAnyCodec.ReadAny(ref context, {refModeExpr}, true), typeof({typeOfTypeName}))!;");
+ return;
+ case DynamicAnyKind.None:
+ break;
+ default:
+ throw new InvalidOperationException($"unsupported dynamic any kind {member.DynamicAnyKind}");
+ }
+
+ if (allowDirectRead && !member.IsNullable && TryBuildDirectFieldRead(member, out string? directReadExpr))
+ {
+ sb.AppendLine($"{indent}{assignmentTarget} = {directReadExpr};");
+ return;
+ }
+
+ if (allowDirectRead && TryBuildNullableFixedTaggedFieldRead(member, assignmentTarget, variableSuffix, indent, out string? nullableReadCode))
+ {
+ sb.AppendLine(nullableReadCode);
+ return;
+ }
+
+ sb.AppendLine(
+ $"{indent}{assignmentTarget} = context.TypeResolver.GetSerializer<{member.TypeName}>().Read(ref context, {refModeExpr}, {readTypeInfoExpr});");
+ }
+
+ private static string StripNullableForTypeOf(string typeName)
+ {
+ return typeName.Replace("?", string.Empty);
+ }
+
+ private static bool TryBuildDirectFieldWrite(MemberModel member, string memberAccess, out string? writeCode)
+ {
+ writeCode = null;
+ if (!CanUseDirectBuiltInFieldAccess(member))
+ {
+ return false;
+ }
+
+ return TryBuildDirectPayloadWrite(member.Classification.TypeId, memberAccess, out writeCode);
+ }
+
+ private static bool TryBuildDirectFieldRead(MemberModel member, out string? readExpr)
+ {
+ readExpr = null;
+ if (!CanUseDirectBuiltInFieldAccess(member))
+ {
+ return false;
+ }
+
+ return TryBuildDirectPayloadRead(member.Classification.TypeId, out readExpr);
+ }
+
+ private static bool TryBuildNullableFixedTaggedFieldWrite(MemberModel member, string memberAccess, out string? writeCode)
+ {
+ writeCode = null;
+ if (!member.IsNullableValueType || !IsFixedTaggedTypeId(member.Classification.TypeId))
+ {
+ return false;
+ }
+
+ if (!TryBuildDirectPayloadWrite(member.Classification.TypeId, $"{memberAccess}.Value", out string? payloadWriteCode))
+ {
+ return false;
+ }
+
+ writeCode = $"if (!{memberAccess}.HasValue) {{ context.Writer.WriteInt8((sbyte)global::Apache.Fory.RefFlag.Null); }} else {{ context.Writer.WriteInt8((sbyte)global::Apache.Fory.RefFlag.NotNullValue); {payloadWriteCode} }}";
+ return true;
+ }
+
+ private static bool TryBuildNullableFixedTaggedFieldRead(
+ MemberModel member,
+ string assignmentTarget,
+ string variableSuffix,
+ string indent,
+ out string code)
+ {
+ code = string.Empty;
+ if (!member.IsNullableValueType || !IsFixedTaggedTypeId(member.Classification.TypeId))
+ {
+ return false;
+ }
+
+ if (!TryBuildDirectPayloadRead(member.Classification.TypeId, out string? payloadReadExpr))
+ {
+ return false;
+ }
+
+ string refFlagVar = $"__{member.Name}RefFlag{variableSuffix}";
+ string nestedIndent = indent + " ";
+ StringBuilder sb = new();
+ sb.AppendLine($"{indent}sbyte {refFlagVar} = context.Reader.ReadInt8();");
+ sb.AppendLine($"{indent}if ({refFlagVar} == (sbyte)global::Apache.Fory.RefFlag.Null)");
+ sb.AppendLine($"{indent}{{");
+ sb.AppendLine($"{nestedIndent}{assignmentTarget} = ({member.TypeName})null!;");
+ sb.AppendLine($"{indent}}}");
+ sb.AppendLine($"{indent}else");
+ sb.AppendLine($"{indent}{{");
+ sb.AppendLine($"{nestedIndent}{assignmentTarget} = {payloadReadExpr};");
+ sb.Append($"{indent}}}");
+ code = sb.ToString();
+ return true;
+ }
+
+ private static bool IsFixedTaggedTypeId(uint typeId)
+ {
+ return typeId is 4 or 6 or 8 or 11 or 13 or 15;
+ }
+
+ private static bool TryBuildDirectPayloadWrite(uint typeId, string valueExpr, out string? writeCode)
+ {
+ writeCode = null;
+ switch (typeId)
+ {
+ case 1:
+ writeCode = $"context.Writer.WriteUInt8({valueExpr} ? (byte)1 : (byte)0);";
+ return true;
+ case 2:
+ writeCode = $"context.Writer.WriteInt8({valueExpr});";
+ return true;
+ case 3:
+ writeCode = $"context.Writer.WriteInt16({valueExpr});";
+ return true;
+ case 4:
+ writeCode = $"context.Writer.WriteInt32({valueExpr});";
+ return true;
+ case 5:
+ writeCode = $"context.Writer.WriteVarInt32({valueExpr});";
+ return true;
+ case 6:
+ writeCode = $"context.Writer.WriteInt64({valueExpr});";
+ return true;
+ case 7:
+ writeCode = $"context.Writer.WriteVarInt64({valueExpr});";
+ return true;
+ case 8:
+ writeCode = $"context.Writer.WriteTaggedInt64({valueExpr});";
+ return true;
+ case 9:
+ writeCode = $"context.Writer.WriteUInt8({valueExpr});";
+ return true;
+ case 10:
+ writeCode = $"context.Writer.WriteUInt16({valueExpr});";
+ return true;
+ case 11:
+ writeCode = $"context.Writer.WriteUInt32({valueExpr});";
+ return true;
+ case 12:
+ writeCode = $"context.Writer.WriteVarUInt32({valueExpr});";
+ return true;
+ case 13:
+ writeCode = $"context.Writer.WriteUInt64({valueExpr});";
+ return true;
+ case 14:
+ writeCode = $"context.Writer.WriteVarUInt64({valueExpr});";
+ return true;
+ case 15:
+ writeCode = $"context.Writer.WriteTaggedUInt64({valueExpr});";
+ return true;
+ case 19:
+ writeCode = $"context.Writer.WriteFloat32({valueExpr});";
+ return true;
+ case 20:
+ writeCode = $"context.Writer.WriteFloat64({valueExpr});";
+ return true;
+ case 21:
+ writeCode = $"global::Apache.Fory.StringSerializer.WriteString(ref context, {valueExpr});";
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ private static bool TryBuildDirectPayloadRead(uint typeId, out string? readExpr)
+ {
+ readExpr = null;
+ switch (typeId)
+ {
+ case 1:
+ readExpr = "context.Reader.ReadUInt8() != 0";
+ return true;
+ case 2:
+ readExpr = "context.Reader.ReadInt8()";
+ return true;
+ case 3:
+ readExpr = "context.Reader.ReadInt16()";
+ return true;
+ case 4:
+ readExpr = "context.Reader.ReadInt32()";
+ return true;
+ case 5:
+ readExpr = "context.Reader.ReadVarInt32()";
+ return true;
+ case 6:
+ readExpr = "context.Reader.ReadInt64()";
+ return true;
+ case 7:
+ readExpr = "context.Reader.ReadVarInt64()";
+ return true;
+ case 8:
+ readExpr = "context.Reader.ReadTaggedInt64()";
+ return true;
+ case 9:
+ readExpr = "context.Reader.ReadUInt8()";
+ return true;
+ case 10:
+ readExpr = "context.Reader.ReadUInt16()";
+ return true;
+ case 11:
+ readExpr = "context.Reader.ReadUInt32()";
+ return true;
+ case 12:
+ readExpr = "context.Reader.ReadVarUInt32()";
+ return true;
+ case 13:
+ readExpr = "context.Reader.ReadUInt64()";
+ return true;
+ case 14:
+ readExpr = "context.Reader.ReadVarUInt64()";
+ return true;
+ case 15:
+ readExpr = "context.Reader.ReadTaggedUInt64()";
+ return true;
+ case 19:
+ readExpr = "context.Reader.ReadFloat32()";
+ return true;
+ case 20:
+ readExpr = "context.Reader.ReadFloat64()";
+ return true;
+ case 21:
+ readExpr = "global::Apache.Fory.StringSerializer.ReadString(ref context)";
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ private static bool CanUseDirectBuiltInFieldAccess(MemberModel member)
+ {
+ if (member.IsNullable ||
+ member.DynamicAnyKind != DynamicAnyKind.None ||
+ member.IsCollection ||
+ member.Classification.IsMap)
+ {
+ return false;
+ }
+
+ return member.Classification.IsPrimitive || member.Classification.TypeId == 21;
+ }
+
+ private static string BuildSchemaFingerprintExpression(ImmutableArray members)
+ {
+ if (members.IsDefaultOrEmpty)
+ {
+ return "\"\"";
+ }
+
+ IEnumerable ordered = members
+ .OrderBy(m => m.FieldIdentifier, StringComparer.Ordinal)
+ .ThenBy(m => m.OriginalIndex);
+
+ StringBuilder sb = new();
+ bool first = true;
+ foreach (MemberModel member in ordered)
+ {
+ uint fingerprintTypeId = (member.Classification.IsPrimitive || member.Classification.IsBuiltIn)
+ ? member.Classification.TypeId
+ : 0;
+ string trackRefExpr = member.DynamicAnyKind switch
+ {
+ DynamicAnyKind.AnyValue => "(trackRef ? 1 : 0)",
+ _ => member.Classification.IsBuiltIn
+ ? "0"
+ : $"((trackRef && typeResolver.GetTypeInfo<{member.TypeName}>().IsReferenceTrackableType) ? 1 : 0)",
+ };
+ string nullable = member.IsNullable ? "1" : "0";
+ string piece = $"\"{EscapeString(member.FieldIdentifier)},{fingerprintTypeId},\" + {trackRefExpr} + \",{nullable};\"";
+ if (!first)
+ {
+ sb.Append(" + ");
+ }
+
+ first = false;
+ sb.Append(piece);
+ }
+
+ return sb.ToString();
+ }
+
+ private static string BuildCompatibleTypeMetaExpression(TypeMetaFieldTypeModel model, string trackRefExpr)
+ {
+ string localTrackRefExpr = model.TrackRefByContext ? trackRefExpr : "false";
+ if (model.Generics.Length > 0)
+ {
+ string generics = string.Join(
+ ", ",
+ model.Generics.Select(g => BuildCompatibleTypeMetaExpression(g, "false")));
+ return
+ $"new global::Apache.Fory.TypeMetaFieldType({model.TypeIdExpr}, {BoolLiteral(model.Nullable)}, {localTrackRefExpr}, new global::Apache.Fory.TypeMetaFieldType[] {{ {generics} }})";
+ }
+
+ return $"new global::Apache.Fory.TypeMetaFieldType({model.TypeIdExpr}, {BoolLiteral(model.Nullable)}, {localTrackRefExpr})";
+ }
+
+ private static string BuildWriteRefModeExpression(MemberModel member)
+ {
+ return member.DynamicAnyKind switch
+ {
+ DynamicAnyKind.AnyValue => $"__ForyRefMode({BoolLiteral(member.IsNullable)}, context.TrackRef)",
+ _ => member.Classification.IsBuiltIn
+ ? $"__ForyRefMode({BoolLiteral(member.IsNullable)}, false)"
+ : $"__ForyRefMode({BoolLiteral(member.IsNullable)}, context.TrackRef && context.TypeResolver.GetTypeInfo<{member.TypeName}>().IsReferenceTrackableType)",
+ };
+ }
+
+ private static TypeModel? BuildTypeModel(GeneratorAttributeSyntaxContext context, CancellationToken cancellationToken)
+ {
+ _ = cancellationToken;
+ if (context.TargetSymbol is not INamedTypeSymbol typeSymbol)
+ {
+ return null;
+ }
+
+ if (typeSymbol.TypeParameters.Length > 0)
+ {
+ return null;
+ }
+
+ string typeName = typeSymbol.ToDisplayString(FullNameFormat);
+ string serializerName = "__ForySerializer_" + Sanitize(typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
+ if (typeSymbol.TypeKind == TypeKind.Enum)
+ {
+ return new TypeModel(
+ typeName,
+ serializerName,
+ DeclKind.Enum,
+ ImmutableArray.Empty,
+ ImmutableArray.Empty);
+ }
+
+ DeclKind kind = typeSymbol.TypeKind switch
+ {
+ TypeKind.Struct => DeclKind.Struct,
+ TypeKind.Class => DeclKind.Class,
+ _ => DeclKind.Unknown,
+ };
+
+ if (kind == DeclKind.Unknown)
+ {
+ return null;
+ }
+
+ if (kind == DeclKind.Class && !HasAccessibleParameterlessCtor(typeSymbol))
+ {
+ return null;
+ }
+
+ List members = [];
+ foreach (ISymbol member in typeSymbol.GetMembers())
+ {
+ if (member.IsStatic)
+ {
+ continue;
+ }
+
+ if (member is IFieldSymbol field)
+ {
+ if (field.IsConst || field.IsReadOnly || !IsReadableWritableAccessibility(field.DeclaredAccessibility))
+ {
+ continue;
+ }
+
+ MemberModel? parsedField = BuildMemberModel(field.Name, field.Type, field, MemberDeclKind.Field);
+ if (parsedField is not null)
+ {
+ members.Add(parsedField);
+ }
+
+ continue;
+ }
+
+ if (member is IPropertySymbol property)
+ {
+ if (property.IsIndexer || property.GetMethod is null || property.SetMethod is null)
+ {
+ continue;
+ }
+
+ if (property.SetMethod.IsInitOnly)
+ {
+ continue;
+ }
+
+ if (!IsReadableWritableAccessibility(property.GetMethod.DeclaredAccessibility) ||
+ !IsReadableWritableAccessibility(property.SetMethod.DeclaredAccessibility))
+ {
+ continue;
+ }
+
+ MemberModel? parsedProperty = BuildMemberModel(
+ property.Name,
+ property.Type,
+ property,
+ MemberDeclKind.Property);
+ if (parsedProperty is not null)
+ {
+ members.Add(parsedProperty);
+ }
+ }
+ }
+
+ ImmutableArray ordered = members
+ .OrderBy(m => m.OriginalIndex)
+ .ToImmutableArray();
+ ImmutableArray sorted = SortMembers(ordered);
+
+ return new TypeModel(typeName, serializerName, kind, ordered, sorted);
+ }
+
+ private static MemberModel? BuildMemberModel(
+ string name,
+ ITypeSymbol memberType,
+ ISymbol memberSymbol,
+ MemberDeclKind memberDeclKind)
+ {
+ (bool isOptional, ITypeSymbol unwrappedType) = UnwrapNullable(memberType);
+ FieldEncoding fieldEncoding = FieldEncoding.None;
+ foreach (AttributeData attribute in memberSymbol.GetAttributes())
+ {
+ string? attrName = attribute.AttributeClass?.ToDisplayString();
+ if (!string.Equals(attrName, "Apache.Fory.FieldAttribute", StringComparison.Ordinal))
+ {
+ continue;
+ }
+
+ foreach (KeyValuePair namedArg in attribute.NamedArguments)
+ {
+ if (!string.Equals(namedArg.Key, "Encoding", StringComparison.Ordinal))
+ {
+ continue;
+ }
+
+ if (namedArg.Value.Value is int encoding)
+ {
+ fieldEncoding = (FieldEncoding)encoding;
+ }
+ }
+ }
+
+ DynamicAnyKind dynamicAnyKind = ResolveDynamicAnyKind(unwrappedType);
+ TypeResolution resolution = ResolveTypeResolution(unwrappedType, fieldEncoding);
+ if (!resolution.Supported)
+ {
+ return null;
+ }
+
+ TypeClassification classification = resolution.Classification;
+ int group = classification.IsPrimitive
+ ? (isOptional ? 2 : 1)
+ : classification.IsMap
+ ? 5
+ : classification.IsCollection
+ ? 4
+ : classification.IsBuiltIn
+ ? 3
+ : 6;
+
+ int index = int.MaxValue;
+ Location? sourceLocation = memberSymbol.Locations.FirstOrDefault(loc => loc.IsInSource);
+ if (sourceLocation is not null)
+ {
+ index = sourceLocation.SourceSpan.Start;
+ }
+
+ string typeName = memberType.ToDisplayString(FullNameFormat);
+ TypeMetaFieldTypeModel typeMeta = BuildTypeMetaFieldTypeModel(
+ memberType,
+ isOptional,
+ dynamicAnyKind,
+ resolution.Classification.TypeId);
+
+ return new MemberModel(
+ name,
+ ToSnakeCase(name),
+ index,
+ memberDeclKind,
+ typeName,
+ isOptional,
+ memberType is INamedTypeSymbol nts &&
+ nts.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T,
+ classification,
+ group,
+ classification.IsCollection || classification.IsMap,
+ dynamicAnyKind == DynamicAnyKind.None ? DynamicAnyKind.None : dynamicAnyKind,
+ typeMeta);
+ }
+
+ private static TypeMetaFieldTypeModel BuildTypeMetaFieldTypeModel(
+ ITypeSymbol memberType,
+ bool nullable,
+ DynamicAnyKind dynamicAnyKind,
+ uint explicitTypeId)
+ {
+ (bool _, ITypeSymbol unwrapped) = UnwrapNullable(memberType);
+
+ if (TryGetListElementType(unwrapped, out ITypeSymbol? listElementType))
+ {
+ bool elementNullable = GenericNullable(listElementType!);
+ TypeMetaFieldTypeModel element = BuildTypeMetaFieldTypeModel(
+ listElementType!,
+ elementNullable,
+ ResolveDynamicAnyKind(UnwrapNullable(listElementType!).Item2),
+ 0);
+ return new TypeMetaFieldTypeModel(
+ "(uint)global::Apache.Fory.TypeId.List",
+ nullable,
+ false,
+ ImmutableArray.Create(element));
+ }
+
+ if (TryGetSetElementType(unwrapped, out ITypeSymbol? setElementType))
+ {
+ bool elementNullable = GenericNullable(setElementType!);
+ TypeMetaFieldTypeModel element = BuildTypeMetaFieldTypeModel(
+ setElementType!,
+ elementNullable,
+ ResolveDynamicAnyKind(UnwrapNullable(setElementType!).Item2),
+ 0);
+ return new TypeMetaFieldTypeModel(
+ "(uint)global::Apache.Fory.TypeId.Set",
+ nullable,
+ false,
+ ImmutableArray.Create(element));
+ }
+
+ if (TryGetMapTypeArguments(unwrapped, out ITypeSymbol? keyType, out ITypeSymbol? valueType))
+ {
+ bool keyNullable = GenericNullable(keyType!);
+ bool valueNullable = GenericNullable(valueType!);
+ TypeMetaFieldTypeModel key = BuildTypeMetaFieldTypeModel(
+ keyType!,
+ keyNullable,
+ ResolveDynamicAnyKind(UnwrapNullable(keyType!).Item2),
+ 0);
+ TypeMetaFieldTypeModel value = BuildTypeMetaFieldTypeModel(
+ valueType!,
+ valueNullable,
+ ResolveDynamicAnyKind(UnwrapNullable(valueType!).Item2),
+ 0);
+ return new TypeMetaFieldTypeModel(
+ "(uint)global::Apache.Fory.TypeId.Map",
+ nullable,
+ false,
+ ImmutableArray.Create(key, value));
+ }
+
+ TypeClassification classification = ClassifyType(unwrapped);
+ if (explicitTypeId != 0 && classification.IsPrimitive && classification.TypeId != explicitTypeId)
+ {
+ return new TypeMetaFieldTypeModel(
+ explicitTypeId.ToString(),
+ nullable,
+ false,
+ ImmutableArray.Empty);
+ }
+
+ if (IsUnionType(unwrapped))
+ {
+ return new TypeMetaFieldTypeModel(
+ "(uint)global::Apache.Fory.TypeId.Union",
+ nullable,
+ true,
+ ImmutableArray.Empty);
+ }
+
+ if (dynamicAnyKind == DynamicAnyKind.AnyValue)
+ {
+ return new TypeMetaFieldTypeModel(
+ "(uint)global::Apache.Fory.TypeId.Unknown",
+ nullable,
+ true,
+ ImmutableArray.Empty);
+ }
+
+ if (unwrapped.TypeKind == TypeKind.Enum)
+ {
+ return new TypeMetaFieldTypeModel(
+ "(uint)global::Apache.Fory.TypeId.Enum",
+ nullable,
+ false,
+ ImmutableArray.Empty);
+ }
+
+ return new TypeMetaFieldTypeModel(
+ $"(uint){classification.TypeId}",
+ nullable,
+ !classification.IsBuiltIn && unwrapped.TypeKind != TypeKind.Enum,
+ ImmutableArray.Empty);
+ }
+
+ private static ImmutableArray SortMembers(ImmutableArray members)
+ {
+ return members
+ .OrderBy(m => m.Group)
+ .ThenBy(m =>
+ {
+ if (m.Group is 1 or 2)
+ {
+ return m.Classification.IsCompressedNumeric ? 1 : 0;
+ }
+
+ return 0;
+ })
+ .ThenByDescending(m => m.Group is 1 or 2 ? m.Classification.PrimitiveSize : 0)
+ .ThenBy(m =>
+ {
+ if (m.Group is 1 or 2)
+ {
+ return (int)(uint.MaxValue - m.Classification.TypeId);
+ }
+
+ if (m.Group is 3 or 4 or 5)
+ {
+ return (int)m.Classification.TypeId;
+ }
+
+ return 0;
+ })
+ .ThenBy(m => m.FieldIdentifier, StringComparer.Ordinal)
+ .ThenBy(m => m.Name, StringComparer.Ordinal)
+ .ThenBy(m => m.OriginalIndex)
+ .ToImmutableArray();
+ }
+
+ private static bool GenericNullable(ITypeSymbol type)
+ {
+ (bool optional, ITypeSymbol unwrapped) = UnwrapNullable(type);
+ if (optional)
+ {
+ return true;
+ }
+
+ TypeClassification c = ClassifyType(unwrapped);
+ return !c.IsPrimitive;
+ }
+
+ private static bool IsReadableWritableAccessibility(Accessibility accessibility)
+ {
+ return accessibility is Accessibility.Public or Accessibility.Internal or Accessibility.ProtectedOrInternal;
+ }
+
+ private static bool HasAccessibleParameterlessCtor(INamedTypeSymbol type)
+ {
+ foreach (IMethodSymbol ctor in type.InstanceConstructors)
+ {
+ if (ctor.Parameters.Length != 0)
+ {
+ continue;
+ }
+
+ if (ctor.DeclaredAccessibility is Accessibility.Public or Accessibility.Internal or Accessibility.ProtectedOrInternal)
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private static TypeResolution ResolveTypeResolution(ITypeSymbol type, FieldEncoding encoding)
+ {
+ TypeClassification baseType = ClassifyType(type);
+ if (encoding == FieldEncoding.None)
+ {
+ return new TypeResolution(true, baseType);
+ }
+
+ bool isInt32 = type.SpecialType == SpecialType.System_Int32;
+ bool isUInt32 = type.SpecialType == SpecialType.System_UInt32;
+ bool isInt64 = type.SpecialType == SpecialType.System_Int64;
+ bool isUInt64 = type.SpecialType == SpecialType.System_UInt64;
+
+ if (isInt32)
+ {
+ return encoding switch
+ {
+ FieldEncoding.Varint => new TypeResolution(true, baseType),
+ FieldEncoding.Fixed => new TypeResolution(
+ true,
+ new TypeClassification(4, true, true, false, false, false, 4)),
+ _ => new TypeResolution(false, baseType),
+ };
+ }
+
+ if (isUInt32)
+ {
+ return encoding switch
+ {
+ FieldEncoding.Varint => new TypeResolution(true, baseType),
+ FieldEncoding.Fixed => new TypeResolution(
+ true,
+ new TypeClassification(11, true, true, false, false, false, 4)),
+ _ => new TypeResolution(false, baseType),
+ };
+ }
+
+ if (isInt64)
+ {
+ return encoding switch
+ {
+ FieldEncoding.Varint => new TypeResolution(true, baseType),
+ FieldEncoding.Fixed => new TypeResolution(
+ true,
+ new TypeClassification(6, true, true, false, false, false, 8)),
+ FieldEncoding.Tagged => new TypeResolution(
+ true,
+ new TypeClassification(8, true, true, false, false, true, 8)),
+ _ => new TypeResolution(false, baseType),
+ };
+ }
+
+ if (isUInt64)
+ {
+ return encoding switch
+ {
+ FieldEncoding.Varint => new TypeResolution(true, baseType),
+ FieldEncoding.Fixed => new TypeResolution(
+ true,
+ new TypeClassification(13, true, true, false, false, false, 8)),
+ FieldEncoding.Tagged => new TypeResolution(
+ true,
+ new TypeClassification(15, true, true, false, false, true, 8)),
+ _ => new TypeResolution(false, baseType),
+ };
+ }
+
+ return new TypeResolution(false, baseType);
+ }
+
+ private static TypeClassification ClassifyType(ITypeSymbol type)
+ {
+ if (ResolveDynamicAnyKind(type) == DynamicAnyKind.AnyValue)
+ {
+ return new TypeClassification(0, false, true, false, false, false, 0);
+ }
+
+ if (type.SpecialType == SpecialType.System_Boolean)
+ {
+ return new TypeClassification(1, true, true, false, false, false, 1);
+ }
+
+ if (type.SpecialType == SpecialType.System_SByte)
+ {
+ return new TypeClassification(2, true, true, false, false, false, 1);
+ }
+
+ if (type.SpecialType == SpecialType.System_Int16)
+ {
+ return new TypeClassification(3, true, true, false, false, false, 2);
+ }
+
+ if (type.SpecialType == SpecialType.System_Int32)
+ {
+ return new TypeClassification(5, true, true, false, false, true, 4);
+ }
+
+ if (type.SpecialType == SpecialType.System_Int64)
+ {
+ return new TypeClassification(7, true, true, false, false, true, 8);
+ }
+
+ if (type.SpecialType == SpecialType.System_Byte)
+ {
+ return new TypeClassification(9, true, true, false, false, false, 1);
+ }
+
+ if (type.SpecialType == SpecialType.System_UInt16)
+ {
+ return new TypeClassification(10, true, true, false, false, false, 2);
+ }
+
+ if (type.SpecialType == SpecialType.System_UInt32)
+ {
+ return new TypeClassification(12, true, true, false, false, true, 4);
+ }
+
+ if (type.SpecialType == SpecialType.System_UInt64)
+ {
+ return new TypeClassification(14, true, true, false, false, true, 8);
+ }
+
+ if (type.SpecialType == SpecialType.System_Single)
+ {
+ return new TypeClassification(19, true, true, false, false, false, 4);
+ }
+
+ if (type.SpecialType == SpecialType.System_Double)
+ {
+ return new TypeClassification(20, true, true, false, false, false, 8);
+ }
+
+ if (type.SpecialType == SpecialType.System_String)
+ {
+ return new TypeClassification(21, false, true, false, false, false, 0);
+ }
+
+ if (IsDateType(type))
+ {
+ return new TypeClassification(39, false, true, false, false, false, 0);
+ }
+
+ if (IsTimestampType(type))
+ {
+ return new TypeClassification(38, false, true, false, false, false, 0);
+ }
+
+ if (IsDurationType(type))
+ {
+ return new TypeClassification(37, false, true, false, false, false, 0);
+ }
+
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ TypeClassification elem = ClassifyType(arrayType.ElementType);
+ uint typeId = elem.TypeId switch
+ {
+ 9 => 41,
+ 1 => 43,
+ 2 => 44,
+ 3 => 45,
+ 5 => 46,
+ 7 => 47,
+ 10 => 49,
+ 12 => 50,
+ 14 => 51,
+ 19 => 55,
+ 20 => 56,
+ _ => 22,
+ };
+ return new TypeClassification(typeId, false, true, true, false, false, 0);
+ }
+
+ if (TryGetListElementType(type, out _))
+ {
+ return new TypeClassification(22, false, true, true, false, false, 0);
+ }
+
+ if (TryGetSetElementType(type, out _))
+ {
+ return new TypeClassification(23, false, true, true, false, false, 0);
+ }
+
+ if (TryGetMapTypeArguments(type, out _, out _))
+ {
+ return new TypeClassification(24, false, true, false, true, false, 0);
+ }
+
+ if (IsUnionType(type))
+ {
+ return new TypeClassification(33, false, false, false, false, false, 0);
+ }
+
+ return new TypeClassification(27, false, false, false, false, false, 0);
+ }
+
+ private static DynamicAnyKind ResolveDynamicAnyKind(ITypeSymbol type)
+ {
+ if (type.SpecialType == SpecialType.System_Object)
+ {
+ return DynamicAnyKind.AnyValue;
+ }
+
+ return DynamicAnyKind.None;
+ }
+
+ private static bool IsDateType(ITypeSymbol symbol)
+ {
+ return string.Equals(symbol.ToDisplayString(), "System.DateOnly", StringComparison.Ordinal);
+ }
+
+ private static bool IsTimestampType(ITypeSymbol symbol)
+ {
+ string name = symbol.ToDisplayString();
+ return string.Equals(name, "System.DateTime", StringComparison.Ordinal) ||
+ string.Equals(name, "System.DateTimeOffset", StringComparison.Ordinal);
+ }
+
+ private static bool IsDurationType(ITypeSymbol symbol)
+ {
+ return string.Equals(symbol.ToDisplayString(), "System.TimeSpan", StringComparison.Ordinal);
+ }
+
+ private static bool IsUnionType(ITypeSymbol symbol)
+ {
+ INamedTypeSymbol? current = symbol as INamedTypeSymbol;
+ while (current is not null)
+ {
+ if (string.Equals(current.ToDisplayString(), "Apache.Fory.Union", StringComparison.Ordinal))
+ {
+ return true;
+ }
+
+ current = current.BaseType;
+ }
+
+ return false;
+ }
+
+ private static bool TryGetListElementType(ITypeSymbol type, out ITypeSymbol? elementType)
+ {
+ elementType = null;
+ if (type is IArrayTypeSymbol arrayType)
+ {
+ elementType = arrayType.ElementType;
+ return true;
+ }
+
+ if (type is not INamedTypeSymbol named)
+ {
+ return false;
+ }
+
+ string genericName = named.ConstructedFrom.ToDisplayString();
+ if (genericName is
+ "System.Collections.Generic.List" or
+ "System.Collections.Generic.IList" or
+ "System.Collections.Generic.IReadOnlyList")
+ {
+ elementType = named.TypeArguments[0];
+ return true;
+ }
+
+ return false;
+ }
+
+ private static bool TryGetSetElementType(ITypeSymbol type, out ITypeSymbol? elementType)
+ {
+ elementType = null;
+ if (type is not INamedTypeSymbol named)
+ {
+ return false;
+ }
+
+ string genericName = named.ConstructedFrom.ToDisplayString();
+ if (genericName is
+ "System.Collections.Generic.HashSet" or
+ "System.Collections.Generic.ISet" or
+ "System.Collections.Generic.IReadOnlySet")
+ {
+ elementType = named.TypeArguments[0];
+ return true;
+ }
+
+ return false;
+ }
+
+ private static bool TryGetMapTypeArguments(ITypeSymbol type, out ITypeSymbol? keyType, out ITypeSymbol? valueType)
+ {
+ keyType = null;
+ valueType = null;
+ if (type is not INamedTypeSymbol named)
+ {
+ return false;
+ }
+
+ string genericName = named.ConstructedFrom.ToDisplayString();
+ if (genericName is
+ "System.Collections.Generic.Dictionary" or
+ "System.Collections.Generic.IDictionary" or
+ "System.Collections.Generic.IReadOnlyDictionary" or
+ "Apache.Fory.NullableKeyDictionary")
+ {
+ keyType = named.TypeArguments[0];
+ valueType = named.TypeArguments[1];
+ return true;
+ }
+
+ return false;
+ }
+
+ private static (bool, ITypeSymbol) UnwrapNullable(ITypeSymbol type)
+ {
+ if (type is INamedTypeSymbol named &&
+ named.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
+ {
+ return (true, named.TypeArguments[0]);
+ }
+
+ if (type.IsReferenceType && type.NullableAnnotation == NullableAnnotation.Annotated)
+ {
+ return (true, type.WithNullableAnnotation(NullableAnnotation.NotAnnotated));
+ }
+
+ return (false, type);
+ }
+
+ private static string BoolLiteral(bool value) => value ? "true" : "false";
+
+ private static string EscapeString(string value) => value.Replace("\\", "\\\\").Replace("\"", "\\\"");
+
+ private static string ToSnakeCase(string name)
+ {
+ if (string.IsNullOrEmpty(name))
+ {
+ return name;
+ }
+
+ StringBuilder sb = new(name.Length + 4);
+ for (int i = 0; i < name.Length; i++)
+ {
+ char c = name[i];
+ if (char.IsUpper(c))
+ {
+ if (i > 0)
+ {
+ bool prevUpper = char.IsUpper(name[i - 1]);
+ bool nextUpperOrEnd = i + 1 >= name.Length || char.IsUpper(name[i + 1]);
+ if (!prevUpper || !nextUpperOrEnd)
+ {
+ sb.Append('_');
+ }
+ }
+
+ sb.Append(char.ToLowerInvariant(c));
+ }
+ else
+ {
+ sb.Append(c);
+ }
+ }
+
+ return sb.ToString();
+ }
+
+ private static string Sanitize(string name)
+ {
+ StringBuilder sb = new(name.Length + 8);
+ foreach (char c in name)
+ {
+ sb.Append(char.IsLetterOrDigit(c) ? c : '_');
+ }
+
+ return sb.ToString();
+ }
+
+ private sealed class TypeResolution
+ {
+ public TypeResolution(bool supported, TypeClassification classification)
+ {
+ Supported = supported;
+ Classification = classification;
+ }
+
+ public bool Supported { get; }
+ public TypeClassification Classification { get; }
+ }
+
+ private sealed class TypeClassification
+ {
+ public TypeClassification(
+ uint typeId,
+ bool isPrimitive,
+ bool isBuiltIn,
+ bool isCollection,
+ bool isMap,
+ bool isCompressedNumeric,
+ int primitiveSize)
+ {
+ TypeId = typeId;
+ IsPrimitive = isPrimitive;
+ IsBuiltIn = isBuiltIn;
+ IsCollection = isCollection;
+ IsMap = isMap;
+ IsCompressedNumeric = isCompressedNumeric;
+ PrimitiveSize = primitiveSize;
+ }
+
+ public uint TypeId { get; }
+ public bool IsPrimitive { get; }
+ public bool IsBuiltIn { get; }
+ public bool IsCollection { get; }
+ public bool IsMap { get; }
+ public bool IsCompressedNumeric { get; }
+ public int PrimitiveSize { get; }
+ }
+
+ private sealed class TypeMetaFieldTypeModel
+ {
+ public TypeMetaFieldTypeModel(
+ string typeIdExpr,
+ bool nullable,
+ bool trackRefByContext,
+ ImmutableArray generics)
+ {
+ TypeIdExpr = typeIdExpr;
+ Nullable = nullable;
+ TrackRefByContext = trackRefByContext;
+ Generics = generics;
+ }
+
+ public string TypeIdExpr { get; }
+ public bool Nullable { get; }
+ public bool TrackRefByContext { get; }
+ public ImmutableArray Generics { get; }
+ }
+
+ private sealed class TypeModel
+ {
+ public TypeModel(
+ string typeName,
+ string serializerName,
+ DeclKind kind,
+ ImmutableArray members,
+ ImmutableArray sortedMembers)
+ {
+ TypeName = typeName;
+ SerializerName = serializerName;
+ Kind = kind;
+ Members = members;
+ SortedMembers = sortedMembers;
+ }
+
+ public string TypeName { get; }
+ public string SerializerName { get; }
+ public DeclKind Kind { get; }
+ public ImmutableArray Members { get; }
+ public ImmutableArray SortedMembers { get; }
+ }
+
+ private sealed class MemberModel
+ {
+ public MemberModel(
+ string name,
+ string fieldIdentifier,
+ int originalIndex,
+ MemberDeclKind declKind,
+ string typeName,
+ bool isNullable,
+ bool isNullableValueType,
+ TypeClassification classification,
+ int group,
+ bool isCollection,
+ DynamicAnyKind dynamicAnyKind,
+ TypeMetaFieldTypeModel typeMeta)
+ {
+ Name = name;
+ FieldIdentifier = fieldIdentifier;
+ OriginalIndex = originalIndex;
+ DeclKind = declKind;
+ TypeName = typeName;
+ IsNullable = isNullable;
+ IsNullableValueType = isNullableValueType;
+ Classification = classification;
+ Group = group;
+ IsCollection = isCollection;
+ DynamicAnyKind = dynamicAnyKind;
+ TypeMeta = typeMeta;
+ }
+
+ public string Name { get; }
+ public string FieldIdentifier { get; }
+ public int OriginalIndex { get; }
+ public MemberDeclKind DeclKind { get; }
+ public string TypeName { get; }
+ public bool IsNullable { get; }
+ public bool IsNullableValueType { get; }
+ public TypeClassification Classification { get; }
+ public int Group { get; }
+ public bool IsCollection { get; }
+ public DynamicAnyKind DynamicAnyKind { get; }
+ public TypeMetaFieldTypeModel TypeMeta { get; }
+ }
+
+ private enum MemberDeclKind
+ {
+ Field,
+ Property,
+ }
+
+ private enum DeclKind
+ {
+ Unknown,
+ Class,
+ Struct,
+ Enum,
+ }
+
+ private enum DynamicAnyKind
+ {
+ None,
+ AnyValue,
+ }
+
+ private enum FieldEncoding
+ {
+ None = -1,
+ Varint = 0,
+ Fixed = 1,
+ Tagged = 2,
+ }
+}
diff --git a/csharp/src/Fory/AnySerializer.cs b/csharp/src/Fory/AnySerializer.cs
new file mode 100644
index 0000000000..9ca4008b09
--- /dev/null
+++ b/csharp/src/Fory/AnySerializer.cs
@@ -0,0 +1,445 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+public sealed class DynamicAnyObjectSerializer : Serializer
+{
+ public override TypeId StaticTypeId => TypeId.Unknown;
+ public override bool IsNullableType => true;
+ public override bool IsReferenceTrackableType => true;
+ public override object? DefaultValue => null;
+ public override bool IsNone(in object? value) => value is null;
+
+ public override void WriteData(ref WriteContext context, in object? value, bool hasGenerics)
+ {
+ if (IsNone(value))
+ {
+ return;
+ }
+
+ DynamicAnyCodec.WriteAnyPayload(value!, ref context, hasGenerics);
+ }
+
+ public override object? ReadData(ref ReadContext context)
+ {
+ DynamicTypeInfo? dynamicTypeInfo = context.DynamicTypeInfo(typeof(object));
+ if (dynamicTypeInfo is null)
+ {
+ throw new InvalidDataException("dynamic Any value requires type info");
+ }
+
+ return context.TypeResolver.ReadDynamicValue(dynamicTypeInfo, ref context);
+ }
+
+ public override void WriteTypeInfo(ref WriteContext context)
+ {
+ throw new InvalidDataException("dynamic Any value type info is runtime-only");
+ }
+
+ public override void ReadTypeInfo(ref ReadContext context)
+ {
+ DynamicTypeInfo typeInfo = context.TypeResolver.ReadDynamicTypeInfo(ref context);
+ context.SetDynamicTypeInfo(typeof(object), typeInfo);
+ }
+
+ public override void Write(ref WriteContext context, in object? value, RefMode refMode, bool writeTypeInfo, bool hasGenerics)
+ {
+ if (refMode != RefMode.None)
+ {
+ if (IsNone(value))
+ {
+ context.Writer.WriteInt8((sbyte)RefFlag.Null);
+ return;
+ }
+
+ bool wroteTrackingRefFlag = false;
+ if (refMode == RefMode.Tracking && AnyValueIsReferenceTrackable(value!, context.TypeResolver))
+ {
+ if (context.RefWriter.TryWriteReference(context.Writer, value!))
+ {
+ return;
+ }
+
+ wroteTrackingRefFlag = true;
+ }
+
+ if (!wroteTrackingRefFlag)
+ {
+ context.Writer.WriteInt8((sbyte)RefFlag.NotNullValue);
+ }
+ }
+
+ if (writeTypeInfo)
+ {
+ DynamicAnyCodec.WriteAnyTypeInfo(value!, ref context);
+ }
+
+ WriteData(ref context, value, hasGenerics);
+ }
+
+ public override object? Read(ref ReadContext context, RefMode refMode, bool readTypeInfo)
+ {
+ if (refMode != RefMode.None)
+ {
+ sbyte rawFlag = context.Reader.ReadInt8();
+ RefFlag flag = (RefFlag)rawFlag;
+ switch (flag)
+ {
+ case RefFlag.Null:
+ return null;
+ case RefFlag.Ref:
+ {
+ uint refId = context.Reader.ReadVarUInt32();
+ return context.RefReader.ReadRefValue(refId);
+ }
+ case RefFlag.RefValue:
+ {
+ uint reservedRefId = context.RefReader.ReserveRefId();
+ context.PushPendingReference(reservedRefId);
+ if (readTypeInfo)
+ {
+ ReadTypeInfo(ref context);
+ }
+
+ object? value = ReadData(ref context);
+ if (readTypeInfo)
+ {
+ context.ClearDynamicTypeInfo(typeof(object));
+ }
+
+ context.FinishPendingReferenceIfNeeded(value);
+ context.PopPendingReference();
+ return value;
+ }
+ case RefFlag.NotNullValue:
+ break;
+ default:
+ throw new RefException($"invalid ref flag {rawFlag}");
+ }
+ }
+
+ if (readTypeInfo)
+ {
+ ReadTypeInfo(ref context);
+ }
+
+ object? result = ReadData(ref context);
+ if (readTypeInfo)
+ {
+ context.ClearDynamicTypeInfo(typeof(object));
+ }
+
+ return result;
+ }
+
+ private static bool AnyValueIsReferenceTrackable(object value, TypeResolver typeResolver)
+ {
+ Serializer serializer = typeResolver.GetSerializer(value.GetType());
+ return serializer.IsReferenceTrackableType;
+ }
+}
+
+public static class DynamicAnyCodec
+{
+ internal static void WriteAnyTypeInfo(object value, ref WriteContext context)
+ {
+ if (DynamicContainerCodec.TryGetTypeId(value, out TypeId containerTypeId))
+ {
+ context.Writer.WriteUInt8((byte)containerTypeId);
+ return;
+ }
+
+ if (TryWriteKnownTypeInfo(value, ref context))
+ {
+ return;
+ }
+
+ Serializer serializer = context.TypeResolver.GetSerializer(value.GetType());
+ serializer.WriteTypeInfo(ref context);
+ }
+
+ public static object? CastAnyDynamicValue(object? value, Type targetType)
+ {
+ if (value is null)
+ {
+ if (targetType == typeof(object))
+ {
+ return null;
+ }
+
+ if (!targetType.IsValueType || Nullable.GetUnderlyingType(targetType) is not null)
+ {
+ return null;
+ }
+
+ throw new InvalidDataException($"cannot cast null dynamic Any value to non-nullable {targetType}");
+ }
+
+ if (targetType.IsInstanceOfType(value))
+ {
+ return value;
+ }
+
+ throw new InvalidDataException($"cannot cast dynamic Any value to {targetType}");
+ }
+
+ public static void WriteAny(ref WriteContext context, object? value, RefMode refMode, bool writeTypeInfo = true, bool hasGenerics = false)
+ {
+ context.TypeResolver.GetSerializer().Write(ref context, value, refMode, writeTypeInfo, hasGenerics);
+ }
+
+ public static object? ReadAny(ref ReadContext context, RefMode refMode, bool readTypeInfo = true)
+ {
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, readTypeInfo);
+ }
+
+ public static void WriteAnyPayload(object value, ref WriteContext context, bool hasGenerics)
+ {
+ if (DynamicContainerCodec.TryWritePayload(value, ref context, hasGenerics))
+ {
+ return;
+ }
+
+ if (TryWriteKnownPayload(value, ref context))
+ {
+ return;
+ }
+
+ Serializer serializer = context.TypeResolver.GetSerializer(value.GetType());
+ serializer.WriteDataObject(ref context, value, hasGenerics);
+ }
+
+ private static bool TryWriteKnownTypeInfo(object value, ref WriteContext context)
+ {
+ switch (value)
+ {
+ case bool:
+ context.Writer.WriteUInt8((byte)TypeId.Bool);
+ return true;
+ case sbyte:
+ context.Writer.WriteUInt8((byte)TypeId.Int8);
+ return true;
+ case short:
+ context.Writer.WriteUInt8((byte)TypeId.Int16);
+ return true;
+ case int:
+ context.Writer.WriteUInt8((byte)TypeId.VarInt32);
+ return true;
+ case long:
+ context.Writer.WriteUInt8((byte)TypeId.VarInt64);
+ return true;
+ case byte:
+ context.Writer.WriteUInt8((byte)TypeId.UInt8);
+ return true;
+ case ushort:
+ context.Writer.WriteUInt8((byte)TypeId.UInt16);
+ return true;
+ case uint:
+ context.Writer.WriteUInt8((byte)TypeId.VarUInt32);
+ return true;
+ case ulong:
+ context.Writer.WriteUInt8((byte)TypeId.VarUInt64);
+ return true;
+ case float:
+ context.Writer.WriteUInt8((byte)TypeId.Float32);
+ return true;
+ case double:
+ context.Writer.WriteUInt8((byte)TypeId.Float64);
+ return true;
+ case string:
+ context.Writer.WriteUInt8((byte)TypeId.String);
+ return true;
+ case byte[]:
+ context.Writer.WriteUInt8((byte)TypeId.Binary);
+ return true;
+ case bool[]:
+ context.Writer.WriteUInt8((byte)TypeId.BoolArray);
+ return true;
+ case sbyte[]:
+ context.Writer.WriteUInt8((byte)TypeId.Int8Array);
+ return true;
+ case short[]:
+ context.Writer.WriteUInt8((byte)TypeId.Int16Array);
+ return true;
+ case int[]:
+ context.Writer.WriteUInt8((byte)TypeId.Int32Array);
+ return true;
+ case long[]:
+ context.Writer.WriteUInt8((byte)TypeId.Int64Array);
+ return true;
+ case ushort[]:
+ context.Writer.WriteUInt8((byte)TypeId.UInt16Array);
+ return true;
+ case uint[]:
+ context.Writer.WriteUInt8((byte)TypeId.UInt32Array);
+ return true;
+ case ulong[]:
+ context.Writer.WriteUInt8((byte)TypeId.UInt64Array);
+ return true;
+ case float[]:
+ context.Writer.WriteUInt8((byte)TypeId.Float32Array);
+ return true;
+ case double[]:
+ context.Writer.WriteUInt8((byte)TypeId.Float64Array);
+ return true;
+ case DateOnly:
+ context.Writer.WriteUInt8((byte)TypeId.Date);
+ return true;
+ case DateTimeOffset:
+ case DateTime:
+ context.Writer.WriteUInt8((byte)TypeId.Timestamp);
+ return true;
+ case TimeSpan:
+ context.Writer.WriteUInt8((byte)TypeId.Duration);
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ private static bool TryWriteKnownPayload(object value, ref WriteContext context)
+ {
+ switch (value)
+ {
+ case bool v:
+ context.Writer.WriteUInt8(v ? (byte)1 : (byte)0);
+ return true;
+ case sbyte v:
+ context.Writer.WriteInt8(v);
+ return true;
+ case short v:
+ context.Writer.WriteInt16(v);
+ return true;
+ case int v:
+ context.Writer.WriteVarInt32(v);
+ return true;
+ case long v:
+ context.Writer.WriteVarInt64(v);
+ return true;
+ case byte v:
+ context.Writer.WriteUInt8(v);
+ return true;
+ case ushort v:
+ context.Writer.WriteUInt16(v);
+ return true;
+ case uint v:
+ context.Writer.WriteVarUInt32(v);
+ return true;
+ case ulong v:
+ context.Writer.WriteVarUInt64(v);
+ return true;
+ case float v:
+ context.Writer.WriteFloat32(v);
+ return true;
+ case double v:
+ context.Writer.WriteFloat64(v);
+ return true;
+ case string v:
+ StringSerializer.WriteString(ref context, v);
+ return true;
+ case DateOnly v:
+ TimeCodec.WriteDate(ref context, v);
+ return true;
+ case DateTimeOffset v:
+ TimeCodec.WriteTimestamp(ref context, v);
+ return true;
+ case DateTime v:
+ TimeCodec.WriteTimestamp(ref context, TimeCodec.ToDateTimeOffset(v));
+ return true;
+ case TimeSpan v:
+ TimeCodec.WriteDuration(ref context, v);
+ return true;
+ case byte[] v:
+ context.Writer.WriteVarUInt32((uint)v.Length);
+ context.Writer.WriteBytes(v);
+ return true;
+ case bool[] v:
+ context.Writer.WriteVarUInt32((uint)v.Length);
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteUInt8(v[i] ? (byte)1 : (byte)0);
+ }
+ return true;
+ case sbyte[] v:
+ context.Writer.WriteVarUInt32((uint)v.Length);
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteInt8(v[i]);
+ }
+ return true;
+ case short[] v:
+ context.Writer.WriteVarUInt32((uint)(v.Length * 2));
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteInt16(v[i]);
+ }
+ return true;
+ case int[] v:
+ context.Writer.WriteVarUInt32((uint)(v.Length * 4));
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteInt32(v[i]);
+ }
+ return true;
+ case long[] v:
+ context.Writer.WriteVarUInt32((uint)(v.Length * 8));
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteInt64(v[i]);
+ }
+ return true;
+ case ushort[] v:
+ context.Writer.WriteVarUInt32((uint)(v.Length * 2));
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteUInt16(v[i]);
+ }
+ return true;
+ case uint[] v:
+ context.Writer.WriteVarUInt32((uint)(v.Length * 4));
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteUInt32(v[i]);
+ }
+ return true;
+ case ulong[] v:
+ context.Writer.WriteVarUInt32((uint)(v.Length * 8));
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteUInt64(v[i]);
+ }
+ return true;
+ case float[] v:
+ context.Writer.WriteVarUInt32((uint)(v.Length * 4));
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteFloat32(v[i]);
+ }
+ return true;
+ case double[] v:
+ context.Writer.WriteVarUInt32((uint)(v.Length * 8));
+ for (int i = 0; i < v.Length; i++)
+ {
+ context.Writer.WriteFloat64(v[i]);
+ }
+ return true;
+ default:
+ return false;
+ }
+ }
+}
diff --git a/csharp/src/Fory/Attributes.cs b/csharp/src/Fory/Attributes.cs
new file mode 100644
index 0000000000..84fe5dc380
--- /dev/null
+++ b/csharp/src/Fory/Attributes.cs
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum)]
+public sealed class ForyObjectAttribute : Attribute
+{
+}
+
+public enum FieldEncoding
+{
+ Varint,
+ Fixed,
+ Tagged,
+}
+
+[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class FieldAttribute : Attribute
+{
+ public FieldEncoding Encoding { get; set; } = FieldEncoding.Varint;
+}
diff --git a/csharp/src/Fory/ByteBuffer.cs b/csharp/src/Fory/ByteBuffer.cs
new file mode 100644
index 0000000000..4d7e83e14a
--- /dev/null
+++ b/csharp/src/Fory/ByteBuffer.cs
@@ -0,0 +1,418 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+using System.Buffers.Binary;
+
+namespace Apache.Fory;
+
+public sealed class ByteWriter
+{
+ private readonly List _storage;
+
+ public ByteWriter(int capacity = 256)
+ {
+ _storage = new List(capacity);
+ }
+
+ public int Count => _storage.Count;
+
+ public IReadOnlyList Storage => _storage;
+
+ public void Reserve(int additional)
+ {
+ _storage.Capacity = Math.Max(_storage.Capacity, _storage.Count + additional);
+ }
+
+ public void WriteUInt8(byte value)
+ {
+ _storage.Add(value);
+ }
+
+ public void WriteInt8(sbyte value)
+ {
+ _storage.Add(unchecked((byte)value));
+ }
+
+ public void WriteUInt16(ushort value)
+ {
+ Span tmp = stackalloc byte[2];
+ BinaryPrimitives.WriteUInt16LittleEndian(tmp, value);
+ WriteBytes(tmp);
+ }
+
+ public void WriteInt16(short value)
+ {
+ WriteUInt16(unchecked((ushort)value));
+ }
+
+ public void WriteUInt32(uint value)
+ {
+ Span tmp = stackalloc byte[4];
+ BinaryPrimitives.WriteUInt32LittleEndian(tmp, value);
+ WriteBytes(tmp);
+ }
+
+ public void WriteInt32(int value)
+ {
+ WriteUInt32(unchecked((uint)value));
+ }
+
+ public void WriteUInt64(ulong value)
+ {
+ Span tmp = stackalloc byte[8];
+ BinaryPrimitives.WriteUInt64LittleEndian(tmp, value);
+ WriteBytes(tmp);
+ }
+
+ public void WriteInt64(long value)
+ {
+ WriteUInt64(unchecked((ulong)value));
+ }
+
+ public void WriteVarUInt32(uint value)
+ {
+ uint remaining = value;
+ while (remaining >= 0x80)
+ {
+ WriteUInt8((byte)((remaining & 0x7F) | 0x80));
+ remaining >>= 7;
+ }
+
+ WriteUInt8((byte)remaining);
+ }
+
+ public void WriteVarUInt64(ulong value)
+ {
+ ulong remaining = value;
+ for (var i = 0; i < 8; i++)
+ {
+ if (remaining < 0x80)
+ {
+ WriteUInt8((byte)remaining);
+ return;
+ }
+
+ WriteUInt8((byte)((remaining & 0x7F) | 0x80));
+ remaining >>= 7;
+ }
+
+ WriteUInt8((byte)(remaining & 0xFF));
+ }
+
+ public void WriteVarUInt36Small(ulong value)
+ {
+ if (value >= (1UL << 36))
+ {
+ throw new EncodingException("varuint36small overflow");
+ }
+
+ WriteVarUInt64(value);
+ }
+
+ public void WriteVarInt32(int value)
+ {
+ uint zigzag = unchecked((uint)((value << 1) ^ (value >> 31)));
+ WriteVarUInt32(zigzag);
+ }
+
+ public void WriteVarInt64(long value)
+ {
+ ulong zigzag = unchecked((ulong)((value << 1) ^ (value >> 63)));
+ WriteVarUInt64(zigzag);
+ }
+
+ public void WriteTaggedInt64(long value)
+ {
+ if (value >= -1_073_741_824L && value <= 1_073_741_823L)
+ {
+ WriteInt32(unchecked((int)value << 1));
+ return;
+ }
+
+ WriteUInt8(0x01);
+ WriteInt64(value);
+ }
+
+ public void WriteTaggedUInt64(ulong value)
+ {
+ if (value <= int.MaxValue)
+ {
+ WriteUInt32(unchecked((uint)value << 1));
+ return;
+ }
+
+ WriteUInt8(0x01);
+ WriteUInt64(value);
+ }
+
+ public void WriteFloat32(float value)
+ {
+ WriteUInt32(unchecked((uint)BitConverter.SingleToInt32Bits(value)));
+ }
+
+ public void WriteFloat64(double value)
+ {
+ WriteUInt64(unchecked((ulong)BitConverter.DoubleToInt64Bits(value)));
+ }
+
+ public void WriteBytes(ReadOnlySpan bytes)
+ {
+ for (int i = 0; i < bytes.Length; i++)
+ {
+ _storage.Add(bytes[i]);
+ }
+ }
+
+ public void SetByte(int index, byte value)
+ {
+ _storage[index] = value;
+ }
+
+ public void SetBytes(int index, ReadOnlySpan bytes)
+ {
+ for (var i = 0; i < bytes.Length; i++)
+ {
+ _storage[index + i] = bytes[i];
+ }
+ }
+
+ public byte[] ToArray()
+ {
+ return _storage.ToArray();
+ }
+
+ public void Reset()
+ {
+ _storage.Clear();
+ }
+}
+
+public sealed class ByteReader
+{
+ private readonly byte[] _storage;
+ private int _cursor;
+
+ public ByteReader(ReadOnlySpan data)
+ {
+ _storage = data.ToArray();
+ _cursor = 0;
+ }
+
+ public ByteReader(byte[] bytes)
+ {
+ _storage = bytes;
+ _cursor = 0;
+ }
+
+ public byte[] Storage => _storage;
+
+ public int Cursor => _cursor;
+
+ public int Remaining => _storage.Length - _cursor;
+
+ public void SetCursor(int value)
+ {
+ _cursor = value;
+ }
+
+ public void MoveBack(int amount)
+ {
+ _cursor -= amount;
+ }
+
+ public void CheckBound(int need)
+ {
+ if (_cursor + need > _storage.Length)
+ {
+ throw new OutOfBoundsException(_cursor, need, _storage.Length);
+ }
+ }
+
+ public byte ReadUInt8()
+ {
+ CheckBound(1);
+ byte value = _storage[_cursor];
+ _cursor += 1;
+ return value;
+ }
+
+ public sbyte ReadInt8()
+ {
+ return unchecked((sbyte)ReadUInt8());
+ }
+
+ public ushort ReadUInt16()
+ {
+ CheckBound(2);
+ ushort value = BinaryPrimitives.ReadUInt16LittleEndian(_storage.AsSpan(_cursor, 2));
+ _cursor += 2;
+ return value;
+ }
+
+ public short ReadInt16()
+ {
+ return unchecked((short)ReadUInt16());
+ }
+
+ public uint ReadUInt32()
+ {
+ CheckBound(4);
+ uint value = BinaryPrimitives.ReadUInt32LittleEndian(_storage.AsSpan(_cursor, 4));
+ _cursor += 4;
+ return value;
+ }
+
+ public int ReadInt32()
+ {
+ return unchecked((int)ReadUInt32());
+ }
+
+ public ulong ReadUInt64()
+ {
+ CheckBound(8);
+ ulong value = BinaryPrimitives.ReadUInt64LittleEndian(_storage.AsSpan(_cursor, 8));
+ _cursor += 8;
+ return value;
+ }
+
+ public long ReadInt64()
+ {
+ return unchecked((long)ReadUInt64());
+ }
+
+ public uint ReadVarUInt32()
+ {
+ uint result = 0;
+ var shift = 0;
+ while (true)
+ {
+ byte b = ReadUInt8();
+ result |= (uint)(b & 0x7F) << shift;
+ if ((b & 0x80) == 0)
+ {
+ return result;
+ }
+
+ shift += 7;
+ if (shift > 28)
+ {
+ throw new EncodingException("varuint32 overflow");
+ }
+ }
+ }
+
+ public ulong ReadVarUInt64()
+ {
+ ulong result = 0;
+ var shift = 0;
+ for (var i = 0; i < 8; i++)
+ {
+ byte b = ReadUInt8();
+ result |= (ulong)(b & 0x7F) << shift;
+ if ((b & 0x80) == 0)
+ {
+ return result;
+ }
+
+ shift += 7;
+ }
+
+ byte last = ReadUInt8();
+ result |= (ulong)last << 56;
+ return result;
+ }
+
+ public ulong ReadVarUInt36Small()
+ {
+ ulong value = ReadVarUInt64();
+ if (value >= (1UL << 36))
+ {
+ throw new EncodingException("varuint36small overflow");
+ }
+
+ return value;
+ }
+
+ public int ReadVarInt32()
+ {
+ uint encoded = ReadVarUInt32();
+ return unchecked((int)((encoded >> 1) ^ (~(encoded & 1) + 1)));
+ }
+
+ public long ReadVarInt64()
+ {
+ ulong encoded = ReadVarUInt64();
+ return unchecked((long)((encoded >> 1) ^ (~(encoded & 1UL) + 1UL)));
+ }
+
+ public long ReadTaggedInt64()
+ {
+ int first = ReadInt32();
+ if ((first & 1) == 0)
+ {
+ return first >> 1;
+ }
+
+ MoveBack(3);
+ return ReadInt64();
+ }
+
+ public ulong ReadTaggedUInt64()
+ {
+ uint first = ReadUInt32();
+ if ((first & 1) == 0)
+ {
+ return first >> 1;
+ }
+
+ MoveBack(3);
+ return ReadUInt64();
+ }
+
+ public float ReadFloat32()
+ {
+ return BitConverter.Int32BitsToSingle(unchecked((int)ReadUInt32()));
+ }
+
+ public double ReadFloat64()
+ {
+ return BitConverter.Int64BitsToDouble(unchecked((long)ReadUInt64()));
+ }
+
+ public byte[] ReadBytes(int count)
+ {
+ CheckBound(count);
+ byte[] result = new byte[count];
+ Array.Copy(_storage, _cursor, result, 0, count);
+ _cursor += count;
+ return result;
+ }
+
+ public ReadOnlySpan ReadSpan(int count)
+ {
+ CheckBound(count);
+ ReadOnlySpan span = _storage.AsSpan(_cursor, count);
+ _cursor += count;
+ return span;
+ }
+
+ public void Skip(int count)
+ {
+ CheckBound(count);
+ _cursor += count;
+ }
+}
diff --git a/csharp/src/Fory/CollectionSerializers.cs b/csharp/src/Fory/CollectionSerializers.cs
new file mode 100644
index 0000000000..c1b026e33a
--- /dev/null
+++ b/csharp/src/Fory/CollectionSerializers.cs
@@ -0,0 +1,457 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+using System.Collections;
+
+namespace Apache.Fory;
+
+internal static class CollectionBits
+{
+ public const byte TrackingRef = 0b0000_0001;
+ public const byte HasNull = 0b0000_0010;
+ public const byte DeclaredElementType = 0b0000_0100;
+ public const byte SameType = 0b0000_1000;
+}
+
+
+internal static class CollectionCodec
+{
+ public static void WriteCollectionData(
+ IEnumerable values,
+ Serializer elementSerializer,
+ ref WriteContext context,
+ bool hasGenerics)
+ {
+ List list = values as List ?? [.. values];
+ context.Writer.WriteVarUInt32((uint)list.Count);
+ if (list.Count == 0)
+ {
+ return;
+ }
+
+ bool hasNull = false;
+ if (elementSerializer.IsNullableType)
+ {
+ for (int i = 0; i < list.Count; i++)
+ {
+ if (!elementSerializer.IsNoneObject(list[i]))
+ {
+ continue;
+ }
+
+ hasNull = true;
+ break;
+ }
+ }
+
+ bool trackRef = context.TrackRef && elementSerializer.IsReferenceTrackableType;
+ bool declaredElementType = hasGenerics && !elementSerializer.StaticTypeId.NeedsTypeInfoForField();
+ bool dynamicElementType = elementSerializer.StaticTypeId == TypeId.Unknown;
+
+ byte header = dynamicElementType ? (byte)0 : CollectionBits.SameType;
+ if (trackRef)
+ {
+ header |= CollectionBits.TrackingRef;
+ }
+
+ if (hasNull)
+ {
+ header |= CollectionBits.HasNull;
+ }
+
+ if (declaredElementType)
+ {
+ header |= CollectionBits.DeclaredElementType;
+ }
+
+ context.Writer.WriteUInt8(header);
+ if (!dynamicElementType && !declaredElementType)
+ {
+ elementSerializer.WriteTypeInfo(ref context);
+ }
+
+ if (dynamicElementType)
+ {
+ RefMode refMode = trackRef ? RefMode.Tracking : hasNull ? RefMode.NullOnly : RefMode.None;
+ foreach (T element in list)
+ {
+ elementSerializer.Write(ref context, element, refMode, true, hasGenerics);
+ }
+
+ return;
+ }
+
+ if (trackRef)
+ {
+ foreach (T element in list)
+ {
+ elementSerializer.Write(ref context, element, RefMode.Tracking, false, hasGenerics);
+ }
+
+ return;
+ }
+
+ if (hasNull)
+ {
+ foreach (T element in list)
+ {
+ if (elementSerializer.IsNoneObject(element))
+ {
+ context.Writer.WriteInt8((sbyte)RefFlag.Null);
+ }
+ else
+ {
+ context.Writer.WriteInt8((sbyte)RefFlag.NotNullValue);
+ elementSerializer.WriteData(ref context, element, hasGenerics);
+ }
+ }
+
+ return;
+ }
+
+ foreach (T element in list)
+ {
+ elementSerializer.WriteData(ref context, element, hasGenerics);
+ }
+ }
+
+ public static List ReadCollectionData(Serializer elementSerializer, ref ReadContext context)
+ {
+ int length = checked((int)context.Reader.ReadVarUInt32());
+ if (length == 0)
+ {
+ return [];
+ }
+
+ byte header = context.Reader.ReadUInt8();
+ bool trackRef = (header & CollectionBits.TrackingRef) != 0;
+ bool hasNull = (header & CollectionBits.HasNull) != 0;
+ bool declared = (header & CollectionBits.DeclaredElementType) != 0;
+ bool sameType = (header & CollectionBits.SameType) != 0;
+ bool canonicalizeElements = context.TrackRef && !trackRef && elementSerializer.IsReferenceTrackableType;
+
+ List values = new(length);
+ if (!sameType)
+ {
+ if (trackRef)
+ {
+ for (int i = 0; i < length; i++)
+ {
+ values.Add(elementSerializer.Read(ref context, RefMode.Tracking, true));
+ }
+
+ return values;
+ }
+
+ if (hasNull)
+ {
+ for (int i = 0; i < length; i++)
+ {
+ sbyte refFlag = context.Reader.ReadInt8();
+ if (refFlag == (sbyte)RefFlag.Null)
+ {
+ values.Add((T)elementSerializer.DefaultObject!);
+ }
+ else if (refFlag == (sbyte)RefFlag.NotNullValue)
+ {
+ values.Add(ReadCollectionElementWithCanonicalization(elementSerializer, ref context, true, canonicalizeElements));
+ }
+ else
+ {
+ throw new RefException($"invalid nullability flag {refFlag}");
+ }
+ }
+ }
+ else
+ {
+ for (int i = 0; i < length; i++)
+ {
+ values.Add(ReadCollectionElementWithCanonicalization(elementSerializer, ref context, true, canonicalizeElements));
+ }
+ }
+
+ return values;
+ }
+
+ if (!declared)
+ {
+ elementSerializer.ReadTypeInfo(ref context);
+ }
+
+ if (trackRef)
+ {
+ for (int i = 0; i < length; i++)
+ {
+ values.Add(elementSerializer.Read(ref context, RefMode.Tracking, false));
+ }
+
+ if (!declared)
+ {
+ context.ClearDynamicTypeInfo(typeof(T));
+ }
+
+ return values;
+ }
+
+ if (hasNull)
+ {
+ for (int i = 0; i < length; i++)
+ {
+ sbyte refFlag = context.Reader.ReadInt8();
+ if (refFlag == (sbyte)RefFlag.Null)
+ {
+ values.Add((T)elementSerializer.DefaultObject!);
+ }
+ else
+ {
+ values.Add(ReadCollectionElementDataWithCanonicalization(elementSerializer, ref context, canonicalizeElements));
+ }
+ }
+ }
+ else
+ {
+ for (int i = 0; i < length; i++)
+ {
+ values.Add(ReadCollectionElementDataWithCanonicalization(elementSerializer, ref context, canonicalizeElements));
+ }
+ }
+
+ if (!declared)
+ {
+ context.ClearDynamicTypeInfo(typeof(T));
+ }
+
+ return values;
+ }
+
+ private static T ReadCollectionElementWithCanonicalization(
+ Serializer elementSerializer,
+ ref ReadContext context,
+ bool readTypeInfo,
+ bool canonicalize)
+ {
+ if (!canonicalize)
+ {
+ return elementSerializer.Read(ref context, RefMode.None, readTypeInfo);
+ }
+
+ int start = context.Reader.Cursor;
+ T value = elementSerializer.Read(ref context, RefMode.None, readTypeInfo);
+ int end = context.Reader.Cursor;
+ return context.CanonicalizeNonTrackingReference(value, start, end);
+ }
+
+ private static T ReadCollectionElementDataWithCanonicalization(
+ Serializer elementSerializer,
+ ref ReadContext context,
+ bool canonicalize)
+ {
+ if (!canonicalize)
+ {
+ return elementSerializer.ReadData(ref context);
+ }
+
+ int start = context.Reader.Cursor;
+ T value = elementSerializer.ReadData(ref context);
+ int end = context.Reader.Cursor;
+ return context.CanonicalizeNonTrackingReference(value, start, end);
+ }
+}
+
+internal static class DynamicContainerCodec
+{
+ public static bool TryGetTypeId(object value, out TypeId typeId)
+ {
+ if (value is IDictionary)
+ {
+ typeId = TypeId.Map;
+ return true;
+ }
+
+ Type valueType = value.GetType();
+ if (value is IList && !valueType.IsArray)
+ {
+ typeId = TypeId.List;
+ return true;
+ }
+
+ if (IsSet(valueType))
+ {
+ typeId = TypeId.Set;
+ return true;
+ }
+
+ typeId = default;
+ return false;
+ }
+
+ public static bool TryWritePayload(object value, ref WriteContext context, bool hasGenerics)
+ {
+ if (value is IDictionary dictionary)
+ {
+ NullableKeyDictionary map = new();
+ foreach (DictionaryEntry entry in dictionary)
+ {
+ map.Add(entry.Key, entry.Value);
+ }
+
+ context.TypeResolver.GetSerializer>().WriteData(ref context, map, false);
+ return true;
+ }
+
+ Type valueType = value.GetType();
+ if (value is IList list && !valueType.IsArray)
+ {
+ List values = new(list.Count);
+ for (int i = 0; i < list.Count; i++)
+ {
+ values.Add(list[i]);
+ }
+
+ context.TypeResolver.GetSerializer>().WriteData(ref context, values, hasGenerics);
+ return true;
+ }
+
+ if (!IsSet(valueType))
+ {
+ return false;
+ }
+
+ HashSet set = [];
+ foreach (object? item in (IEnumerable)value)
+ {
+ set.Add(item);
+ }
+
+ context.TypeResolver.GetSerializer>().WriteData(ref context, set, hasGenerics);
+ return true;
+ }
+
+ public static List ReadListPayload(ref ReadContext context)
+ {
+ return context.TypeResolver.GetSerializer>().ReadData(ref context);
+ }
+
+ public static HashSet ReadSetPayload(ref ReadContext context)
+ {
+ return context.TypeResolver.GetSerializer>().ReadData(ref context);
+ }
+
+ public static object ReadMapPayload(ref ReadContext context)
+ {
+ NullableKeyDictionary map = context.TypeResolver.GetSerializer>().ReadData(ref context);
+ if (map.HasNullKey)
+ {
+ return map;
+ }
+
+ return new Dictionary(map.NonNullEntries);
+ }
+
+ private static bool IsSet(Type valueType)
+ {
+ if (!valueType.IsGenericType)
+ {
+ return false;
+ }
+
+ if (valueType.GetGenericTypeDefinition() == typeof(ISet<>))
+ {
+ return true;
+ }
+
+ foreach (Type iface in valueType.GetInterfaces())
+ {
+ if (!iface.IsGenericType)
+ {
+ continue;
+ }
+
+ if (iface.GetGenericTypeDefinition() == typeof(ISet<>))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
+
+public sealed class ArraySerializer : Serializer
+{
+ public override TypeId StaticTypeId => TypeId.List;
+ public override bool IsNullableType => true;
+ public override bool IsReferenceTrackableType => true;
+ public override T[] DefaultValue => null!;
+ public override bool IsNone(in T[] value) => value is null;
+
+ public override void WriteData(ref WriteContext context, in T[] value, bool hasGenerics)
+ {
+ T[] safe = value ?? [];
+ CollectionCodec.WriteCollectionData(
+ safe,
+ context.TypeResolver.GetSerializer(),
+ ref context,
+ hasGenerics);
+ }
+
+ public override T[] ReadData(ref ReadContext context)
+ {
+ List values = CollectionCodec.ReadCollectionData(context.TypeResolver.GetSerializer(), ref context);
+ return values.ToArray();
+ }
+}
+
+public class ListSerializer : Serializer>
+{
+ public override TypeId StaticTypeId => TypeId.List;
+ public override bool IsNullableType => true;
+ public override bool IsReferenceTrackableType => true;
+ public override List DefaultValue => null!;
+ public override bool IsNone(in List value) => value is null;
+
+ public override void WriteData(ref WriteContext context, in List value, bool hasGenerics)
+ {
+ List safe = value ?? [];
+ CollectionCodec.WriteCollectionData(safe, context.TypeResolver.GetSerializer(), ref context, hasGenerics);
+ }
+
+ public override List ReadData(ref ReadContext context)
+ {
+ return CollectionCodec.ReadCollectionData(context.TypeResolver.GetSerializer(), ref context);
+ }
+}
+
+public sealed class SetSerializer : Serializer> where T : notnull
+{
+ public override TypeId StaticTypeId => TypeId.Set;
+ public override bool IsNullableType => true;
+ public override bool IsReferenceTrackableType => true;
+ public override HashSet DefaultValue => null!;
+ public override bool IsNone(in HashSet value) => value is null;
+
+ public override void WriteData(ref WriteContext context, in HashSet value, bool hasGenerics)
+ {
+ List list = value is null ? [] : [.. value];
+ context.TypeResolver.GetSerializer>().WriteData(ref context, list, hasGenerics);
+ }
+
+ public override HashSet ReadData(ref ReadContext context)
+ {
+ return [.. context.TypeResolver.GetSerializer>().ReadData(ref context)];
+ }
+}
diff --git a/csharp/src/Fory/Config.cs b/csharp/src/Fory/Config.cs
new file mode 100644
index 0000000000..5fd8f2609c
--- /dev/null
+++ b/csharp/src/Fory/Config.cs
@@ -0,0 +1,90 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+public sealed record Config(
+ bool Xlang = true,
+ bool TrackRef = false,
+ bool Compatible = false,
+ bool CheckStructVersion = false,
+ bool EnableReflectionFallback = false,
+ int MaxDepth = 512);
+
+public sealed class ForyBuilder
+{
+ private bool _xlang = true;
+ private bool _trackRef;
+ private bool _compatible;
+ private bool _checkStructVersion;
+ private bool _enableReflectionFallback;
+ private int _maxDepth = 512;
+
+ public ForyBuilder Xlang(bool enabled = true)
+ {
+ _xlang = enabled;
+ return this;
+ }
+
+ public ForyBuilder TrackRef(bool enabled = false)
+ {
+ _trackRef = enabled;
+ return this;
+ }
+
+ public ForyBuilder Compatible(bool enabled = false)
+ {
+ _compatible = enabled;
+ return this;
+ }
+
+ public ForyBuilder CheckStructVersion(bool enabled = false)
+ {
+ _checkStructVersion = enabled;
+ return this;
+ }
+
+ public ForyBuilder EnableReflectionFallback(bool enabled = false)
+ {
+ _enableReflectionFallback = enabled;
+ return this;
+ }
+
+ public ForyBuilder MaxDepth(int value)
+ {
+ if (value <= 0)
+ {
+ throw new ArgumentOutOfRangeException(nameof(value), "MaxDepth must be greater than 0.");
+ }
+
+ _maxDepth = value;
+ return this;
+ }
+
+ public Fory Build()
+ {
+ return new Fory(
+ new Config(
+ Xlang: _xlang,
+ TrackRef: _trackRef,
+ Compatible: _compatible,
+ CheckStructVersion: _checkStructVersion,
+ EnableReflectionFallback: _enableReflectionFallback,
+ MaxDepth: _maxDepth));
+ }
+}
+
diff --git a/csharp/src/Fory/Context.cs b/csharp/src/Fory/Context.cs
new file mode 100644
index 0000000000..9dafa1c1d2
--- /dev/null
+++ b/csharp/src/Fory/Context.cs
@@ -0,0 +1,397 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+public sealed class CompatibleTypeDefWriteState
+{
+ private readonly Dictionary _typeIndexByType = [];
+ private uint _nextIndex;
+
+ public uint? LookupIndex(Type type)
+ {
+ return _typeIndexByType.TryGetValue(type, out uint idx) ? idx : null;
+ }
+
+ public (uint Index, bool IsNew) AssignIndexIfAbsent(Type type)
+ {
+ if (_typeIndexByType.TryGetValue(type, out uint existing))
+ {
+ return (existing, false);
+ }
+
+ uint index = _nextIndex;
+ _nextIndex += 1;
+ _typeIndexByType[type] = index;
+ return (index, true);
+ }
+
+ public void Reset()
+ {
+ _typeIndexByType.Clear();
+ _nextIndex = 0;
+ }
+}
+
+public sealed class CompatibleTypeDefReadState
+{
+ private readonly List _typeMetas = [];
+
+ public TypeMeta? TypeMetaAt(int index)
+ {
+ return index >= 0 && index < _typeMetas.Count ? _typeMetas[index] : null;
+ }
+
+ public void StoreTypeMeta(TypeMeta typeMeta, int index)
+ {
+ if (index < 0)
+ {
+ throw new InvalidDataException("negative compatible type definition index");
+ }
+
+ if (index == _typeMetas.Count)
+ {
+ _typeMetas.Add(typeMeta);
+ return;
+ }
+
+ if (index < _typeMetas.Count)
+ {
+ _typeMetas[index] = typeMeta;
+ return;
+ }
+
+ throw new InvalidDataException(
+ $"compatible type definition index gap: index={index}, count={_typeMetas.Count}");
+ }
+
+ public void Reset()
+ {
+ _typeMetas.Clear();
+ }
+}
+
+public sealed class MetaStringWriteState
+{
+ private readonly Dictionary _stringIndexByKey = [];
+ private uint _nextIndex;
+
+ public uint? Index(MetaString value)
+ {
+ return _stringIndexByKey.TryGetValue(value, out uint index) ? index : null;
+ }
+
+ public (uint Index, bool IsNew) AssignIndexIfAbsent(MetaString value)
+ {
+ if (_stringIndexByKey.TryGetValue(value, out uint existing))
+ {
+ return (existing, false);
+ }
+
+ uint index = _nextIndex;
+ _nextIndex += 1;
+ _stringIndexByKey[value] = index;
+ return (index, true);
+ }
+
+ public void Reset()
+ {
+ _stringIndexByKey.Clear();
+ _nextIndex = 0;
+ }
+}
+
+public sealed class MetaStringReadState
+{
+ private readonly List _values = [];
+
+ public MetaString? ValueAt(int index)
+ {
+ return index >= 0 && index < _values.Count ? _values[index] : null;
+ }
+
+ public void Append(MetaString value)
+ {
+ _values.Add(value);
+ }
+
+ public void Reset()
+ {
+ _values.Clear();
+ }
+}
+
+public sealed record DynamicTypeInfo(
+ TypeId WireTypeId,
+ uint? UserTypeId,
+ MetaString? NamespaceName,
+ MetaString? TypeName,
+ TypeMeta? CompatibleTypeMeta);
+
+public readonly struct WriteContext
+{
+ public WriteContext(
+ ByteWriter writer,
+ TypeResolver typeResolver,
+ bool trackRef,
+ bool compatible = false,
+ CompatibleTypeDefWriteState? compatibleTypeDefState = null,
+ MetaStringWriteState? metaStringWriteState = null)
+ {
+ Writer = writer;
+ TypeResolver = typeResolver;
+ TrackRef = trackRef;
+ Compatible = compatible;
+ RefWriter = new RefWriter();
+ CompatibleTypeDefState = compatibleTypeDefState ?? new CompatibleTypeDefWriteState();
+ MetaStringWriteState = metaStringWriteState ?? new MetaStringWriteState();
+ }
+
+ public ByteWriter Writer { get; }
+
+ public TypeResolver TypeResolver { get; }
+
+ public bool TrackRef { get; }
+
+ public bool Compatible { get; }
+
+ public RefWriter RefWriter { get; }
+
+ public CompatibleTypeDefWriteState CompatibleTypeDefState { get; }
+
+ public MetaStringWriteState MetaStringWriteState { get; }
+
+ public void WriteCompatibleTypeMeta(Type type, TypeMeta typeMeta)
+ {
+ (uint index, bool isNew) = CompatibleTypeDefState.AssignIndexIfAbsent(type);
+ if (isNew)
+ {
+ Writer.WriteVarUInt32(index << 1);
+ Writer.WriteBytes(typeMeta.Encode());
+ }
+ else
+ {
+ Writer.WriteVarUInt32((index << 1) | 1);
+ }
+ }
+
+ public void ResetObjectState()
+ {
+ RefWriter.Reset();
+ }
+
+ public void Reset()
+ {
+ ResetObjectState();
+ CompatibleTypeDefState.Reset();
+ MetaStringWriteState.Reset();
+ }
+}
+
+internal readonly record struct PendingRefSlot(uint RefId, bool Bound);
+
+internal readonly record struct CanonicalReferenceSignature(
+ Type Type,
+ ulong HashLo,
+ ulong HashHi,
+ int Length);
+
+internal sealed class CanonicalReferenceEntry
+{
+ public required byte[] Bytes { get; init; }
+ public required object Object { get; init; }
+}
+
+public sealed class ReadContext
+{
+ private readonly List _pendingRefStack = [];
+ private readonly Dictionary> _pendingCompatibleTypeMeta = [];
+ private readonly Dictionary _pendingDynamicTypeInfo = [];
+ private readonly Dictionary> _canonicalReferenceCache = [];
+
+ public ReadContext(
+ ByteReader reader,
+ TypeResolver typeResolver,
+ bool trackRef,
+ bool compatible = false,
+ CompatibleTypeDefReadState? compatibleTypeDefState = null,
+ MetaStringReadState? metaStringReadState = null)
+ {
+ Reader = reader;
+ TypeResolver = typeResolver;
+ TrackRef = trackRef;
+ Compatible = compatible;
+ RefReader = new RefReader();
+ CompatibleTypeDefState = compatibleTypeDefState ?? new CompatibleTypeDefReadState();
+ MetaStringReadState = metaStringReadState ?? new MetaStringReadState();
+ }
+
+ public ByteReader Reader { get; }
+
+ public TypeResolver TypeResolver { get; }
+
+ public bool TrackRef { get; }
+
+ public bool Compatible { get; }
+
+ public RefReader RefReader { get; }
+
+ public CompatibleTypeDefReadState CompatibleTypeDefState { get; }
+
+ public MetaStringReadState MetaStringReadState { get; }
+
+ public void PushPendingReference(uint refId)
+ {
+ _pendingRefStack.Add(new PendingRefSlot(refId, false));
+ }
+
+ public void BindPendingReference(object? value)
+ {
+ if (_pendingRefStack.Count == 0)
+ {
+ return;
+ }
+
+ PendingRefSlot last = _pendingRefStack[^1];
+ _pendingRefStack.RemoveAt(_pendingRefStack.Count - 1);
+ _pendingRefStack.Add(last with { Bound = true });
+ RefReader.StoreRef(value, last.RefId);
+ }
+
+ public void FinishPendingReferenceIfNeeded(object? value)
+ {
+ if (_pendingRefStack.Count == 0)
+ {
+ return;
+ }
+
+ PendingRefSlot last = _pendingRefStack[^1];
+ if (!last.Bound)
+ {
+ RefReader.StoreRef(value, last.RefId);
+ }
+ }
+
+ public void PopPendingReference()
+ {
+ if (_pendingRefStack.Count > 0)
+ {
+ _pendingRefStack.RemoveAt(_pendingRefStack.Count - 1);
+ }
+ }
+
+ public TypeMeta ReadCompatibleTypeMeta()
+ {
+ uint indexMarker = Reader.ReadVarUInt32();
+ bool isRef = (indexMarker & 1) == 1;
+ int index = checked((int)(indexMarker >> 1));
+ if (isRef)
+ {
+ TypeMeta? cached = CompatibleTypeDefState.TypeMetaAt(index);
+ if (cached is null)
+ {
+ throw new InvalidDataException($"unknown compatible type definition ref index {index}");
+ }
+
+ return cached;
+ }
+
+ TypeMeta typeMeta = TypeMeta.Decode(Reader);
+ CompatibleTypeDefState.StoreTypeMeta(typeMeta, index);
+ return typeMeta;
+ }
+
+ public void PushCompatibleTypeMeta(Type type, TypeMeta typeMeta)
+ {
+ _pendingCompatibleTypeMeta[type] = [typeMeta];
+ }
+
+ public TypeMeta ConsumeCompatibleTypeMeta(Type type)
+ {
+ if (!_pendingCompatibleTypeMeta.TryGetValue(type, out List? stack) || stack.Count == 0)
+ {
+ throw new InvalidDataException($"missing compatible type metadata for {type}");
+ }
+
+ return stack[^1];
+ }
+
+ public void SetDynamicTypeInfo(Type type, DynamicTypeInfo typeInfo)
+ {
+ _pendingDynamicTypeInfo[type] = typeInfo;
+ }
+
+ public DynamicTypeInfo? DynamicTypeInfo(Type type)
+ {
+ return _pendingDynamicTypeInfo.TryGetValue(type, out DynamicTypeInfo? typeInfo) ? typeInfo : null;
+ }
+
+ public void ClearDynamicTypeInfo(Type type)
+ {
+ _pendingDynamicTypeInfo.Remove(type);
+ }
+
+ public T CanonicalizeNonTrackingReference(T value, int start, int end)
+ {
+ if (!TrackRef || end <= start || value is null || value is not object obj)
+ {
+ return value;
+ }
+
+ byte[] bytes = new byte[end - start];
+ Array.Copy(Reader.Storage, start, bytes, 0, bytes.Length);
+ (ulong hashLo, ulong hashHi) = MurmurHash3.X64_128(bytes, 47);
+ CanonicalReferenceSignature signature = new(obj.GetType(), hashLo, hashHi, bytes.Length);
+
+ if (_canonicalReferenceCache.TryGetValue(signature, out List? bucket))
+ {
+ foreach (CanonicalReferenceEntry entry in bucket)
+ {
+ if (entry.Bytes.AsSpan().SequenceEqual(bytes))
+ {
+ return (T)entry.Object;
+ }
+ }
+
+ bucket.Add(new CanonicalReferenceEntry { Bytes = bytes, Object = obj });
+ return value;
+ }
+
+ _canonicalReferenceCache[signature] =
+ [
+ new CanonicalReferenceEntry { Bytes = bytes, Object = obj },
+ ];
+ return value;
+ }
+
+ public void ResetObjectState()
+ {
+ RefReader.Reset();
+ _pendingRefStack.Clear();
+ _pendingCompatibleTypeMeta.Clear();
+ _pendingDynamicTypeInfo.Clear();
+ _canonicalReferenceCache.Clear();
+ }
+
+ public void Reset()
+ {
+ ResetObjectState();
+ CompatibleTypeDefState.Reset();
+ MetaStringReadState.Reset();
+ }
+}
+
diff --git a/csharp/src/Fory/DictionarySerializers.cs b/csharp/src/Fory/DictionarySerializers.cs
new file mode 100644
index 0000000000..9b1e923a14
--- /dev/null
+++ b/csharp/src/Fory/DictionarySerializers.cs
@@ -0,0 +1,473 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+internal static class DictionaryBits
+{
+ public const byte TrackingKeyRef = 0b0000_0001;
+ public const byte KeyNull = 0b0000_0010;
+ public const byte DeclaredKeyType = 0b0000_0100;
+ public const byte TrackingValueRef = 0b0000_1000;
+ public const byte ValueNull = 0b0001_0000;
+ public const byte DeclaredValueType = 0b0010_0000;
+}
+
+public class DictionarySerializer : Serializer>
+ where TKey : notnull
+{
+ public override TypeId StaticTypeId => TypeId.Map;
+ public override bool IsNullableType => true;
+ public override bool IsReferenceTrackableType => true;
+ public override Dictionary DefaultValue => null!;
+ public override bool IsNone(in Dictionary value) => value is null;
+
+ public override void WriteData(ref WriteContext context, in Dictionary value, bool hasGenerics)
+ {
+ Serializer keySerializer = context.TypeResolver.GetSerializer();
+ Serializer valueSerializer = context.TypeResolver.GetSerializer();
+ Dictionary map = value ?? [];
+ context.Writer.WriteVarUInt32((uint)map.Count);
+ if (map.Count == 0)
+ {
+ return;
+ }
+
+ bool trackKeyRef = context.TrackRef && keySerializer.IsReferenceTrackableType;
+ bool trackValueRef = context.TrackRef && valueSerializer.IsReferenceTrackableType;
+ bool keyDeclared = hasGenerics && !keySerializer.StaticTypeId.NeedsTypeInfoForField();
+ bool valueDeclared = hasGenerics && !valueSerializer.StaticTypeId.NeedsTypeInfoForField();
+ bool keyDynamicType = keySerializer.StaticTypeId == TypeId.Unknown;
+ bool valueDynamicType = valueSerializer.StaticTypeId == TypeId.Unknown;
+
+ KeyValuePair[] pairs = [.. map];
+ if (keyDynamicType || valueDynamicType)
+ {
+ WriteDynamicMapPairs(
+ pairs,
+ ref context,
+ hasGenerics,
+ trackKeyRef,
+ trackValueRef,
+ keyDeclared,
+ valueDeclared,
+ keyDynamicType,
+ valueDynamicType,
+ keySerializer,
+ valueSerializer);
+ return;
+ }
+
+ int index = 0;
+ while (index < pairs.Length)
+ {
+ KeyValuePair pair = pairs[index];
+ bool keyIsNull = keySerializer.IsNoneObject(pair.Key);
+ bool valueIsNull = valueSerializer.IsNoneObject(pair.Value);
+ if (keyIsNull || valueIsNull)
+ {
+ byte header = 0;
+ if (trackKeyRef)
+ {
+ header |= DictionaryBits.TrackingKeyRef;
+ }
+
+ if (trackValueRef)
+ {
+ header |= DictionaryBits.TrackingValueRef;
+ }
+
+ if (keyIsNull)
+ {
+ header |= DictionaryBits.KeyNull;
+ }
+
+ if (valueIsNull)
+ {
+ header |= DictionaryBits.ValueNull;
+ }
+
+ if (!keyIsNull && keyDeclared)
+ {
+ header |= DictionaryBits.DeclaredKeyType;
+ }
+
+ if (!valueIsNull && valueDeclared)
+ {
+ header |= DictionaryBits.DeclaredValueType;
+ }
+
+ context.Writer.WriteUInt8(header);
+ if (!keyIsNull)
+ {
+ if (!keyDeclared)
+ {
+ keySerializer.WriteTypeInfo(ref context);
+ }
+
+ keySerializer.Write(ref context, pair.Key, trackKeyRef ? RefMode.Tracking : RefMode.None, false, hasGenerics);
+ }
+
+ if (!valueIsNull)
+ {
+ if (!valueDeclared)
+ {
+ valueSerializer.WriteTypeInfo(ref context);
+ }
+
+ valueSerializer.Write(ref context, pair.Value, trackValueRef ? RefMode.Tracking : RefMode.None, false, hasGenerics);
+ }
+
+ index += 1;
+ continue;
+ }
+
+ byte blockHeader = 0;
+ if (trackKeyRef)
+ {
+ blockHeader |= DictionaryBits.TrackingKeyRef;
+ }
+
+ if (trackValueRef)
+ {
+ blockHeader |= DictionaryBits.TrackingValueRef;
+ }
+
+ if (keyDeclared)
+ {
+ blockHeader |= DictionaryBits.DeclaredKeyType;
+ }
+
+ if (valueDeclared)
+ {
+ blockHeader |= DictionaryBits.DeclaredValueType;
+ }
+
+ context.Writer.WriteUInt8(blockHeader);
+ int chunkSizeOffset = context.Writer.Count;
+ context.Writer.WriteUInt8(0);
+ if (!keyDeclared)
+ {
+ keySerializer.WriteTypeInfo(ref context);
+ }
+
+ if (!valueDeclared)
+ {
+ valueSerializer.WriteTypeInfo(ref context);
+ }
+
+ byte chunkSize = 0;
+ while (index < pairs.Length && chunkSize < byte.MaxValue)
+ {
+ KeyValuePair current = pairs[index];
+ if (keySerializer.IsNoneObject(current.Key) || valueSerializer.IsNoneObject(current.Value))
+ {
+ break;
+ }
+
+ keySerializer.Write(ref context, current.Key, trackKeyRef ? RefMode.Tracking : RefMode.None, false, hasGenerics);
+ valueSerializer.Write(ref context, current.Value, trackValueRef ? RefMode.Tracking : RefMode.None, false, hasGenerics);
+ chunkSize += 1;
+ index += 1;
+ }
+
+ context.Writer.SetByte(chunkSizeOffset, chunkSize);
+ }
+ }
+
+ public override Dictionary ReadData(ref ReadContext context)
+ {
+ Serializer keySerializer = context.TypeResolver.GetSerializer();
+ Serializer valueSerializer = context.TypeResolver.GetSerializer();
+ int totalLength = checked((int)context.Reader.ReadVarUInt32());
+ if (totalLength == 0)
+ {
+ return [];
+ }
+
+ Dictionary map = new(totalLength);
+ bool keyDynamicType = keySerializer.StaticTypeId == TypeId.Unknown;
+ bool valueDynamicType = valueSerializer.StaticTypeId == TypeId.Unknown;
+ bool canonicalizeValues = context.TrackRef && valueSerializer.IsReferenceTrackableType;
+
+ int readCount = 0;
+ while (readCount < totalLength)
+ {
+ byte header = context.Reader.ReadUInt8();
+ bool trackKeyRef = (header & DictionaryBits.TrackingKeyRef) != 0;
+ bool keyNull = (header & DictionaryBits.KeyNull) != 0;
+ bool keyDeclared = (header & DictionaryBits.DeclaredKeyType) != 0;
+ bool trackValueRef = (header & DictionaryBits.TrackingValueRef) != 0;
+ bool valueNull = (header & DictionaryBits.ValueNull) != 0;
+ bool valueDeclared = (header & DictionaryBits.DeclaredValueType) != 0;
+
+ if (keyNull && valueNull)
+ {
+ // Dictionary cannot represent a null key.
+ // Drop this entry instead of mapping it to default(TKey), which would corrupt key semantics.
+ readCount += 1;
+ continue;
+ }
+
+ if (keyNull)
+ {
+ TValue value = ReadValueElement(
+ ref context,
+ trackValueRef,
+ !valueDeclared,
+ canonicalizeValues,
+ valueSerializer);
+
+ // Preserve stream/reference state by reading value payload, then skip null-key entry.
+ // This avoids injecting a fake default(TKey) key into Dictionary.
+ readCount += 1;
+ continue;
+ }
+
+ if (valueNull)
+ {
+ TKey key = keySerializer.Read(
+ ref context,
+ trackKeyRef ? RefMode.Tracking : RefMode.None,
+ !keyDeclared);
+
+ map[key] = (TValue)valueSerializer.DefaultObject!;
+ readCount += 1;
+ continue;
+ }
+
+ int chunkSize = context.Reader.ReadUInt8();
+ if (keyDynamicType || valueDynamicType)
+ {
+ for (int i = 0; i < chunkSize; i++)
+ {
+ DynamicTypeInfo? keyDynamicInfo = null;
+ DynamicTypeInfo? valueDynamicInfo = null;
+
+ if (!keyDeclared)
+ {
+ if (keyDynamicType)
+ {
+ keyDynamicInfo = context.TypeResolver.ReadDynamicTypeInfo(ref context);
+ }
+ else
+ {
+ keySerializer.ReadTypeInfo(ref context);
+ }
+ }
+
+ if (!valueDeclared)
+ {
+ if (valueDynamicType)
+ {
+ valueDynamicInfo = context.TypeResolver.ReadDynamicTypeInfo(ref context);
+ }
+ else
+ {
+ valueSerializer.ReadTypeInfo(ref context);
+ }
+ }
+
+ if (keyDynamicInfo is not null)
+ {
+ context.SetDynamicTypeInfo(typeof(TKey), keyDynamicInfo);
+ }
+
+ TKey key = keySerializer.Read(ref context, trackKeyRef ? RefMode.Tracking : RefMode.None, false);
+ if (keyDynamicInfo is not null)
+ {
+ context.ClearDynamicTypeInfo(typeof(TKey));
+ }
+
+ if (valueDynamicInfo is not null)
+ {
+ context.SetDynamicTypeInfo(typeof(TValue), valueDynamicInfo);
+ }
+
+ TValue value = ReadValueElement(
+ ref context,
+ trackValueRef,
+ false,
+ canonicalizeValues,
+ valueSerializer);
+ if (valueDynamicInfo is not null)
+ {
+ context.ClearDynamicTypeInfo(typeof(TValue));
+ }
+
+ map[key] = value;
+ }
+
+ readCount += chunkSize;
+ continue;
+ }
+
+ if (!keyDeclared)
+ {
+ keySerializer.ReadTypeInfo(ref context);
+ }
+
+ if (!valueDeclared)
+ {
+ valueSerializer.ReadTypeInfo(ref context);
+ }
+
+ for (int i = 0; i < chunkSize; i++)
+ {
+ TKey key = keySerializer.Read(ref context, trackKeyRef ? RefMode.Tracking : RefMode.None, false);
+ TValue value = ReadValueElement(ref context, trackValueRef, false, canonicalizeValues, valueSerializer);
+ map[key] = value;
+ }
+
+ if (!keyDeclared)
+ {
+ context.ClearDynamicTypeInfo(typeof(TKey));
+ }
+
+ if (!valueDeclared)
+ {
+ context.ClearDynamicTypeInfo(typeof(TValue));
+ }
+
+ readCount += chunkSize;
+ }
+
+ return map;
+ }
+
+ private static void WriteDynamicMapPairs(
+ KeyValuePair[] pairs,
+ ref WriteContext context,
+ bool hasGenerics,
+ bool trackKeyRef,
+ bool trackValueRef,
+ bool keyDeclared,
+ bool valueDeclared,
+ bool keyDynamicType,
+ bool valueDynamicType,
+ Serializer keySerializer,
+ Serializer valueSerializer)
+ {
+ foreach (KeyValuePair pair in pairs)
+ {
+ bool keyIsNull = keySerializer.IsNoneObject(pair.Key);
+ bool valueIsNull = valueSerializer.IsNoneObject(pair.Value);
+ byte header = 0;
+ if (trackKeyRef)
+ {
+ header |= DictionaryBits.TrackingKeyRef;
+ }
+
+ if (trackValueRef)
+ {
+ header |= DictionaryBits.TrackingValueRef;
+ }
+
+ if (keyIsNull)
+ {
+ header |= DictionaryBits.KeyNull;
+ }
+ else if (!keyDynamicType && keyDeclared)
+ {
+ header |= DictionaryBits.DeclaredKeyType;
+ }
+
+ if (valueIsNull)
+ {
+ header |= DictionaryBits.ValueNull;
+ }
+ else if (!valueDynamicType && valueDeclared)
+ {
+ header |= DictionaryBits.DeclaredValueType;
+ }
+
+ context.Writer.WriteUInt8(header);
+ if (keyIsNull && valueIsNull)
+ {
+ continue;
+ }
+
+ if (keyIsNull)
+ {
+ valueSerializer.Write(
+ ref context,
+ pair.Value,
+ trackValueRef ? RefMode.Tracking : RefMode.None,
+ !valueDeclared,
+ hasGenerics);
+ continue;
+ }
+
+ if (valueIsNull)
+ {
+ keySerializer.Write(
+ ref context,
+ pair.Key,
+ trackKeyRef ? RefMode.Tracking : RefMode.None,
+ !keyDeclared,
+ hasGenerics);
+ continue;
+ }
+
+ context.Writer.WriteUInt8(1);
+ if (!keyDeclared)
+ {
+ if (keyDynamicType)
+ {
+ DynamicAnyCodec.WriteAnyTypeInfo(pair.Key!, ref context);
+ }
+ else
+ {
+ keySerializer.WriteTypeInfo(ref context);
+ }
+ }
+
+ if (!valueDeclared)
+ {
+ if (valueDynamicType)
+ {
+ DynamicAnyCodec.WriteAnyTypeInfo(pair.Value!, ref context);
+ }
+ else
+ {
+ valueSerializer.WriteTypeInfo(ref context);
+ }
+ }
+
+ keySerializer.Write(ref context, pair.Key, trackKeyRef ? RefMode.Tracking : RefMode.None, false, hasGenerics);
+ valueSerializer.Write(ref context, pair.Value, trackValueRef ? RefMode.Tracking : RefMode.None, false, hasGenerics);
+ }
+ }
+
+ private static TValue ReadValueElement(
+ ref ReadContext context,
+ bool trackValueRef,
+ bool readTypeInfo,
+ bool canonicalizeValues,
+ Serializer valueSerializer)
+ {
+ if (trackValueRef || !canonicalizeValues)
+ {
+ return valueSerializer.Read(ref context, trackValueRef ? RefMode.Tracking : RefMode.None, readTypeInfo);
+ }
+
+ int start = context.Reader.Cursor;
+ TValue value = valueSerializer.Read(ref context, RefMode.None, readTypeInfo);
+ int end = context.Reader.Cursor;
+ return context.CanonicalizeNonTrackingReference(value, start, end);
+ }
+}
diff --git a/csharp/src/Fory/EnumSerializer.cs b/csharp/src/Fory/EnumSerializer.cs
new file mode 100644
index 0000000000..ba269899e2
--- /dev/null
+++ b/csharp/src/Fory/EnumSerializer.cs
@@ -0,0 +1,43 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+public sealed class EnumSerializer : Serializer where TEnum : struct, Enum
+{
+ public override TypeId StaticTypeId => TypeId.Enum;
+ public override TEnum DefaultValue => default;
+
+ public override void WriteData(ref WriteContext context, in TEnum value, bool hasGenerics)
+ {
+ _ = hasGenerics;
+ uint ordinal = Convert.ToUInt32(value);
+ context.Writer.WriteVarUInt32(ordinal);
+ }
+
+ public override TEnum ReadData(ref ReadContext context)
+ {
+ uint ordinal = context.Reader.ReadVarUInt32();
+ TEnum value = (TEnum)Enum.ToObject(typeof(TEnum), ordinal);
+ if (!Enum.IsDefined(typeof(TEnum), value))
+ {
+ throw new InvalidDataException($"unknown enum ordinal {ordinal}");
+ }
+
+ return value;
+ }
+}
diff --git a/csharp/src/Fory/FieldSkipper.cs b/csharp/src/Fory/FieldSkipper.cs
new file mode 100644
index 0000000000..22121372cd
--- /dev/null
+++ b/csharp/src/Fory/FieldSkipper.cs
@@ -0,0 +1,114 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+public static class FieldSkipper
+{
+ public static void SkipFieldValue(ref ReadContext context, TypeMetaFieldType fieldType)
+ {
+ _ = ReadFieldValue(ref context, fieldType);
+ }
+
+ private static uint? ReadEnumOrdinal(ref ReadContext context, RefMode refMode)
+ {
+ return refMode switch
+ {
+ RefMode.None => context.Reader.ReadVarUInt32(),
+ RefMode.NullOnly => ReadNullableEnumOrdinal(ref context),
+ RefMode.Tracking => throw new InvalidDataException("enum tracking ref mode is not supported"),
+ _ => throw new InvalidDataException($"unsupported ref mode {refMode}"),
+ };
+ }
+
+ private static uint? ReadNullableEnumOrdinal(ref ReadContext context)
+ {
+ sbyte flag = context.Reader.ReadInt8();
+ if (flag == (sbyte)RefFlag.Null)
+ {
+ return null;
+ }
+
+ if (flag != (sbyte)RefFlag.NotNullValue)
+ {
+ throw new InvalidDataException($"unexpected enum nullOnly flag {flag}");
+ }
+
+ return context.Reader.ReadVarUInt32();
+ }
+
+ private static object? ReadFieldValue(ref ReadContext context, TypeMetaFieldType fieldType)
+ {
+ RefMode refMode = RefModeExtensions.From(fieldType.Nullable, fieldType.TrackRef);
+ switch (fieldType.TypeId)
+ {
+ case (uint)TypeId.Bool:
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, false);
+ case (uint)TypeId.Int8:
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, false);
+ case (uint)TypeId.Int16:
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, false);
+ case (uint)TypeId.VarInt32:
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, false);
+ case (uint)TypeId.VarInt64:
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, false);
+ case (uint)TypeId.Float32:
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, false);
+ case (uint)TypeId.Float64:
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, false);
+ case (uint)TypeId.String:
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, false);
+ case (uint)TypeId.List:
+ {
+ if (fieldType.Generics.Count != 1 || fieldType.Generics[0].TypeId != (uint)TypeId.String)
+ {
+ throw new InvalidDataException("unsupported compatible list element type");
+ }
+
+ return context.TypeResolver.GetSerializer>().Read(ref context, refMode, false);
+ }
+ case (uint)TypeId.Set:
+ {
+ if (fieldType.Generics.Count != 1 || fieldType.Generics[0].TypeId != (uint)TypeId.String)
+ {
+ throw new InvalidDataException("unsupported compatible set element type");
+ }
+
+ return context.TypeResolver.GetSerializer>().Read(ref context, refMode, false);
+ }
+ case (uint)TypeId.Map:
+ {
+ if (fieldType.Generics.Count != 2 ||
+ fieldType.Generics[0].TypeId != (uint)TypeId.String ||
+ fieldType.Generics[1].TypeId != (uint)TypeId.String)
+ {
+ throw new InvalidDataException("unsupported compatible map key/value type");
+ }
+
+ return context.TypeResolver.GetSerializer>().Read(ref context, refMode, false);
+ }
+ case (uint)TypeId.Enum:
+ return ReadEnumOrdinal(ref context, refMode);
+ case (uint)TypeId.Union:
+ case (uint)TypeId.TypedUnion:
+ case (uint)TypeId.NamedUnion:
+ return context.TypeResolver.GetSerializer().Read(ref context, refMode, false);
+ default:
+ throw new InvalidDataException($"unsupported compatible field type id {fieldType.TypeId}");
+ }
+ }
+}
diff --git a/csharp/src/Fory/Fory.cs b/csharp/src/Fory/Fory.cs
new file mode 100644
index 0000000000..124fa0ceda
--- /dev/null
+++ b/csharp/src/Fory/Fory.cs
@@ -0,0 +1,242 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+using System.Buffers;
+
+namespace Apache.Fory;
+
+public sealed class Fory
+{
+ private readonly TypeResolver _typeResolver;
+
+ internal Fory(Config config)
+ {
+ Config = config;
+ _typeResolver = new TypeResolver();
+ }
+
+ public Config Config { get; }
+
+ public static ForyBuilder Builder()
+ {
+ return new ForyBuilder();
+ }
+
+ public Fory Register(uint typeId)
+ {
+ _typeResolver.Register(typeof(T), typeId);
+ return this;
+ }
+
+ public Fory Register(string typeName)
+ {
+ _typeResolver.Register(typeof(T), string.Empty, typeName);
+ return this;
+ }
+
+ public Fory Register(string typeNamespace, string typeName)
+ {
+ _typeResolver.Register(typeof(T), typeNamespace, typeName);
+ return this;
+ }
+
+ public Fory Register(uint typeId)
+ where TSerializer : Serializer, new()
+ {
+ Serializer serializerBinding = _typeResolver.RegisterSerializer();
+ _typeResolver.Register(typeof(T), typeId, serializerBinding);
+ return this;
+ }
+
+ public Fory Register(string typeNamespace, string typeName)
+ where TSerializer : Serializer, new()
+ {
+ Serializer serializerBinding = _typeResolver.RegisterSerializer();
+ _typeResolver.Register(typeof(T), typeNamespace, typeName, serializerBinding);
+ return this;
+ }
+
+ public byte[] Serialize(in T value)
+ {
+ ByteWriter writer = new();
+ Serializer binding = _typeResolver.GetSerializer();
+ bool isNone = binding.IsNone(value);
+ WriteHead(writer, isNone);
+ if (!isNone)
+ {
+ WriteContext context = new(
+ writer,
+ _typeResolver,
+ Config.TrackRef,
+ Config.Compatible,
+ new CompatibleTypeDefWriteState(),
+ new MetaStringWriteState());
+ RefMode refMode = Config.TrackRef ? RefMode.Tracking : RefMode.NullOnly;
+ binding.Write(ref context, value, refMode, true, false);
+ context.ResetObjectState();
+ }
+
+ return writer.ToArray();
+ }
+
+ public void Serialize(IBufferWriter output, in T value)
+ {
+ byte[] payload = Serialize(value);
+ output.Write(payload);
+ }
+
+ public T Deserialize(ReadOnlySpan payload)
+ {
+ ByteReader reader = new(payload);
+ T value = DeserializeFromReader(reader);
+ if (reader.Remaining != 0)
+ {
+ throw new InvalidDataException($"unexpected trailing bytes after deserializing {typeof(T)}");
+ }
+
+ return value;
+ }
+
+ public T Deserialize(ref ReadOnlySequence payload)
+ {
+ byte[] bytes = payload.ToArray();
+ ByteReader reader = new(bytes);
+ T value = DeserializeFromReader(reader);
+ payload = payload.Slice(reader.Cursor);
+ return value;
+ }
+
+ public byte[] SerializeObject(object? value)
+ {
+ ByteWriter writer = new();
+ bool isNone = value is null;
+ WriteHead(writer, isNone);
+ if (!isNone)
+ {
+ WriteContext context = new(
+ writer,
+ _typeResolver,
+ Config.TrackRef,
+ Config.Compatible,
+ new CompatibleTypeDefWriteState(),
+ new MetaStringWriteState());
+ RefMode refMode = Config.TrackRef ? RefMode.Tracking : RefMode.NullOnly;
+ DynamicAnyCodec.WriteAny(ref context, value, refMode, true, false);
+ context.ResetObjectState();
+ }
+
+ return writer.ToArray();
+ }
+
+ public void SerializeObject(IBufferWriter output, object? value)
+ {
+ byte[] payload = SerializeObject(value);
+ output.Write(payload);
+ }
+
+ public object? DeserializeObject(ReadOnlySpan payload)
+ {
+ ByteReader reader = new(payload);
+ object? value = DeserializeObjectFromReader(reader);
+ if (reader.Remaining != 0)
+ {
+ throw new InvalidDataException("unexpected trailing bytes after deserializing dynamic object");
+ }
+
+ return value;
+ }
+
+ public object? DeserializeObject(ref ReadOnlySequence payload)
+ {
+ byte[] bytes = payload.ToArray();
+ ByteReader reader = new(bytes);
+ object? value = DeserializeObjectFromReader(reader);
+ payload = payload.Slice(reader.Cursor);
+ return value;
+ }
+
+ public void WriteHead(ByteWriter writer, bool isNone)
+ {
+ byte bitmap = 0;
+ if (Config.Xlang)
+ {
+ bitmap |= ForyHeaderFlag.IsXlang;
+ }
+
+ if (isNone)
+ {
+ bitmap |= ForyHeaderFlag.IsNull;
+ }
+
+ writer.WriteUInt8(bitmap);
+ }
+
+ public bool ReadHead(ByteReader reader)
+ {
+ byte bitmap = reader.ReadUInt8();
+ bool peerIsXlang = (bitmap & ForyHeaderFlag.IsXlang) != 0;
+ if (peerIsXlang != Config.Xlang)
+ {
+ throw new InvalidDataException("xlang bitmap mismatch");
+ }
+
+ return (bitmap & ForyHeaderFlag.IsNull) != 0;
+ }
+
+ private T DeserializeFromReader(ByteReader reader)
+ {
+ bool isNone = ReadHead(reader);
+ Serializer binding = _typeResolver.GetSerializer();
+ if (isNone)
+ {
+ return binding.DefaultValue;
+ }
+
+ ReadContext context = new(
+ reader,
+ _typeResolver,
+ Config.TrackRef,
+ Config.Compatible,
+ new CompatibleTypeDefReadState(),
+ new MetaStringReadState());
+ RefMode refMode = Config.TrackRef ? RefMode.Tracking : RefMode.NullOnly;
+ T value = binding.Read(ref context, refMode, true);
+ context.ResetObjectState();
+ return value;
+ }
+
+ private object? DeserializeObjectFromReader(ByteReader reader)
+ {
+ bool isNone = ReadHead(reader);
+ if (isNone)
+ {
+ return null;
+ }
+
+ ReadContext context = new(
+ reader,
+ _typeResolver,
+ Config.TrackRef,
+ Config.Compatible,
+ new CompatibleTypeDefReadState(),
+ new MetaStringReadState());
+ RefMode refMode = Config.TrackRef ? RefMode.Tracking : RefMode.NullOnly;
+ object? value = DynamicAnyCodec.ReadAny(ref context, refMode, true);
+ context.ResetObjectState();
+ return value;
+ }
+}
diff --git a/csharp/src/Fory/Fory.csproj b/csharp/src/Fory/Fory.csproj
new file mode 100644
index 0000000000..2082c7f5e4
--- /dev/null
+++ b/csharp/src/Fory/Fory.csproj
@@ -0,0 +1,8 @@
+
+
+ net8.0
+ 12.0
+ enable
+ enable
+
+
diff --git a/csharp/src/Fory/ForyException.cs b/csharp/src/Fory/ForyException.cs
new file mode 100644
index 0000000000..d3c4689ff2
--- /dev/null
+++ b/csharp/src/Fory/ForyException.cs
@@ -0,0 +1,70 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+public class ForyException : Exception
+{
+ public ForyException(string message) : base(message)
+ {
+ }
+}
+
+public sealed class InvalidDataException : ForyException
+{
+ public InvalidDataException(string message) : base($"Invalid data: {message}")
+ {
+ }
+}
+
+public sealed class TypeMismatchException : ForyException
+{
+ public TypeMismatchException(uint expected, uint actual)
+ : base($"Type mismatch: expected {expected}, got {actual}")
+ {
+ }
+}
+
+public sealed class TypeNotRegisteredException : ForyException
+{
+ public TypeNotRegisteredException(string message) : base($"Type not registered: {message}")
+ {
+ }
+}
+
+public sealed class RefException : ForyException
+{
+ public RefException(string message) : base($"Reference error: {message}")
+ {
+ }
+}
+
+public sealed class EncodingException : ForyException
+{
+ public EncodingException(string message) : base($"Encoding error: {message}")
+ {
+ }
+}
+
+public sealed class OutOfBoundsException : ForyException
+{
+ public OutOfBoundsException(int cursor, int need, int length)
+ : base($"Buffer out of bounds: cursor={cursor}, need={need}, length={length}")
+ {
+ }
+}
+
diff --git a/csharp/src/Fory/ForyFlags.cs b/csharp/src/Fory/ForyFlags.cs
new file mode 100644
index 0000000000..d5b1819579
--- /dev/null
+++ b/csharp/src/Fory/ForyFlags.cs
@@ -0,0 +1,54 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+public enum RefFlag : sbyte
+{
+ Null = -3,
+ Ref = -2,
+ NotNullValue = -1,
+ RefValue = 0,
+}
+
+public enum RefMode : byte
+{
+ None = 0,
+ NullOnly = 1,
+ Tracking = 2,
+}
+
+internal static class RefModeExtensions
+{
+ public static RefMode From(bool nullable, bool trackRef)
+ {
+ if (trackRef)
+ {
+ return RefMode.Tracking;
+ }
+
+ return nullable ? RefMode.NullOnly : RefMode.None;
+ }
+}
+
+public static class ForyHeaderFlag
+{
+ public const byte IsNull = 0x01;
+ public const byte IsXlang = 0x02;
+ public const byte IsOutOfBand = 0x04;
+}
+
diff --git a/csharp/src/Fory/MetaString.cs b/csharp/src/Fory/MetaString.cs
new file mode 100644
index 0000000000..f67152e2d2
--- /dev/null
+++ b/csharp/src/Fory/MetaString.cs
@@ -0,0 +1,533 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+using System.Text;
+
+namespace Apache.Fory;
+
+public enum MetaStringEncoding : byte
+{
+ Utf8 = 0,
+ LowerSpecial = 1,
+ LowerUpperDigitSpecial = 2,
+ FirstToLowerSpecial = 3,
+ AllToLowerSpecial = 4,
+}
+
+public readonly struct MetaString : IEquatable
+{
+ private const int MaxMetaStringLength = 32_767;
+
+ public MetaString(
+ string value,
+ MetaStringEncoding encoding,
+ char specialChar1,
+ char specialChar2,
+ byte[] bytes)
+ {
+ if (value.Length >= MaxMetaStringLength)
+ {
+ throw new EncodingException("meta string too long");
+ }
+
+ if (encoding != MetaStringEncoding.Utf8 && bytes.Length == 0)
+ {
+ throw new EncodingException("encoded meta string cannot be empty");
+ }
+
+ Value = value;
+ Encoding = encoding;
+ SpecialChar1 = specialChar1;
+ SpecialChar2 = specialChar2;
+ Bytes = bytes;
+ StripLastChar = encoding != MetaStringEncoding.Utf8 && (bytes[0] & 0x80) != 0;
+ }
+
+ public string Value { get; }
+
+ public MetaStringEncoding Encoding { get; }
+
+ public char SpecialChar1 { get; }
+
+ public char SpecialChar2 { get; }
+
+ public byte[] Bytes { get; }
+
+ public bool StripLastChar { get; }
+
+ public static MetaString Empty(char specialChar1, char specialChar2)
+ {
+ return new MetaString(string.Empty, MetaStringEncoding.Utf8, specialChar1, specialChar2, []);
+ }
+
+ public bool Equals(MetaString other)
+ {
+ return Value == other.Value &&
+ Encoding == other.Encoding &&
+ SpecialChar1 == other.SpecialChar1 &&
+ SpecialChar2 == other.SpecialChar2 &&
+ Bytes.AsSpan().SequenceEqual(other.Bytes);
+ }
+
+ public override bool Equals(object? obj)
+ {
+ return obj is MetaString other && Equals(other);
+ }
+
+ public override int GetHashCode()
+ {
+ HashCode hc = new();
+ hc.Add(Value);
+ hc.Add(Encoding);
+ hc.Add(SpecialChar1);
+ hc.Add(SpecialChar2);
+ foreach (byte b in Bytes)
+ {
+ hc.Add(b);
+ }
+
+ return hc.ToHashCode();
+ }
+}
+
+public sealed class MetaStringEncoder
+{
+ private const int MaxMetaStringLength = 32_767;
+
+ public MetaStringEncoder(char specialChar1, char specialChar2)
+ {
+ SpecialChar1 = specialChar1;
+ SpecialChar2 = specialChar2;
+ }
+
+ public char SpecialChar1 { get; }
+
+ public char SpecialChar2 { get; }
+
+ public static MetaStringEncoder Namespace { get; } = new('.', '_');
+
+ public static MetaStringEncoder TypeName { get; } = new('$', '_');
+
+ public static MetaStringEncoder FieldName { get; } = new('$', '_');
+
+ public MetaString Encode(string input)
+ {
+ return EncodeAuto(input, null);
+ }
+
+ public MetaString Encode(string input, IReadOnlyList allowedEncodings)
+ {
+ return EncodeAuto(input, allowedEncodings);
+ }
+
+ public MetaString Encode(string input, MetaStringEncoding encoding)
+ {
+ if (input.Length >= MaxMetaStringLength)
+ {
+ throw new EncodingException("meta string too long");
+ }
+
+ if (input.Length == 0)
+ {
+ return MetaString.Empty(SpecialChar1, SpecialChar2);
+ }
+
+ if (encoding != MetaStringEncoding.Utf8 && !IsLatin(input))
+ {
+ throw new EncodingException("non-ASCII characters are not allowed for packed meta string");
+ }
+
+ return encoding switch
+ {
+ MetaStringEncoding.Utf8 => new MetaString(
+ input,
+ MetaStringEncoding.Utf8,
+ SpecialChar1,
+ SpecialChar2,
+ Encoding.UTF8.GetBytes(input)),
+ MetaStringEncoding.LowerSpecial => new MetaString(
+ input,
+ MetaStringEncoding.LowerSpecial,
+ SpecialChar1,
+ SpecialChar2,
+ EncodeGeneric(input, 5, MapLowerSpecial)),
+ MetaStringEncoding.LowerUpperDigitSpecial => new MetaString(
+ input,
+ MetaStringEncoding.LowerUpperDigitSpecial,
+ SpecialChar1,
+ SpecialChar2,
+ EncodeGeneric(input, 6, MapLowerUpperDigitSpecial)),
+ MetaStringEncoding.FirstToLowerSpecial => new MetaString(
+ input,
+ MetaStringEncoding.FirstToLowerSpecial,
+ SpecialChar1,
+ SpecialChar2,
+ EncodeGeneric(LowerFirstAscii(input), 5, MapLowerSpecial)),
+ MetaStringEncoding.AllToLowerSpecial => new MetaString(
+ input,
+ MetaStringEncoding.AllToLowerSpecial,
+ SpecialChar1,
+ SpecialChar2,
+ EncodeGeneric(EscapeAllUpper(input), 5, MapLowerSpecial)),
+ _ => throw new EncodingException($"unsupported meta string encoding: {encoding}"),
+ };
+ }
+
+ private MetaString EncodeAuto(string input, IReadOnlyList? allowedEncodings)
+ {
+ if (input.Length >= MaxMetaStringLength)
+ {
+ throw new EncodingException("meta string too long");
+ }
+
+ if (input.Length == 0)
+ {
+ return MetaString.Empty(SpecialChar1, SpecialChar2);
+ }
+
+ if (!IsLatin(input))
+ {
+ return new MetaString(input, MetaStringEncoding.Utf8, SpecialChar1, SpecialChar2, Encoding.UTF8.GetBytes(input));
+ }
+
+ MetaStringEncoding encoding = ChooseEncoding(input, allowedEncodings);
+ return Encode(input, encoding);
+ }
+
+ private MetaStringEncoding ChooseEncoding(string input, IReadOnlyList? allowedEncodings)
+ {
+ bool Allow(MetaStringEncoding encoding)
+ {
+ return allowedEncodings is null || allowedEncodings.Contains(encoding);
+ }
+
+ int digitCount = 0;
+ int upperCount = 0;
+ bool canLowerSpecial = true;
+ bool canLowerUpperDigitSpecial = true;
+
+ foreach (char c in input)
+ {
+ if (canLowerSpecial)
+ {
+ bool isValid = c is >= 'a' and <= 'z' || c is '.' or '_' or '$' or '|';
+ if (!isValid)
+ {
+ canLowerSpecial = false;
+ }
+ }
+
+ if (canLowerUpperDigitSpecial)
+ {
+ bool isLower = c is >= 'a' and <= 'z';
+ bool isUpper = c is >= 'A' and <= 'Z';
+ bool isDigit = c is >= '0' and <= '9';
+ bool isSpecial = c == SpecialChar1 || c == SpecialChar2;
+ if (!(isLower || isUpper || isDigit || isSpecial))
+ {
+ canLowerUpperDigitSpecial = false;
+ }
+ }
+
+ if (c is >= '0' and <= '9')
+ {
+ digitCount++;
+ }
+
+ if (c is >= 'A' and <= 'Z')
+ {
+ upperCount++;
+ }
+ }
+
+ if (canLowerSpecial && Allow(MetaStringEncoding.LowerSpecial))
+ {
+ return MetaStringEncoding.LowerSpecial;
+ }
+
+ if (canLowerUpperDigitSpecial)
+ {
+ if (digitCount != 0 && Allow(MetaStringEncoding.LowerUpperDigitSpecial))
+ {
+ return MetaStringEncoding.LowerUpperDigitSpecial;
+ }
+
+ if (upperCount == 1 &&
+ char.IsUpper(input[0]) &&
+ Allow(MetaStringEncoding.FirstToLowerSpecial))
+ {
+ return MetaStringEncoding.FirstToLowerSpecial;
+ }
+
+ if ((input.Length + upperCount) * 5 < input.Length * 6 && Allow(MetaStringEncoding.AllToLowerSpecial))
+ {
+ return MetaStringEncoding.AllToLowerSpecial;
+ }
+
+ if (Allow(MetaStringEncoding.LowerUpperDigitSpecial))
+ {
+ return MetaStringEncoding.LowerUpperDigitSpecial;
+ }
+ }
+
+ return MetaStringEncoding.Utf8;
+ }
+
+ private byte[] EncodeGeneric(string input, int bitsPerChar, Func mapper)
+ {
+ int totalBits = input.Length * bitsPerChar + 1;
+ int byteLength = (totalBits + 7) / 8;
+ byte[] bytes = new byte[byteLength];
+ int currentBit = 1;
+
+ foreach (char c in input)
+ {
+ byte value = mapper(c);
+ for (int i = bitsPerChar - 1; i >= 0; i--)
+ {
+ if (((value >> i) & 0x01) != 0)
+ {
+ int bytePos = currentBit / 8;
+ int bitPos = currentBit % 8;
+ bytes[bytePos] |= (byte)(1 << (7 - bitPos));
+ }
+
+ currentBit++;
+ }
+ }
+
+ if (byteLength * 8 >= totalBits + bitsPerChar)
+ {
+ bytes[0] |= 0x80;
+ }
+
+ return bytes;
+ }
+
+ private static byte MapLowerSpecial(char c)
+ {
+ if (c is >= 'a' and <= 'z')
+ {
+ return (byte)(c - 'a');
+ }
+
+ return c switch
+ {
+ '.' => 26,
+ '_' => 27,
+ '$' => 28,
+ '|' => 29,
+ _ => throw new EncodingException("unsupported character in LOWER_SPECIAL"),
+ };
+ }
+
+ private byte MapLowerUpperDigitSpecial(char c)
+ {
+ if (c is >= 'a' and <= 'z')
+ {
+ return (byte)(c - 'a');
+ }
+
+ if (c is >= 'A' and <= 'Z')
+ {
+ return (byte)(26 + c - 'A');
+ }
+
+ if (c is >= '0' and <= '9')
+ {
+ return (byte)(52 + c - '0');
+ }
+
+ if (c == SpecialChar1)
+ {
+ return 62;
+ }
+
+ if (c == SpecialChar2)
+ {
+ return 63;
+ }
+
+ throw new EncodingException("unsupported character in LOWER_UPPER_DIGIT_SPECIAL");
+ }
+
+ private static string LowerFirstAscii(string input)
+ {
+ if (input.Length == 0)
+ {
+ return input;
+ }
+
+ return char.ToLowerInvariant(input[0]) + input[1..];
+ }
+
+ private static string EscapeAllUpper(string input)
+ {
+ StringBuilder sb = new(input.Length * 2);
+ foreach (char c in input)
+ {
+ if (char.IsUpper(c))
+ {
+ sb.Append('|');
+ sb.Append(char.ToLowerInvariant(c));
+ }
+ else
+ {
+ sb.Append(c);
+ }
+ }
+
+ return sb.ToString();
+ }
+
+ private static bool IsLatin(string input)
+ {
+ foreach (char c in input)
+ {
+ if (c > 255)
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
+
+public sealed class MetaStringDecoder
+{
+ public MetaStringDecoder(char specialChar1, char specialChar2)
+ {
+ SpecialChar1 = specialChar1;
+ SpecialChar2 = specialChar2;
+ }
+
+ public char SpecialChar1 { get; }
+
+ public char SpecialChar2 { get; }
+
+ public static MetaStringDecoder Namespace { get; } = new('.', '_');
+
+ public static MetaStringDecoder TypeName { get; } = new('$', '_');
+
+ public static MetaStringDecoder FieldName { get; } = new('$', '_');
+
+ public MetaString Decode(byte[] bytes, MetaStringEncoding encoding)
+ {
+ string value = encoding switch
+ {
+ MetaStringEncoding.Utf8 => Encoding.UTF8.GetString(bytes),
+ MetaStringEncoding.LowerSpecial => DecodeGeneric(bytes, 5, UnmapLowerSpecial),
+ MetaStringEncoding.LowerUpperDigitSpecial => DecodeGeneric(bytes, 6, UnmapLowerUpperDigitSpecial),
+ MetaStringEncoding.FirstToLowerSpecial =>
+ DecodeFirstToLowerSpecial(bytes),
+ MetaStringEncoding.AllToLowerSpecial =>
+ UnescapeAllUpper(DecodeGeneric(bytes, 5, UnmapLowerSpecial)),
+ _ => throw new EncodingException($"unsupported meta string encoding: {encoding}"),
+ };
+
+ return new MetaString(value, encoding, SpecialChar1, SpecialChar2, bytes);
+ }
+
+ private string DecodeFirstToLowerSpecial(byte[] bytes)
+ {
+ string decoded = DecodeGeneric(bytes, 5, UnmapLowerSpecial);
+ if (decoded.Length == 0)
+ {
+ return decoded;
+ }
+
+ return char.ToUpperInvariant(decoded[0]) + decoded[1..];
+ }
+
+ private string DecodeGeneric(byte[] bytes, int bitsPerChar, Func mapper)
+ {
+ if (bytes.Length == 0)
+ {
+ return string.Empty;
+ }
+
+ bool stripLast = (bytes[0] & 0x80) != 0;
+ int totalBits = bytes.Length * 8;
+ int bitIndex = 1;
+ StringBuilder sb = new(bytes.Length);
+ while (bitIndex + bitsPerChar <= totalBits &&
+ !(stripLast && (bitIndex + 2 * bitsPerChar > totalBits)))
+ {
+ byte value = 0;
+ for (var i = 0; i < bitsPerChar; i++)
+ {
+ int byteIndex = bitIndex / 8;
+ int intra = bitIndex % 8;
+ byte bit = (byte)((bytes[byteIndex] >> (7 - intra)) & 0x01);
+ value = (byte)((value << 1) | bit);
+ bitIndex++;
+ }
+
+ sb.Append(mapper(value));
+ }
+
+ return sb.ToString();
+ }
+
+ private static char UnmapLowerSpecial(byte value)
+ {
+ return value switch
+ {
+ <= 25 => (char)('a' + value),
+ 26 => '.',
+ 27 => '_',
+ 28 => '$',
+ 29 => '|',
+ _ => throw new EncodingException("invalid LOWER_SPECIAL value"),
+ };
+ }
+
+ private char UnmapLowerUpperDigitSpecial(byte value)
+ {
+ return value switch
+ {
+ <= 25 => (char)('a' + value),
+ <= 51 => (char)('A' + value - 26),
+ <= 61 => (char)('0' + value - 52),
+ 62 => SpecialChar1,
+ 63 => SpecialChar2,
+ _ => throw new EncodingException("invalid LOWER_UPPER_DIGIT_SPECIAL value"),
+ };
+ }
+
+ private static string UnescapeAllUpper(string input)
+ {
+ StringBuilder sb = new(input.Length);
+ for (int i = 0; i < input.Length; i++)
+ {
+ char c = input[i];
+ if (c == '|' && i + 1 < input.Length)
+ {
+ i++;
+ sb.Append(char.ToUpperInvariant(input[i]));
+ }
+ else
+ {
+ sb.Append(c);
+ }
+ }
+
+ return sb.ToString();
+ }
+}
+
diff --git a/csharp/src/Fory/MurmurHash3.cs b/csharp/src/Fory/MurmurHash3.cs
new file mode 100644
index 0000000000..d36c7f0a2d
--- /dev/null
+++ b/csharp/src/Fory/MurmurHash3.cs
@@ -0,0 +1,145 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+using System.Buffers.Binary;
+
+namespace Apache.Fory;
+
+public static class MurmurHash3
+{
+ public static (ulong H1, ulong H2) X64_128(ReadOnlySpan bytes, ulong seed = 47)
+ {
+ const ulong c1 = 0x87c37b91114253d5;
+ const ulong c2 = 0x4cf5ad432745937f;
+
+ ulong h1 = seed;
+ ulong h2 = seed;
+
+ int length = bytes.Length;
+ int nblocks = length / 16;
+ for (int i = 0; i < nblocks; i++)
+ {
+ int offset = i * 16;
+ ulong k1 = BinaryPrimitives.ReadUInt64LittleEndian(bytes.Slice(offset, 8));
+ ulong k2 = BinaryPrimitives.ReadUInt64LittleEndian(bytes.Slice(offset + 8, 8));
+
+ k1 *= c1;
+ k1 = RotateLeft(k1, 31);
+ k1 *= c2;
+ h1 ^= k1;
+
+ h1 = RotateLeft(h1, 27);
+ h1 += h2;
+ h1 = h1 * 5 + 0x52dce729;
+
+ k2 *= c2;
+ k2 = RotateLeft(k2, 33);
+ k2 *= c1;
+ h2 ^= k2;
+
+ h2 = RotateLeft(h2, 31);
+ h2 += h1;
+ h2 = h2 * 5 + 0x38495ab5;
+ }
+
+ ulong tk1 = 0;
+ ulong tk2 = 0;
+ int tailStart = nblocks * 16;
+ ReadOnlySpan tail = bytes.Slice(tailStart);
+ switch (length & 15)
+ {
+ case 15:
+ tk2 ^= (ulong)tail[14] << 48;
+ goto case 14;
+ case 14:
+ tk2 ^= (ulong)tail[13] << 40;
+ goto case 13;
+ case 13:
+ tk2 ^= (ulong)tail[12] << 32;
+ goto case 12;
+ case 12:
+ tk2 ^= (ulong)tail[11] << 24;
+ goto case 11;
+ case 11:
+ tk2 ^= (ulong)tail[10] << 16;
+ goto case 10;
+ case 10:
+ tk2 ^= (ulong)tail[9] << 8;
+ goto case 9;
+ case 9:
+ tk2 ^= tail[8];
+ tk2 *= c2;
+ tk2 = RotateLeft(tk2, 33);
+ tk2 *= c1;
+ h2 ^= tk2;
+ goto case 8;
+ case 8:
+ tk1 ^= (ulong)tail[7] << 56;
+ goto case 7;
+ case 7:
+ tk1 ^= (ulong)tail[6] << 48;
+ goto case 6;
+ case 6:
+ tk1 ^= (ulong)tail[5] << 40;
+ goto case 5;
+ case 5:
+ tk1 ^= (ulong)tail[4] << 32;
+ goto case 4;
+ case 4:
+ tk1 ^= (ulong)tail[3] << 24;
+ goto case 3;
+ case 3:
+ tk1 ^= (ulong)tail[2] << 16;
+ goto case 2;
+ case 2:
+ tk1 ^= (ulong)tail[1] << 8;
+ goto case 1;
+ case 1:
+ tk1 ^= tail[0];
+ tk1 *= c1;
+ tk1 = RotateLeft(tk1, 31);
+ tk1 *= c2;
+ h1 ^= tk1;
+ break;
+ }
+
+ h1 ^= (ulong)length;
+ h2 ^= (ulong)length;
+ h1 += h2;
+ h2 += h1;
+ h1 = Fmix64(h1);
+ h2 = Fmix64(h2);
+ h1 += h2;
+ h2 += h1;
+ return (h1, h2);
+ }
+
+ private static ulong RotateLeft(ulong x, int r)
+ {
+ return (x << r) | (x >> (64 - r));
+ }
+
+ private static ulong Fmix64(ulong x)
+ {
+ x ^= x >> 33;
+ x *= 0xff51afd7ed558ccd;
+ x ^= x >> 33;
+ x *= 0xc4ceb9fe1a85ec53;
+ x ^= x >> 33;
+ return x;
+ }
+}
diff --git a/csharp/src/Fory/NullableKeyDictionary.cs b/csharp/src/Fory/NullableKeyDictionary.cs
new file mode 100644
index 0000000000..19d2462610
--- /dev/null
+++ b/csharp/src/Fory/NullableKeyDictionary.cs
@@ -0,0 +1,821 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+using System.Collections;
+
+namespace Apache.Fory;
+
+#pragma warning disable CS8714
+public sealed class NullableKeyDictionary : IDictionary, IReadOnlyDictionary
+{
+ private readonly Dictionary _nonNullEntries;
+ private bool _hasNullKey;
+ private TValue _nullValue = default!;
+ private KeyCollection? _keys;
+ private ValueCollection? _values;
+
+ public NullableKeyDictionary()
+ : this((IEqualityComparer?)null)
+ {
+ }
+
+ public NullableKeyDictionary(int capacity)
+ : this(capacity, null)
+ {
+ }
+
+ public NullableKeyDictionary(IEqualityComparer? comparer)
+ : this(0, comparer)
+ {
+ }
+
+ public NullableKeyDictionary(int capacity, IEqualityComparer? comparer)
+ {
+ _nonNullEntries = comparer is null
+ ? new Dictionary(capacity)
+ : new Dictionary(capacity, comparer);
+ }
+
+ public NullableKeyDictionary(IDictionary dictionary)
+ : this(dictionary, null)
+ {
+ }
+
+ public NullableKeyDictionary(IDictionary dictionary, IEqualityComparer? comparer)
+ : this(dictionary?.Count ?? 0, comparer)
+ {
+ ArgumentNullException.ThrowIfNull(dictionary);
+ foreach (KeyValuePair entry in dictionary)
+ {
+ this[entry.Key] = entry.Value;
+ }
+ }
+
+ public int Count => _nonNullEntries.Count + (_hasNullKey ? 1 : 0);
+
+ public bool HasNullKey => _hasNullKey;
+
+ public TValue NullKeyValue => _nullValue;
+
+ public IEqualityComparer Comparer => _nonNullEntries.Comparer;
+
+ public IEnumerable> NonNullEntries => _nonNullEntries;
+
+ public ICollection Keys => _keys ??= new KeyCollection(this);
+
+ IEnumerable IReadOnlyDictionary.Keys => Keys;
+
+ public ICollection Values => _values ??= new ValueCollection(this);
+
+ IEnumerable IReadOnlyDictionary.Values => Values;
+
+ public TValue this[TKey key]
+ {
+ get
+ {
+ if (TryGetValue(key, out TValue value))
+ {
+ return value;
+ }
+
+ throw new KeyNotFoundException();
+ }
+ set => SetValue(key, value);
+ }
+
+ public bool IsReadOnly => false;
+
+ public void Add(TKey key, TValue value)
+ {
+ if (key is null)
+ {
+ if (_hasNullKey)
+ {
+ throw new ArgumentException("An item with the same key has already been added.", nameof(key));
+ }
+
+ SetNullKeyValue(value);
+ return;
+ }
+
+ _nonNullEntries.Add(key, value);
+ }
+
+ public bool ContainsKey(TKey key)
+ {
+ if (key is null)
+ {
+ return _hasNullKey;
+ }
+
+ return _nonNullEntries.ContainsKey(key);
+ }
+
+ public bool Remove(TKey key)
+ {
+ if (key is null)
+ {
+ if (!_hasNullKey)
+ {
+ return false;
+ }
+
+ _hasNullKey = false;
+ _nullValue = default!;
+ return true;
+ }
+
+ return _nonNullEntries.Remove(key);
+ }
+
+ public bool TryGetValue(TKey key, out TValue value)
+ {
+ if (key is null)
+ {
+ if (_hasNullKey)
+ {
+ value = _nullValue;
+ return true;
+ }
+
+ value = default!;
+ return false;
+ }
+
+ return _nonNullEntries.TryGetValue(key, out value!);
+ }
+
+ public void Add(KeyValuePair item)
+ {
+ Add(item.Key, item.Value);
+ }
+
+ public bool Contains(KeyValuePair item)
+ {
+ return TryGetValue(item.Key, out TValue value) &&
+ EqualityComparer.Default.Equals(value, item.Value);
+ }
+
+ public void CopyTo(KeyValuePair[] array, int arrayIndex)
+ {
+ ArgumentNullException.ThrowIfNull(array);
+ if (arrayIndex < 0)
+ {
+ throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+ }
+
+ if (array.Length - arrayIndex < Count)
+ {
+ throw new ArgumentException("The destination array is too small.", nameof(array));
+ }
+
+ if (_hasNullKey)
+ {
+ array[arrayIndex++] = new KeyValuePair(default!, _nullValue);
+ }
+
+ foreach (KeyValuePair entry in _nonNullEntries)
+ {
+ array[arrayIndex++] = entry;
+ }
+ }
+
+ public bool Remove(KeyValuePair item)
+ {
+ if (!Contains(item))
+ {
+ return false;
+ }
+
+ return Remove(item.Key);
+ }
+
+ public void Clear()
+ {
+ _nonNullEntries.Clear();
+ _hasNullKey = false;
+ _nullValue = default!;
+ }
+
+ internal void SetNullKeyValue(TValue value)
+ {
+ _hasNullKey = true;
+ _nullValue = value;
+ }
+
+ private void SetValue(TKey key, TValue value)
+ {
+ if (key is null)
+ {
+ SetNullKeyValue(value);
+ return;
+ }
+
+ _nonNullEntries[key] = value;
+ }
+
+ public IEnumerator> GetEnumerator()
+ {
+ if (_hasNullKey)
+ {
+ yield return new KeyValuePair(default!, _nullValue);
+ }
+
+ foreach (KeyValuePair entry in _nonNullEntries)
+ {
+ yield return entry;
+ }
+ }
+
+ IEnumerator IEnumerable.GetEnumerator()
+ {
+ return GetEnumerator();
+ }
+
+ private sealed class KeyCollection(NullableKeyDictionary map) : ICollection
+ {
+ private readonly NullableKeyDictionary _map = map;
+
+ public int Count => _map.Count;
+
+ public bool IsReadOnly => true;
+
+ public void Add(TKey item)
+ {
+ throw new NotSupportedException("Collection is read-only.");
+ }
+
+ public void Clear()
+ {
+ throw new NotSupportedException("Collection is read-only.");
+ }
+
+ public bool Contains(TKey item)
+ {
+ return _map.ContainsKey(item);
+ }
+
+ public void CopyTo(TKey[] array, int arrayIndex)
+ {
+ ArgumentNullException.ThrowIfNull(array);
+ if (arrayIndex < 0)
+ {
+ throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+ }
+
+ if (array.Length - arrayIndex < Count)
+ {
+ throw new ArgumentException("The destination array is too small.", nameof(array));
+ }
+
+ if (_map._hasNullKey)
+ {
+ array[arrayIndex++] = default!;
+ }
+
+ _map._nonNullEntries.Keys.CopyTo(array, arrayIndex);
+ }
+
+ public bool Remove(TKey item)
+ {
+ throw new NotSupportedException("Collection is read-only.");
+ }
+
+ public IEnumerator GetEnumerator()
+ {
+ if (_map._hasNullKey)
+ {
+ yield return default!;
+ }
+
+ foreach (TKey key in _map._nonNullEntries.Keys)
+ {
+ yield return key;
+ }
+ }
+
+ IEnumerator IEnumerable.GetEnumerator()
+ {
+ return GetEnumerator();
+ }
+ }
+
+ private sealed class ValueCollection(NullableKeyDictionary map) : ICollection
+ {
+ private readonly NullableKeyDictionary _map = map;
+
+ public int Count => _map.Count;
+
+ public bool IsReadOnly => true;
+
+ public void Add(TValue item)
+ {
+ throw new NotSupportedException("Collection is read-only.");
+ }
+
+ public void Clear()
+ {
+ throw new NotSupportedException("Collection is read-only.");
+ }
+
+ public bool Contains(TValue item)
+ {
+ if (_map._hasNullKey && EqualityComparer.Default.Equals(_map._nullValue, item))
+ {
+ return true;
+ }
+
+ return _map._nonNullEntries.Values.Contains(item);
+ }
+
+ public void CopyTo(TValue[] array, int arrayIndex)
+ {
+ ArgumentNullException.ThrowIfNull(array);
+ if (arrayIndex < 0)
+ {
+ throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+ }
+
+ if (array.Length - arrayIndex < Count)
+ {
+ throw new ArgumentException("The destination array is too small.", nameof(array));
+ }
+
+ if (_map._hasNullKey)
+ {
+ array[arrayIndex++] = _map._nullValue;
+ }
+
+ _map._nonNullEntries.Values.CopyTo(array, arrayIndex);
+ }
+
+ public bool Remove(TValue item)
+ {
+ throw new NotSupportedException("Collection is read-only.");
+ }
+
+ public IEnumerator GetEnumerator()
+ {
+ if (_map._hasNullKey)
+ {
+ yield return _map._nullValue;
+ }
+
+ foreach (TValue value in _map._nonNullEntries.Values)
+ {
+ yield return value;
+ }
+ }
+
+ IEnumerator IEnumerable.GetEnumerator()
+ {
+ return GetEnumerator();
+ }
+ }
+}
+
+public sealed class NullableKeyDictionarySerializer : Serializer>
+{
+ public override TypeId StaticTypeId => TypeId.Map;
+ public override bool IsNullableType => true;
+ public override bool IsReferenceTrackableType => true;
+ public override NullableKeyDictionary DefaultValue => null!;
+ public override bool IsNone(in NullableKeyDictionary value) => value is null;
+
+ public override void WriteData(ref WriteContext context, in NullableKeyDictionary value, bool hasGenerics)
+ {
+ Serializer keySerializer = context.TypeResolver.GetSerializer();
+ Serializer valueSerializer = context.TypeResolver.GetSerializer();
+ NullableKeyDictionary map = value ?? new NullableKeyDictionary();
+ context.Writer.WriteVarUInt32((uint)map.Count);
+ if (map.Count == 0)
+ {
+ return;
+ }
+
+ bool trackKeyRef = context.TrackRef && keySerializer.IsReferenceTrackableType;
+ bool trackValueRef = context.TrackRef && valueSerializer.IsReferenceTrackableType;
+ bool keyDeclared = hasGenerics && !keySerializer.StaticTypeId.NeedsTypeInfoForField();
+ bool valueDeclared = hasGenerics && !valueSerializer.StaticTypeId.NeedsTypeInfoForField();
+ bool keyDynamicType = keySerializer.StaticTypeId == TypeId.Unknown;
+ bool valueDynamicType = valueSerializer.StaticTypeId == TypeId.Unknown;
+ KeyValuePair[] pairs = [.. map];
+ if (keyDynamicType || valueDynamicType)
+ {
+ WriteDynamicMapPairs(
+ pairs,
+ ref context,
+ hasGenerics,
+ trackKeyRef,
+ trackValueRef,
+ keyDeclared,
+ valueDeclared,
+ keyDynamicType,
+ valueDynamicType,
+ keySerializer,
+ valueSerializer);
+ return;
+ }
+
+ foreach (KeyValuePair entry in pairs)
+ {
+ bool keyIsNull = entry.Key is null || keySerializer.IsNoneObject(entry.Key);
+ bool valueIsNull = valueSerializer.IsNoneObject(entry.Value);
+ byte header = 0;
+ if (trackKeyRef)
+ {
+ header |= DictionaryBits.TrackingKeyRef;
+ }
+
+ if (trackValueRef)
+ {
+ header |= DictionaryBits.TrackingValueRef;
+ }
+
+ if (keyIsNull)
+ {
+ header |= DictionaryBits.KeyNull;
+ }
+ else if (keyDeclared)
+ {
+ header |= DictionaryBits.DeclaredKeyType;
+ }
+
+ if (valueIsNull)
+ {
+ header |= DictionaryBits.ValueNull;
+ }
+ else if (valueDeclared)
+ {
+ header |= DictionaryBits.DeclaredValueType;
+ }
+
+ context.Writer.WriteUInt8(header);
+ if (keyIsNull && valueIsNull)
+ {
+ continue;
+ }
+
+ if (keyIsNull)
+ {
+ if (!valueDeclared)
+ {
+ valueSerializer.WriteTypeInfo(ref context);
+ }
+
+ valueSerializer.Write(
+ ref context,
+ entry.Value,
+ trackValueRef ? RefMode.Tracking : RefMode.None,
+ false,
+ hasGenerics);
+ continue;
+ }
+
+ if (valueIsNull)
+ {
+ if (!keyDeclared)
+ {
+ keySerializer.WriteTypeInfo(ref context);
+ }
+
+ keySerializer.Write(
+ ref context,
+ entry.Key!,
+ trackKeyRef ? RefMode.Tracking : RefMode.None,
+ false,
+ hasGenerics);
+ continue;
+ }
+
+ context.Writer.WriteUInt8(1);
+ if (!keyDeclared)
+ {
+ keySerializer.WriteTypeInfo(ref context);
+ }
+
+ if (!valueDeclared)
+ {
+ valueSerializer.WriteTypeInfo(ref context);
+ }
+
+ keySerializer.Write(
+ ref context,
+ entry.Key!,
+ trackKeyRef ? RefMode.Tracking : RefMode.None,
+ false,
+ hasGenerics);
+ valueSerializer.Write(
+ ref context,
+ entry.Value,
+ trackValueRef ? RefMode.Tracking : RefMode.None,
+ false,
+ hasGenerics);
+ }
+ }
+
+ public override NullableKeyDictionary ReadData(ref ReadContext context)
+ {
+ Serializer keySerializer = context.TypeResolver.GetSerializer();
+ Serializer valueSerializer = context.TypeResolver.GetSerializer();
+ int totalLength = checked((int)context.Reader.ReadVarUInt32());
+ if (totalLength == 0)
+ {
+ return new NullableKeyDictionary();
+ }
+
+ NullableKeyDictionary map = new();
+ bool keyDynamicType = keySerializer.StaticTypeId == TypeId.Unknown;
+ bool valueDynamicType = valueSerializer.StaticTypeId == TypeId.Unknown;
+ bool canonicalizeValues = context.TrackRef && valueSerializer.IsReferenceTrackableType;
+
+ int readCount = 0;
+ while (readCount < totalLength)
+ {
+ byte header = context.Reader.ReadUInt8();
+ bool trackKeyRef = (header & DictionaryBits.TrackingKeyRef) != 0;
+ bool keyNull = (header & DictionaryBits.KeyNull) != 0;
+ bool keyDeclared = (header & DictionaryBits.DeclaredKeyType) != 0;
+ bool trackValueRef = (header & DictionaryBits.TrackingValueRef) != 0;
+ bool valueNull = (header & DictionaryBits.ValueNull) != 0;
+ bool valueDeclared = (header & DictionaryBits.DeclaredValueType) != 0;
+
+ if (keyNull && valueNull)
+ {
+ map.SetNullKeyValue((TValue)valueSerializer.DefaultObject!);
+ readCount += 1;
+ continue;
+ }
+
+ if (keyNull)
+ {
+ TValue valueRead = ReadValueElement(
+ ref context,
+ trackValueRef,
+ !valueDeclared,
+ canonicalizeValues,
+ valueSerializer);
+
+ map.SetNullKeyValue(valueRead);
+ readCount += 1;
+ continue;
+ }
+
+ if (valueNull)
+ {
+ TKey key = keySerializer.Read(
+ ref context,
+ trackKeyRef ? RefMode.Tracking : RefMode.None,
+ !keyDeclared);
+
+ map[key] = (TValue)valueSerializer.DefaultObject!;
+ readCount += 1;
+ continue;
+ }
+
+ int chunkSize = context.Reader.ReadUInt8();
+ if (keyDynamicType || valueDynamicType)
+ {
+ for (int i = 0; i < chunkSize; i++)
+ {
+ DynamicTypeInfo? keyDynamicInfo = null;
+ DynamicTypeInfo? valueDynamicInfo = null;
+
+ if (!keyDeclared)
+ {
+ if (keyDynamicType)
+ {
+ keyDynamicInfo = context.TypeResolver.ReadDynamicTypeInfo(ref context);
+ }
+ else
+ {
+ keySerializer.ReadTypeInfo(ref context);
+ }
+ }
+
+ if (!valueDeclared)
+ {
+ if (valueDynamicType)
+ {
+ valueDynamicInfo = context.TypeResolver.ReadDynamicTypeInfo(ref context);
+ }
+ else
+ {
+ valueSerializer.ReadTypeInfo(ref context);
+ }
+ }
+
+ if (keyDynamicInfo is not null)
+ {
+ context.SetDynamicTypeInfo(typeof(TKey), keyDynamicInfo);
+ }
+
+ TKey key = keySerializer.Read(ref context, trackKeyRef ? RefMode.Tracking : RefMode.None, false);
+ if (keyDynamicInfo is not null)
+ {
+ context.ClearDynamicTypeInfo(typeof(TKey));
+ }
+
+ if (valueDynamicInfo is not null)
+ {
+ context.SetDynamicTypeInfo(typeof(TValue), valueDynamicInfo);
+ }
+
+ TValue valueRead = ReadValueElement(
+ ref context,
+ trackValueRef,
+ false,
+ canonicalizeValues,
+ valueSerializer);
+ if (valueDynamicInfo is not null)
+ {
+ context.ClearDynamicTypeInfo(typeof(TValue));
+ }
+
+ map[key] = valueRead;
+ }
+
+ readCount += chunkSize;
+ continue;
+ }
+
+ if (!keyDeclared)
+ {
+ keySerializer.ReadTypeInfo(ref context);
+ }
+
+ if (!valueDeclared)
+ {
+ valueSerializer.ReadTypeInfo(ref context);
+ }
+
+ for (int i = 0; i < chunkSize; i++)
+ {
+ TKey key = keySerializer.Read(ref context, trackKeyRef ? RefMode.Tracking : RefMode.None, false);
+ TValue valueRead = ReadValueElement(ref context, trackValueRef, false, canonicalizeValues, valueSerializer);
+ map[key] = valueRead;
+ }
+
+ if (!keyDeclared)
+ {
+ context.ClearDynamicTypeInfo(typeof(TKey));
+ }
+
+ if (!valueDeclared)
+ {
+ context.ClearDynamicTypeInfo(typeof(TValue));
+ }
+
+ readCount += chunkSize;
+ }
+
+ return map;
+ }
+
+ private static void WriteDynamicMapPairs(
+ KeyValuePair[] pairs,
+ ref WriteContext context,
+ bool hasGenerics,
+ bool trackKeyRef,
+ bool trackValueRef,
+ bool keyDeclared,
+ bool valueDeclared,
+ bool keyDynamicType,
+ bool valueDynamicType,
+ Serializer keySerializer,
+ Serializer valueSerializer)
+ {
+ foreach (KeyValuePair pair in pairs)
+ {
+ bool keyIsNull = pair.Key is null || keySerializer.IsNoneObject(pair.Key);
+ bool valueIsNull = valueSerializer.IsNoneObject(pair.Value);
+ byte header = 0;
+ if (trackKeyRef)
+ {
+ header |= DictionaryBits.TrackingKeyRef;
+ }
+
+ if (trackValueRef)
+ {
+ header |= DictionaryBits.TrackingValueRef;
+ }
+
+ if (keyIsNull)
+ {
+ header |= DictionaryBits.KeyNull;
+ }
+ else if (!keyDynamicType && keyDeclared)
+ {
+ header |= DictionaryBits.DeclaredKeyType;
+ }
+
+ if (valueIsNull)
+ {
+ header |= DictionaryBits.ValueNull;
+ }
+ else if (!valueDynamicType && valueDeclared)
+ {
+ header |= DictionaryBits.DeclaredValueType;
+ }
+
+ context.Writer.WriteUInt8(header);
+ if (keyIsNull && valueIsNull)
+ {
+ continue;
+ }
+
+ if (keyIsNull)
+ {
+ valueSerializer.Write(
+ ref context,
+ pair.Value,
+ trackValueRef ? RefMode.Tracking : RefMode.None,
+ !valueDeclared,
+ hasGenerics);
+ continue;
+ }
+
+ if (valueIsNull)
+ {
+ keySerializer.Write(
+ ref context,
+ pair.Key!,
+ trackKeyRef ? RefMode.Tracking : RefMode.None,
+ !keyDeclared,
+ hasGenerics);
+ continue;
+ }
+
+ context.Writer.WriteUInt8(1);
+ if (!keyDeclared)
+ {
+ if (keyDynamicType)
+ {
+ DynamicAnyCodec.WriteAnyTypeInfo(pair.Key!, ref context);
+ }
+ else
+ {
+ keySerializer.WriteTypeInfo(ref context);
+ }
+ }
+
+ if (!valueDeclared)
+ {
+ if (valueDynamicType)
+ {
+ DynamicAnyCodec.WriteAnyTypeInfo(pair.Value!, ref context);
+ }
+ else
+ {
+ valueSerializer.WriteTypeInfo(ref context);
+ }
+ }
+
+ keySerializer.Write(
+ ref context,
+ pair.Key!,
+ trackKeyRef ? RefMode.Tracking : RefMode.None,
+ false,
+ hasGenerics);
+ valueSerializer.Write(
+ ref context,
+ pair.Value,
+ trackValueRef ? RefMode.Tracking : RefMode.None,
+ false,
+ hasGenerics);
+ }
+ }
+
+ private static TValue ReadValueElement(
+ ref ReadContext context,
+ bool trackValueRef,
+ bool readTypeInfo,
+ bool canonicalizeValues,
+ Serializer valueSerializer)
+ {
+ if (trackValueRef || !canonicalizeValues)
+ {
+ return valueSerializer.Read(ref context, trackValueRef ? RefMode.Tracking : RefMode.None, readTypeInfo);
+ }
+
+ int start = context.Reader.Cursor;
+ TValue value = valueSerializer.Read(ref context, RefMode.None, readTypeInfo);
+ int end = context.Reader.Cursor;
+ return context.CanonicalizeNonTrackingReference(value, start, end);
+ }
+}
+#pragma warning restore CS8714
diff --git a/csharp/src/Fory/OptionalSerializer.cs b/csharp/src/Fory/OptionalSerializer.cs
new file mode 100644
index 0000000000..4ac31bcda1
--- /dev/null
+++ b/csharp/src/Fory/OptionalSerializer.cs
@@ -0,0 +1,142 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+namespace Apache.Fory;
+
+public sealed class NullableSerializer : Serializer where T : struct
+{
+ private readonly Serializer