[csharp] Handling of nullable and required properties

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

@@ -1157,23 +1157,26 @@ private void patchParameter(CodegenModel model, CodegenParameter parameter) {
     }
 
     protected void processOperation(CodegenOperation operation) {
-        String[] nestedTypes = { "List", "Collection", "ICollection", "Dictionary" };
+        if (operation.returnProperty == null || operation.returnProperty.items == null) {
+            return;
+        }
 
-        Arrays.stream(nestedTypes).forEach(nestedType -> {
-            if (operation.returnProperty != null && operation.returnType.contains("<" + nestedType + ">") && operation.returnProperty.items != null) {
-                String nestedReturnType = operation.returnProperty.items.dataType;
-                operation.returnType = operation.returnType.replace("<" + nestedType + ">", "<" + nestedReturnType + ">");
+        String[] nestedTypes = {"List", "Collection", "ICollection", "Dictionary"};
+        String dataType = getNullableTypeDeclaration(operation.returnProperty.items);
+
+        for (String nestedType : nestedTypes) {
+            if (operation.returnType.contains("<" + nestedType + ">")) {
+                operation.returnType = operation.returnType.replace("<" + nestedType + ">", "<" + dataType + ">");
                 operation.returnProperty.dataType = operation.returnType;
                 operation.returnProperty.datatypeWithEnum = operation.returnType;
             }
 
-            if (operation.returnProperty != null && operation.returnType.contains(", " + nestedType + ">") && operation.returnProperty.items != null) {
-                String nestedReturnType = operation.returnProperty.items.dataType;
-                operation.returnType = operation.returnType.replace(", " + nestedType + ">", ", " + nestedReturnType + ">");
+            if (operation.returnType.contains(", " + nestedType + ">")) {
+                operation.returnType = operation.returnType.replace(", " + nestedType + ">", ", " + dataType + ">");
                 operation.returnProperty.dataType = operation.returnType;
                 operation.returnProperty.datatypeWithEnum = operation.returnType;
             }
-        });
+        }
     }
 
     protected void updateCodegenParameterEnumLegacy(CodegenParameter parameter, CodegenModel model) {
@@ -1432,12 +1435,20 @@ private String getArrayTypeDeclaration(Schema arr) {
         String arrayType = typeMapping.get("array");
         StringBuilder instantiationType = new StringBuilder(arrayType);
         Schema<?> items = ModelUtils.getSchemaItems(arr);
-        String nestedType = getTypeDeclaration(items);
+
         // TODO: We may want to differentiate here between generics and primitive arrays.
-        instantiationType.append("<").append(nestedType).append(">");
+        instantiationType.append("<").append(getNullableTypeDeclaration(items)).append(">");
         return instantiationType.toString();
     }
 
+    protected String getNullableTypeDeclaration(CodegenProperty property) {
+        return property.dataType;
+    }
+
+    protected String getNullableTypeDeclaration(Schema<?> items) {
+        return getTypeDeclaration(items);
+    }
+
     @Override
     public String toInstantiationType(Schema p) {
         if (ModelUtils.isArraySchema(p)) {
@@ -1453,7 +1464,7 @@ public String getTypeDeclaration(Schema p) {
         } else if (ModelUtils.isMapSchema(p)) {
             // Should we also support maps of maps?
             Schema<?> inner = ModelUtils.getAdditionalProperties(p);
-            return getSchemaType(p) + "<string, " + getTypeDeclaration(inner) + ">";
+            return getSchemaType(p) + "<string, " + getNullableTypeDeclaration(inner) + ">";
         }
         return super.getTypeDeclaration(p);
     }

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

@@ -393,20 +393,6 @@ protected void setTypeMapping() {
         }
     }
 
-    @Override
-    protected void updateCodegenParameterEnum(CodegenParameter parameter, CodegenModel model) {
-        if (GENERICHOST.equals(getLibrary())) {
-            super.updateCodegenParameterEnum(parameter, model);
-            return;
-        }
-
-        super.updateCodegenParameterEnumLegacy(parameter, model);
-
-        if (!parameter.required && parameter.vendorExtensions.get("x-csharp-value-type") != null) { //optional
-            parameter.dataType = parameter.dataType + "?";
-        }
-    }
-
     @Override
     public String apiDocFileFolder() {
         if (GENERICHOST.equals(getLibrary())) {
@@ -456,16 +442,22 @@ public CodegenModel fromModel(String name, Schema model) {
             }
         }
 
-        // Cleanup possible duplicates. Currently, readWriteVars can contain the same property twice. May or may not be isolated to C#.
-        if (codegenModel != null && codegenModel.readWriteVars != null && codegenModel.readWriteVars.size() > 1) {
-            int length = codegenModel.readWriteVars.size() - 1;
-            for (int i = length; i > (length / 2); i--) {
-                final CodegenProperty codegenProperty = codegenModel.readWriteVars.get(i);
-                // If the property at current index is found earlier in the list, remove this last instance.
-                if (codegenModel.readWriteVars.indexOf(codegenProperty) < i) {
-                    codegenModel.readWriteVars.remove(i);
+        if (codegenModel != null && codegenModel.readWriteVars != null) {
+            // Cleanup possible duplicates. Currently, readWriteVars can contain the same property twice. May or may not be isolated to C#.
+            if (codegenModel.readWriteVars.size() > 1) {
+                int length = codegenModel.readWriteVars.size() - 1;
+                for (int i = length; i > (length / 2); i--) {
+                    final CodegenProperty codegenProperty = codegenModel.readWriteVars.get(i);
+                    // If the property at current index is found earlier in the list, remove this last instance.
+                    if (codegenModel.readWriteVars.indexOf(codegenProperty) < i) {
+                        codegenModel.readWriteVars.remove(i);
+                    }
                 }
             }
+
+            for (CodegenProperty prop : codegenModel.readWriteVars) {
+                postProcessModelProperty(codegenModel, prop);
+            }
         }
 
         // avoid breaking changes
@@ -617,23 +609,6 @@ public String getNameUsingModelPropertyNaming(String name) {
         }
     }
 
-    @Override
-    public String getNullableType(Schema p, String type) {
-        if (GENERICHOST.equals(getLibrary())) {
-            return super.getNullableType(p, type);
-        }
-
-        if (languageSpecificPrimitives.contains(type)) {
-            if (isSupportNullable() && ModelUtils.isNullable(p) && this.getNullableTypes().contains(type)) {
-                return type + "?";
-            } else {
-                return type;
-            }
-        } else {
-            return null;
-        }
-    }
-
     @Override
     public CodegenType getTag() {
         return CodegenType.CLIENT;
@@ -659,16 +634,18 @@ public void postProcessModelProperty(CodegenModel model, CodegenProperty propert
         postProcessEmitDefaultValue(property.vendorExtensions);
 
         super.postProcessModelProperty(model, property);
+
+        if (!GENERICHOST.equals(getLibrary())) {
+            if (property.isNullable && (nullReferenceTypesFlag || (!property.isContainer && (getNullableTypes().contains(property.dataType) || property.isEnum)))) {
+                property.vendorExtensions.put("x-csharp-use-nullable-operator", true);
+            }
+        }
     }
 
     @Override
     public void postProcessParameter(CodegenParameter parameter) {
         super.postProcessParameter(parameter);
         postProcessEmitDefaultValue(parameter.vendorExtensions);
-
-        if (!GENERICHOST.equals(getLibrary()) && !parameter.dataType.endsWith("?") && !parameter.required && (nullReferenceTypesFlag || this.getNullableTypes().contains(parameter.dataType))) {
-            parameter.dataType = parameter.dataType + "?";
-        }
     }
 
     public void postProcessEmitDefaultValue(Map<String, Object> vendorExtensions) {
@@ -994,6 +971,8 @@ public void addSupportingFiles(final String clientPackageDir, final String packa
         supportingFiles.add(new SupportingFile("ExceptionFactory.mustache", clientPackageDir, "ExceptionFactory.cs"));
         supportingFiles.add(new SupportingFile("OpenAPIDateConverter.mustache", clientPackageDir, "OpenAPIDateConverter.cs"));
         supportingFiles.add(new SupportingFile("ClientUtils.mustache", clientPackageDir, "ClientUtils.cs"));
+        supportingFiles.add(new SupportingFile("Option.mustache", clientPackageDir, "Option.cs"));
+
         if (needsCustomHttpMethod) {
             supportingFiles.add(new SupportingFile("HttpMethod.mustache", clientPackageDir, "HttpMethod.cs"));
         }
@@ -1544,9 +1523,20 @@ public String toInstantiationType(Schema schema) {
             if (ModelUtils.isMapSchema(additionalProperties)) {
                 inner = toInstantiationType(additionalProperties);
             }
+            if (!GENERICHOST.equals(getLibrary())) {
+                if (ModelUtils.isNullable(additionalProperties) && (this.nullReferenceTypesFlag || ModelUtils.isEnumSchema(additionalProperties) || getValueTypes().contains(inner)) && !inner.endsWith("?")) {
+                    inner += "?";
+                }
+            }
             return instantiationTypes.get("map") + "<String, " + inner + ">";
         } else if (ModelUtils.isArraySchema(schema)) {
-            String inner = getSchemaType(ModelUtils.getSchemaItems(schema));
+            Schema<?> schemaItems = ModelUtils.getSchemaItems(schema);
+            String inner = getSchemaType(schemaItems);
+            if (!GENERICHOST.equals(getLibrary())) {
+                if (ModelUtils.isNullable(schemaItems) && (this.nullReferenceTypesFlag || ModelUtils.isEnumSchema(schemaItems) || getValueTypes().contains(inner)) && !inner.endsWith("?")) {
+                    inner += "?";
+                }
+            }
             return instantiationTypes.get("array") + "<" + inner + ">";
         } else {
             return null;
@@ -1714,4 +1704,24 @@ public Map<String, Object> postProcessSupportingFileData(Map<String, Object> obj
         generateYAMLSpecFile(objs);
         return objs;
     }
+
+    protected String getNullableTypeDeclaration(CodegenProperty property) {
+        String dataType = super.getNullableTypeDeclaration(property);
+        if (!GENERICHOST.equals(getLibrary())) {
+            if (property.isNullable && (this.nullReferenceTypesFlag || property.isEnum || getValueTypes().contains(dataType)) && !dataType.endsWith("?")) {
+                dataType += "?";
+            }
+        }
+        return dataType;
+    }
+
+    protected String getNullableTypeDeclaration(Schema<?> items) {
+        String nestedType = super.getNullableTypeDeclaration(items);
+        if (!GENERICHOST.equals(getLibrary())) {
+            if (ModelUtils.isNullable(items) && (this.nullReferenceTypesFlag || ModelUtils.isEnumSchema(items) || getValueTypes().contains(nestedType)) && !nestedType.endsWith("?")) {
+                nestedType += "?";
+            }
+        }
+        return nestedType;
+    }
 }

modules/openapi-generator/src/main/resources/csharp/ApiClient.mustache

@@ -30,6 +30,7 @@ using Polly;
 using {{packageName}}.Client.Auth;
 {{/hasOAuthMethods}}
 using {{packageName}}.{{modelPackage}};
+using {{packageName}}.{{clientPackage}};
 
 namespace {{packageName}}.Client
 {
@@ -49,7 +50,8 @@ namespace {{packageName}}.Client
                 {
                     OverrideSpecifiedNames = false
                 }
-            }
+            }{{^useGenericHost}},
+            Converters = new List<JsonConverter> { new OptionConverterFactory() }{{/useGenericHost}}
         };
 
         public CustomJsonCodec(IReadableConfiguration configuration)
@@ -184,7 +186,8 @@ namespace {{packageName}}.Client
                 {
                     OverrideSpecifiedNames = false
                 }
-            }
+            }{{^useGenericHost}},
+            Converters = new List<JsonConverter> { new OptionConverterFactory() }{{/useGenericHost}}
         };
 
         /// <summary>

modules/openapi-generator/src/main/resources/csharp/CamelCaseSanitizedParamName.mustache

@@ -0,0 +1 @@
+{{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}

modules/openapi-generator/src/main/resources/csharp/DefaultDataTypeParameter.mustache

@@ -0,0 +1 @@
+default({{^required}}Option<{{/required}}{{{dataType}}}{{>NullConditionalParameter}}{{^required}}>{{/required}})

modules/openapi-generator/src/main/resources/csharp/NullConditionalParameter.mustache

@@ -1 +1 @@
-{{#isNullable}}{{nrt?}}{{^nrt}}{{#vendorExtensions.x-is-value-type}}?{{/vendorExtensions.x-is-value-type}}{{/nrt}}{{/isNullable}}
+{{#vendorExtensions.x-csharp-use-nullable-operator}}?{{/vendorExtensions.x-csharp-use-nullable-operator}}

modules/openapi-generator/src/main/resources/csharp/NullConditionalProperty.mustache

@@ -1 +1 @@
-{{#lambda.first}}{{#isNullable}}{{nrt?}}{{^nrt}}{{#vendorExtensions.x-is-value-type}}?{{/vendorExtensions.x-is-value-type}}{{/nrt}}  {{/isNullable}}{{^required}}{{nrt?}}{{^nrt}}{{#vendorExtensions.x-is-value-type}}?{{/vendorExtensions.x-is-value-type}}{{/nrt}}  {{/required}}{{/lambda.first}}
+{{#vendorExtensions.x-csharp-use-nullable-operator}}?{{/vendorExtensions.x-csharp-use-nullable-operator}}

modules/openapi-generator/src/main/resources/csharp/Option.mustache

@@ -0,0 +1,122 @@
+// <auto-generated>
+{{>partial_header}}
+
+using System;
+using Newtonsoft.Json;
+
+{{#nrt}}
+#nullable enable
+
+{{/nrt}}
+
+namespace {{packageName}}.{{clientPackage}}
+{
+    public class OptionConverter<T> : JsonConverter<Option<T>>
+    {
+        public override void WriteJson(JsonWriter writer, Option<T> value, JsonSerializer serializer)
+        {
+            if (!value.IsSet)
+            {
+                writer.WriteNull();
+            }
+            else
+            {
+                serializer.Serialize(writer, value.Value);
+            }
+        }
+
+        public override Option<T> ReadJson(JsonReader reader, Type objectType, Option<T> existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return new Option<T>();
+            }
+
+            T val = serializer.Deserialize<T>(reader);
+            return val != null ? new Option<T>(val) : new Option<T>();
+        }
+    }
+
+    public class OptionConverterFactory : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+            => objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(Option<>);
+
+        public override void WriteJson(JsonWriter writer, object{{nrt?}} value, JsonSerializer serializer)
+        {
+            Type innerType = value{{nrt?}}.GetType().GetGenericArguments()[0] ?? typeof(object);
+            var converterType = typeof(OptionConverter<>).MakeGenericType(innerType);
+            var converter = (JsonConverter)Activator.CreateInstance(converterType);
+            converter.WriteJson(writer, value, serializer);
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object{{nrt?}} existingValue, JsonSerializer serializer)
+        {
+            Type innerType = objectType.GetGenericArguments()[0];
+            var converterType = typeof(OptionConverter<>).MakeGenericType(innerType);
+            var converter = (JsonConverter)Activator.CreateInstance(converterType){{nrt!}};
+            return converter.ReadJson(reader, objectType, existingValue, serializer);
+        }
+    }
+
+    /// <summary>
+    /// A wrapper for operation parameters which are not required
+    /// </summary>
+    public struct Option<TType>
+    {
+        /// <summary>
+        /// The value to send to the server
+        /// </summary>
+        public TType Value { get; }
+
+        /// <summary>
+        /// When true the value will be sent to the server
+        /// </summary>
+        public bool IsSet { get; }
+
+        /// <summary>
+        /// A wrapper for operation parameters which are not required
+        /// </summary>
+        /// <param name="value"></param>
+        public Option(TType value)
+        {
+            IsSet = true;
+            Value = value;
+        }
+
+        {{#equatable}}
+        public bool Equals(Option<TType> other)
+        {
+            if (IsSet != other.IsSet) {
+                return false;
+            }
+            if (!IsSet) {
+                return true;
+            }
+            return object.Equals(Value, other.Value);
+        }
+
+        public static bool operator ==(Option<TType> left, Option<TType> right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(Option<TType> left, Option<TType> right)
+        {
+            return !left.Equals(right);
+        }
+        {{/equatable}}
+
+        /// <summary>
+        /// Implicitly converts this option to the contained type
+        /// </summary>
+        /// <param name="option"></param>
+        public static implicit operator TType(Option<TType> option) => option.Value;
+
+        /// <summary>
+        /// Implicitly converts the provided value to an Option
+        /// </summary>
+        /// <param name="value"></param>
+        public static implicit operator Option<TType>(TType value) => new Option<TType>(value);
+    }
+}