feat(csharp): option to suppress DateOnly/TimeOnly converters (System.Text.Json)

packages/quicktype-core/src/language/CSharp/SystemTextJsonCSharpRenderer.ts

@@ -512,8 +512,11 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
                             }
                         }
 
-                        this.emitLine("new DateOnlyConverter(),");
-                        this.emitLine("new TimeOnlyConverter(),");
+                        if (this._options.dateTimeOnlyConverters) {
+                            this.emitLine("new DateOnlyConverter(),");
+                            this.emitLine("new TimeOnlyConverter(),");
+                        }
+
                         this.emitLine("IsoDateTimeOffsetConverter.Singleton");
                         // this.emitLine("new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }");
                     });
@@ -1305,7 +1308,16 @@ export class SystemTextJsonCSharpRenderer extends CSharpRenderer {
             this.forEachTransformation("leading-and-interposing", (n, t) =>
                 this.emitTransformation(n, t),
             );
-            this.emitMultiline(`
+            if (this._options.dateTimeOnlyConverters) {
+                this.emitDateTimeOnlyConverters();
+            }
+
+            this.emitIsoDateTimeOffsetConverter();
+        }
+    }
+
+    private emitDateTimeOnlyConverters(): void {
+        this.emitMultiline(`
 public class DateOnlyConverter : JsonConverter<DateOnly>
 {
 	private readonly string serializationFormat;
@@ -1345,9 +1357,12 @@ public class TimeOnlyConverter : JsonConverter<TimeOnly>
 
 	public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options)
 			=> writer.WriteStringValue(value.ToString(serializationFormat));
-}
+}`);
+    }
 
-internal class IsoDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
+    private emitIsoDateTimeOffsetConverter(): void {
+        this.ensureBlankLine();
+        this.emitMultiline(`internal class IsoDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
 {
 	public override bool CanConvert(Type t) => t == typeof(DateTimeOffset);
 
@@ -1415,7 +1430,6 @@ internal class IsoDateTimeOffsetConverter : JsonConverter<DateTimeOffset>
 
 	public static readonly IsoDateTimeOffsetConverter Singleton = new IsoDateTimeOffsetConverter();
 }`);
-        }
     }
 
     protected needNamespace(): boolean {

packages/quicktype-core/src/language/CSharp/language.ts

@@ -133,7 +133,15 @@ export const cSharpOptions = {
 
 export const newtonsoftCSharpOptions = { ...cSharpOptions };
 
-export const systemTextJsonCSharpOptions = { ...cSharpOptions };
+export const systemTextJsonCSharpOptions = {
+    ...cSharpOptions,
+    dateTimeOnlyConverters: new BooleanOption(
+        "dateonly-timeonly-converters",
+        "Emit DateOnly/TimeOnly converters (requires .NET 6 or later)",
+        true,
+        "secondary",
+    ),
+};
 
 export const cSharpLanguageConfig = {
     displayName: "C#",
@@ -148,8 +156,8 @@ export class CSharpTargetLanguage extends TargetLanguage<
         super(cSharpLanguageConfig);
     }
 
-    public getOptions(): typeof cSharpOptions {
-        return cSharpOptions;
+    public getOptions(): typeof systemTextJsonCSharpOptions {
+        return systemTextJsonCSharpOptions;
     }
 
     public get stringTypeMapping(): StringTypeMapping {

test/languages.ts

@@ -180,6 +180,9 @@ export const CSharpLanguageSystemTextJson: Language = {
         { density: "dense" },
         { "number-type": "decimal" },
         { "any-type": "dynamic" },
+        // Suppressing the DateOnly/TimeOnly converters (for pre-.NET 6
+        // targets) must still produce compiling, round-tripping code.
+        ["unions.json", { "dateonly-timeonly-converters": "false" }],
     ],
     sourceFiles: ["src/language/CSharp/index.ts"],
 };

test/unit/csharp-dateonly-timeonly-converters.test.ts

@@ -0,0 +1,59 @@
+import {
+    InputData,
+    JSONSchemaInput,
+    type RendererOptions,
+    quicktype,
+} from "../../packages/quicktype-core/src/index.js";
+import { describe, expect, test } from "vitest";
+
+async function renderCSharp(
+    rendererOptions: RendererOptions = {},
+): Promise<string> {
+    const schema = {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            count: { type: "integer" },
+        },
+        required: ["name", "count"],
+    };
+
+    const schemaInput = new JSONSchemaInput(undefined);
+    await schemaInput.addSource({
+        name: "TopLevel",
+        schema: JSON.stringify(schema),
+    });
+
+    const inputData = new InputData();
+    inputData.addInput(schemaInput);
+
+    const result = await quicktype({
+        inputData,
+        lang: "csharp",
+        rendererOptions: { framework: "SystemTextJson", ...rendererOptions },
+    });
+    return result.lines.join("\n");
+}
+
+describe("C# System.Text.Json DateOnly/TimeOnly converters", () => {
+    test("emits the converters by default", async () => {
+        const output = await renderCSharp();
+
+        expect(output).toContain("class DateOnlyConverter");
+        expect(output).toContain("class TimeOnlyConverter");
+        expect(output).toContain("new DateOnlyConverter(),");
+        expect(output).toContain("new TimeOnlyConverter(),");
+    });
+
+    test("omits the converters with dateonly-timeonly-converters=false", async () => {
+        const output = await renderCSharp({
+            "dateonly-timeonly-converters": "false",
+        });
+
+        expect(output).not.toContain("DateOnlyConverter");
+        expect(output).not.toContain("TimeOnlyConverter");
+        // The DateTimeOffset converter is unaffected.
+        expect(output).toContain("class IsoDateTimeOffsetConverter");
+        expect(output).toContain("IsoDateTimeOffsetConverter.Singleton");
+    });
+});