fix: delegate enum property deserialization to JsonSerializer.Deserialize

Model-level enum property reading now delegates to the enum's own
registered JsonConverter via JsonSerializer.Deserialize<EnumType>()
instead of inlining reader.GetString()/GetInt32() calls. This ensures
the already-fixed enum converters handle all type branching correctly.

Also propagate isNumeric/isInteger/isLong/isFloat/isDouble/isDecimal
flags from referenced enum models to properties in patchProperty(),
so the Write path correctly uses WriteNumber vs WriteString.

Co-authored-by: alexaka1 <22166651+alexaka1@users.noreply.github.com>

Author: Copilot

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractCSharpCodegen.java

@@ -839,6 +839,16 @@ protected void patchProperty(Map<String, CodegenModel> enumRefs, CodegenModel mo
 
             // We do these after updateCodegenPropertyEnum to avoid generalities that don't mesh with C#.
             property.isPrimitiveType = true;
+
+            // Propagate numeric type flags from the referenced enum model so templates
+            // can branch on isNumeric/isInteger/isLong/isFloat/isDouble/isDecimal.
+            property.isNumeric = refModel.isNumeric;
+            property.isInteger = refModel.isInteger;
+            property.isLong = refModel.isLong;
+            property.isFloat = refModel.isFloat;
+            property.isDouble = refModel.isDouble;
+            property.isDecimal = refModel.isDecimal;
+            property.isString = refModel.isString;
         }
 
         this.patchPropertyIsInherited(model, property);

modules/openapi-generator/src/main/resources/csharp/libraries/generichost/JsonConverter.mustache

@@ -225,20 +225,7 @@
                         {{/isDateTime}}
                         {{#isEnum}}
                         {{^isMap}}
-                        {{#isNumeric}}
-                            {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} = {{>OptionProperty}}utf8JsonReader.TokenType == JsonTokenType.Null ? ({{#isInnerEnum}}{{classname}}.{{/isInnerEnum}}{{{datatypeWithEnum}}}?)null : ({{#isInnerEnum}}{{classname}}.{{/isInnerEnum}}{{{datatypeWithEnum}}})utf8JsonReader.Get{{#vendorExtensions.x-unsigned}}U{{/vendorExtensions.x-unsigned}}Int32());
-                        {{/isNumeric}}
-                        {{^isNumeric}}
-                            string{{nrt?}} {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}RawValue = utf8JsonReader.GetString();
-                            {{^isInnerEnum}}
-                            if ({{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}RawValue != null)
-                                {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} = {{>OptionProperty}}{{{datatypeWithEnum}}}ValueConverter.FromStringOrDefault({{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}RawValue));
-                            {{/isInnerEnum}}
-                            {{#isInnerEnum}}
-                            if ({{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}RawValue != null)
-                                {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} = {{>OptionProperty}}{{classname}}.{{{datatypeWithEnum}}}FromStringOrDefault({{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}RawValue));
-                            {{/isInnerEnum}}
-                        {{/isNumeric}}
+                            {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} = {{>OptionProperty}}JsonSerializer.Deserialize<{{#isInnerEnum}}{{classname}}.{{/isInnerEnum}}{{{datatypeWithEnum}}}{{#isNullable}}?{{/isNullable}}>(ref utf8JsonReader, jsonSerializerOptions));
                         {{/isMap}}
                         {{/isEnum}}
                         {{#isUuid}}

modules/openapi-generator/src/test/java/org/openapitools/codegen/csharpnetcore/CSharpClientCodegenTest.java

@@ -337,5 +337,24 @@ public void testIntegerEnumJsonConverterUsesNumericOperations() throws IOExcepti
                 "writer.WriteStringValue(",
                 "return (double) value"
         );
+
+        // Verify model with enum properties uses JsonSerializer.Deserialize for enum props
+        File modelFile = files.get(Paths
+                .get(output.getAbsolutePath(), "src", "Org.OpenAPITools", "Model", "ModelWithEnumProperties.cs")
+                .toString()
+        );
+        assertNotNull(modelFile, "Could not find file for model: ModelWithEnumProperties");
+        assertFileContains(modelFile.toPath(),
+                "JsonSerializer.Deserialize<IntegerEnum",
+                "JsonSerializer.Deserialize<LongEnum",
+                "JsonSerializer.Deserialize<DoubleEnum"
+        );
+        // Enum property values should NOT be read inline with Get* methods;
+        // only the JSON property name key uses GetString, not the enum values
+        assertFileNotContains(modelFile.toPath(),
+                "utf8JsonReader.GetInt32()",
+                "utf8JsonReader.GetInt64()",
+                "utf8JsonReader.GetDouble()"
+        );
     }
 }

modules/openapi-generator/src/test/resources/3_0/csharp/integer-enum.yaml

@@ -41,3 +41,12 @@ components:
         - -1.2
       type: number
       format: double
+    ModelWithEnumProperties:
+      type: object
+      properties:
+        intEnum:
+          $ref: '#/components/schemas/IntegerEnum'
+        longEnum:
+          $ref: '#/components/schemas/LongEnum'
+        doubleEnum:
+          $ref: '#/components/schemas/DoubleEnum'

samples/client/petstore/csharp/generichost/net10/FormModels/src/Org.OpenAPITools/Model/ChildCat.cs

@@ -119,9 +119,7 @@ public override ChildCat Read(ref Utf8JsonReader utf8JsonReader, Type typeToConv
                     switch (localVarJsonPropertyName)
                     {
                         case "pet_type":
-                            string petTypeRawValue = utf8JsonReader.GetString();
-                            if (petTypeRawValue != null)
-                                petType = new Option<ChildCatAllOfPetType?>(ChildCatAllOfPetTypeValueConverter.FromStringOrDefault(petTypeRawValue));
+                            petType = new Option<ChildCatAllOfPetType?>(JsonSerializer.Deserialize<ChildCatAllOfPetType>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "name":
                             name = new Option<string>(utf8JsonReader.GetString());

samples/client/petstore/csharp/generichost/net10/FormModels/src/Org.OpenAPITools/Model/CopyActivity.cs

@@ -115,9 +115,7 @@ public override CopyActivity Read(ref Utf8JsonReader utf8JsonReader, Type typeTo
                             copyActivitytt = new Option<string>(utf8JsonReader.GetString());
                             break;
                         case "$schema":
-                            string schemaRawValue = utf8JsonReader.GetString();
-                            if (schemaRawValue != null)
-                                schema = new Option<CopyActivityAllOfSchema?>(CopyActivityAllOfSchemaValueConverter.FromStringOrDefault(schemaRawValue));
+                            schema = new Option<CopyActivityAllOfSchema?>(JsonSerializer.Deserialize<CopyActivityAllOfSchema>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         default:
                             break;

samples/client/petstore/csharp/generichost/net10/FormModels/src/Org.OpenAPITools/Model/Descendant1.cs

@@ -112,9 +112,7 @@ public override Descendant1 Read(ref Utf8JsonReader utf8JsonReader, Type typeToC
                             descendantName = new Option<string>(utf8JsonReader.GetString());
                             break;
                         case "objectType":
-                            string objectTypeRawValue = utf8JsonReader.GetString();
-                            if (objectTypeRawValue != null)
-                                objectType = new Option<TestDescendantsObjectType?>(TestDescendantsObjectTypeValueConverter.FromStringOrDefault(objectTypeRawValue));
+                            objectType = new Option<TestDescendantsObjectType?>(JsonSerializer.Deserialize<TestDescendantsObjectType>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         default:
                             break;

samples/client/petstore/csharp/generichost/net10/FormModels/src/Org.OpenAPITools/Model/Descendant2.cs

@@ -112,9 +112,7 @@ public override Descendant2 Read(ref Utf8JsonReader utf8JsonReader, Type typeToC
                             confidentiality = new Option<string>(utf8JsonReader.GetString());
                             break;
                         case "objectType":
-                            string objectTypeRawValue = utf8JsonReader.GetString();
-                            if (objectTypeRawValue != null)
-                                objectType = new Option<TestDescendantsObjectType?>(TestDescendantsObjectTypeValueConverter.FromStringOrDefault(objectTypeRawValue));
+                            objectType = new Option<TestDescendantsObjectType?>(JsonSerializer.Deserialize<TestDescendantsObjectType>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         default:
                             break;

samples/client/petstore/csharp/generichost/net10/FormModels/src/Org.OpenAPITools/Model/EnumArrays.cs

@@ -146,9 +146,7 @@ public override EnumArrays Read(ref Utf8JsonReader utf8JsonReader, Type typeToCo
                             arrayEnum = new Option<List<EnumArraysArrayEnumInner>>(JsonSerializer.Deserialize<List<EnumArraysArrayEnumInner>>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "just_symbol":
-                            string justSymbolRawValue = utf8JsonReader.GetString();
-                            if (justSymbolRawValue != null)
-                                justSymbol = new Option<EnumArraysJustSymbol?>(EnumArraysJustSymbolValueConverter.FromStringOrDefault(justSymbolRawValue));
+                            justSymbol = new Option<EnumArraysJustSymbol?>(JsonSerializer.Deserialize<EnumArraysJustSymbol>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         default:
                             break;

samples/client/petstore/csharp/generichost/net10/FormModels/src/Org.OpenAPITools/Model/EnumTest.cs

@@ -255,49 +255,31 @@ public override EnumTest Read(ref Utf8JsonReader utf8JsonReader, Type typeToConv
                     switch (localVarJsonPropertyName)
                     {
                         case "enum_string_required":
-                            string enumStringRequiredRawValue = utf8JsonReader.GetString();
-                            if (enumStringRequiredRawValue != null)
-                                enumStringRequired = new Option<EnumTestEnumString?>(EnumTestEnumStringValueConverter.FromStringOrDefault(enumStringRequiredRawValue));
+                            enumStringRequired = new Option<EnumTestEnumString?>(JsonSerializer.Deserialize<EnumTestEnumString>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "enum_integer":
-                            string enumIntegerRawValue = utf8JsonReader.GetString();
-                            if (enumIntegerRawValue != null)
-                                enumInteger = new Option<EnumTestEnumInteger?>(EnumTestEnumIntegerValueConverter.FromStringOrDefault(enumIntegerRawValue));
+                            enumInteger = new Option<EnumTestEnumInteger?>(JsonSerializer.Deserialize<EnumTestEnumInteger>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "enum_integer_only":
-                            string enumIntegerOnlyRawValue = utf8JsonReader.GetString();
-                            if (enumIntegerOnlyRawValue != null)
-                                enumIntegerOnly = new Option<EnumTestEnumIntegerOnly?>(EnumTestEnumIntegerOnlyValueConverter.FromStringOrDefault(enumIntegerOnlyRawValue));
+                            enumIntegerOnly = new Option<EnumTestEnumIntegerOnly?>(JsonSerializer.Deserialize<EnumTestEnumIntegerOnly>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "enum_number":
-                            string enumNumberRawValue = utf8JsonReader.GetString();
-                            if (enumNumberRawValue != null)
-                                enumNumber = new Option<TestEnumParametersEnumQueryDoubleParameter?>(TestEnumParametersEnumQueryDoubleParameterValueConverter.FromStringOrDefault(enumNumberRawValue));
+                            enumNumber = new Option<TestEnumParametersEnumQueryDoubleParameter?>(JsonSerializer.Deserialize<TestEnumParametersEnumQueryDoubleParameter>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "enum_string":
-                            string enumStringRawValue = utf8JsonReader.GetString();
-                            if (enumStringRawValue != null)
-                                enumString = new Option<EnumTestEnumString?>(EnumTestEnumStringValueConverter.FromStringOrDefault(enumStringRawValue));
+                            enumString = new Option<EnumTestEnumString?>(JsonSerializer.Deserialize<EnumTestEnumString>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "outerEnum":
-                            string outerEnumRawValue = utf8JsonReader.GetString();
-                            if (outerEnumRawValue != null)
-                                outerEnum = new Option<OuterEnum?>(OuterEnumValueConverter.FromStringOrDefault(outerEnumRawValue));
+                            outerEnum = new Option<OuterEnum?>(JsonSerializer.Deserialize<OuterEnum?>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "outerEnumDefaultValue":
-                            string outerEnumDefaultValueRawValue = utf8JsonReader.GetString();
-                            if (outerEnumDefaultValueRawValue != null)
-                                outerEnumDefaultValue = new Option<OuterEnumDefaultValue?>(OuterEnumDefaultValueValueConverter.FromStringOrDefault(outerEnumDefaultValueRawValue));
+                            outerEnumDefaultValue = new Option<OuterEnumDefaultValue?>(JsonSerializer.Deserialize<OuterEnumDefaultValue>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "outerEnumInteger":
-                            string outerEnumIntegerRawValue = utf8JsonReader.GetString();
-                            if (outerEnumIntegerRawValue != null)
-                                outerEnumInteger = new Option<OuterEnumInteger?>(OuterEnumIntegerValueConverter.FromStringOrDefault(outerEnumIntegerRawValue));
+                            outerEnumInteger = new Option<OuterEnumInteger?>(JsonSerializer.Deserialize<OuterEnumInteger>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         case "outerEnumIntegerDefaultValue":
-                            string outerEnumIntegerDefaultValueRawValue = utf8JsonReader.GetString();
-                            if (outerEnumIntegerDefaultValueRawValue != null)
-                                outerEnumIntegerDefaultValue = new Option<OuterEnumIntegerDefaultValue?>(OuterEnumIntegerDefaultValueValueConverter.FromStringOrDefault(outerEnumIntegerDefaultValueRawValue));
+                            outerEnumIntegerDefaultValue = new Option<OuterEnumIntegerDefaultValue?>(JsonSerializer.Deserialize<OuterEnumIntegerDefaultValue>(ref utf8JsonReader, jsonSerializerOptions));
                             break;
                         default:
                             break;
@@ -363,20 +345,14 @@ public void WriteProperties(Utf8JsonWriter writer, EnumTest enumTest, JsonSerial
             writer.WriteString("enum_string_required", enumStringRequiredRawValue);
 
             if (enumTest.EnumIntegerOption.IsSet)
-            {
-                var enumIntegerRawValue = EnumTestEnumIntegerValueConverter.ToJsonValue(enumTest.EnumInteger.Value);
-                writer.WriteNumber("enum_integer", enumIntegerRawValue);
-            }
+                writer.WriteNumber("enum_integer", EnumTestEnumIntegerToJsonValue(enumTest.EnumIntegerOption.Value.Value));
+
             if (enumTest.EnumIntegerOnlyOption.IsSet)
-            {
-                var enumIntegerOnlyRawValue = EnumTestEnumIntegerOnlyValueConverter.ToJsonValue(enumTest.EnumIntegerOnly.Value);
-                writer.WriteNumber("enum_integer_only", enumIntegerOnlyRawValue);
-            }
+                writer.WriteNumber("enum_integer_only", EnumTestEnumIntegerOnlyToJsonValue(enumTest.EnumIntegerOnlyOption.Value.Value));
+
             if (enumTest.EnumNumberOption.IsSet)
-            {
-                var enumNumberRawValue = TestEnumParametersEnumQueryDoubleParameterValueConverter.ToJsonValue(enumTest.EnumNumber.Value);
-                writer.WriteNumber("enum_number", enumNumberRawValue);
-            }
+                writer.WriteNumber("enum_number", TestEnumParametersEnumQueryDoubleParameterToJsonValue(enumTest.EnumNumberOption.Value.Value));
+
             if (enumTest.EnumStringOption.IsSet)
             {
                 var enumStringRawValue = EnumTestEnumStringValueConverter.ToJsonValue(enumTest.EnumString.Value);
@@ -396,15 +372,10 @@ public void WriteProperties(Utf8JsonWriter writer, EnumTest enumTest, JsonSerial
                 writer.WriteString("outerEnumDefaultValue", outerEnumDefaultValueRawValue);
             }
             if (enumTest.OuterEnumIntegerOption.IsSet)
-            {
-                var outerEnumIntegerRawValue = OuterEnumIntegerValueConverter.ToJsonValue(enumTest.OuterEnumInteger.Value);
-                writer.WriteNumber("outerEnumInteger", outerEnumIntegerRawValue);
-            }
+                writer.WriteNumber("outerEnumInteger", OuterEnumIntegerToJsonValue(enumTest.OuterEnumIntegerOption.Value.Value));
+
             if (enumTest.OuterEnumIntegerDefaultValueOption.IsSet)
-            {
-                var outerEnumIntegerDefaultValueRawValue = OuterEnumIntegerDefaultValueValueConverter.ToJsonValue(enumTest.OuterEnumIntegerDefaultValue.Value);
-                writer.WriteNumber("outerEnumIntegerDefaultValue", outerEnumIntegerDefaultValueRawValue);
-            }
+                writer.WriteNumber("outerEnumIntegerDefaultValue", OuterEnumIntegerDefaultValueToJsonValue(enumTest.OuterEnumIntegerDefaultValueOption.Value.Value));
         }
     }
 }