feat(csharp): rework enum serialization to eliminate reflection

[Swimburger]

Description

Linear ticket: Closes FER-4622

Eliminates all reflection usage from C# enum JSON serialization by generating per-enum serializer classes with compile-time dictionary lookups.

Link to Devin Session
Requested by: @Swimburger

Changes Made

Regular enums (EnumGenerator.ts / Enum.ts):

• Each enum now generates a companion {EnumName}Serializer class in the same file
• Two static readonly dictionaries (_stringToEnum, _enumToString) provide O(1) bidirectional mapping
• Read uses _stringToEnum.TryGetValue() — returns default for unknown values
• Write uses _enumToString.TryGetValue() — writes null for unknown values
• Replaces [JsonConverter(typeof(EnumSerializer<T>))] → [JsonConverter(typeof(TSerializer))]

String enums (StringEnumGenerator.ts):

• Each string enum now generates a nested {EnumName}Serializer class inside the record struct
• Read: new MyEnum(stringValue) — no reflection needed (previously used Activator.CreateInstance)
• Write: writer.WriteStringValue(value.{propertyName}) — uses the actual property name (may be Value_ if a member is named "Value")
• Replaces [JsonConverter(typeof(StringEnumSerializer<T>))] → [JsonConverter(typeof(T.TSerializer))]

Removed generic serializer files from as-is includes:

• EnumSerializer.Template.cs and StringEnumSerializer.Template.cs are no longer included in generated output
• Corresponding test template files (EnumSerializerTests, StringEnumSerializerTests) no longer included either

Updated template test files to use inline serializers instead of generic ones.

• Updated README.md generator (not applicable)

Updates Since Last Revision

• Refactored regular enum serializers to use dictionary lookups instead of switch statements, per review feedback. Two static readonly Dictionary fields provide bidirectional mapping; Read/Write use TryGetValue().
• Resolved second merge conflict in generators/csharp/sdk/versions.yml — bumped SDK version to 2.28.0 (main claimed 2.27.0 for gRPC changes).
• Previous fixes retained: undiscriminated-unions Value_ property fix, biome formatting fixes, changelog validation fixes.

Testing

• Seed tests: all 6 exhaustive fixture variants pass (build + tests)
• Seed tests: undiscriminated-unions fixture passes (build + tests) — validates the Value property rename edge case
• Seed tests: enum fixture (both plain-enums and forward-compatible-enums) passes
• Full CI: all 61 checks pass

Human Review Checklist

• Dictionary Write behavior for unknown values: The dictionary-based Write method writes null for unmapped enum values (via TryGetValue returning false). The previous switch-based approach threw ArgumentOutOfRangeException. Verify this is the desired behavior for forward compatibility.
• QueryStringConverterTest.Template.cs still uses switch-based serializer: The test helper TestEnumSerializer in this file uses switch statements rather than dictionaries. This is a test-only helper (not generated code), but is inconsistent with the generated pattern. May want to align for clarity.
• StringEnumGenerator.ts — serializer created after valueProperty: The nested serializer class is intentionally defined after valueProperty (line ~227) so that the Write method can reference valueProperty.name. If anyone reorders this code and moves the serializer back before valueProperty, the hardcoded value.Value bug will return for enums with a "Value" member. Worth verifying in the undiscriminated-unions/KeyType.cs seed output that value.Value_ is generated correctly.
• Enum.ts:writeSerializerClass() — The companion serializer is written via raw string generation rather than the AST builder. Verify the generated dictionary initializers handle edge cases (special chars in wire values, default fallback for unknown values on deserialization).
• Extensions.cs Stringify still uses reflection — Determined to be unused in generated code, so left as-is. Confirm this is acceptable.
• popScope(false) calls in Enum.ts — Used to close dictionary initializer blocks without trailing newline. Verify the generated C# formatting is correct (semicolons placed correctly after closing braces).

---

[devin-ai-integration]

🤖 Devin AI Engineer

I'll be helping with this pull request! Here's what you should know:

✅ I will automatically:

• Address comments on this PR. Add '(aside)' to your comment to have me ignore it.
• Look at CI failures and help fix them

Note: I can only respond to comments from users who have write access to this repository.

⚙️ Control Options:

• Disable automatic comment and CI monitoring

[devin-ai-integration]

✅ Devin Review: No Issues Found

Devin Review analyzed this PR and found no potential bugs to report.

View in Devin Review to see 4 additional findings.

[fern-support]

I think we can do better. Let's create two maps enum -> string and string -> enum and just do lookups instead of switch statements.

[devin-ai-integration]

Good idea — I'll rework regular enum serializers to use Dictionary<string, TEnum> and Dictionary<TEnum, string> lookups instead of switch statements.

[fern-support]

Do we need an inline serializer, what was the previous StringEnumSerializer coming short for?

[devin-ai-integration]

The previous StringEnumSerializer<T> used Activator.CreateInstance (reflection) to construct the string enum instance from the deserialized string value — that's the core thing FER-4622 asked us to eliminate. The inline serializer replaces that with a direct new MyEnum(stringValue) call, no reflection needed.

For string enums specifically, the serializer is simple (just construct from string / read the Value property), so the inline version is lightweight.

[graphite-app]

The Write method writes null for unknown enum values instead of throwing an exception. This is inconsistent with the test template in QueryStringConverterTest.Template.cs:170 which throws an ArgumentOutOfRangeException. Writing null can cause silent data corruption when an invalid enum value is serialized.

// Current (problematic):
writer.WriteStringValue(_enumToString.TryGetValue(value, out var stringValue) ? stringValue : null);

// Should be:
writer.WriteStringValue(_enumToString[value]); // Throws if key not found

Suggested change

	writer.WriteStringValue(_enumToString.TryGetValue(value, out var stringValue) ? stringValue : null);
	writer.WriteStringValue(_enumToString[value]);

Spotted by Graphite



Is this helpful? React 👍 or 👎 to let us know.