Enum default value is set to null

[loupatrick]

Description

One of my response definitions' schema contains a class that has an enum as one of its properties. The C# generated code sets the default value of this enum property to null in the class' constructor. This results in a compilation error.

Shouldn't the enums default value be set to the default value specified in the swagger?
The other possibility would be to set the enum to a nullable type.

Swagger-codegen version

I used the version hosted on editor.swagger.io

Swagger file

{
  "swagger": "2.0",
  "info": {
    "version": "bulk/2.0",
    "title": "My Api",
    "description": "My Api Reference Documentation"
  },
  "host": "MyWebsite.com",
  "basePath": "/basePath",
  "paths": {
    "/data": {
      "get": {
        "summary": "Stuff",
        "description": "Stuff",
        "operationId": "GetData",
        "consumes": [
          "application/json",
          "text/csv"
        ],
        "produces": [
          "application/json"
        ],
        "responses": {
          "201": {
            "description": "OK.",
            "schema": {
              "title": "MainResponse",
              "description": "Response when POSTing data",
              "properties": {
                "Status": {
                  "$ref": "#/definitions/Status"
                }
              }
            }
          }
        },
        "deprecated": false
      }
    }
  },
  "definitions": {
    "Status": {
      "title": "Status",
      "description": "The status",
      "default": "pending",
      "enum": [
        "pending",
        "complete"
      ],
      "type": "string"
    }
  }
}

Generated C# Class

/* 
 * My Api
 *
 * My Api Reference Documentation
 *
 * OpenAPI spec version: bulk/2.0
 * 
 * Generated by: https://github.com/swagger-api/swagger-codegen.git
 *
 * Licensed 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;
using System.Linq;
using System.IO;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Runtime.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

namespace IO.Swagger.Model
{
    /// <summary>
    /// Response when POSTing data
    /// </summary>
    [DataContract]
    public partial class MainResponse :  IEquatable<MainResponse>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="MainResponse" /> class.
        /// </summary>
        /// <param name="Status">Status.</param>
        public MainResponse(Status Status = null)
        {
            this.Status = Status;
        }

        /// <summary>
        /// Gets or Sets Status
        /// </summary>
        [DataMember(Name="Status", EmitDefaultValue=false)]
        public Status Status { get; set; }
        /// <summary>
        /// Returns the string presentation of the object
        /// </summary>
        /// <returns>String presentation of the object</returns>
        public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("class MainResponse {\n");
            sb.Append("  Status: ").Append(Status).Append("\n");
            sb.Append("}\n");
            return sb.ToString();
        }

        /// <summary>
        /// Returns the JSON string presentation of the object
        /// </summary>
        /// <returns>JSON string presentation of the object</returns>
        public string ToJson()
        {
            return JsonConvert.SerializeObject(this, Formatting.Indented);
        }

        /// <summary>
        /// Returns true if objects are equal
        /// </summary>
        /// <param name="obj">Object to be compared</param>
        /// <returns>Boolean</returns>
        public override bool Equals(object obj)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            return this.Equals(obj as MainResponse);
        }

        /// <summary>
        /// Returns true if MainResponse instances are equal
        /// </summary>
        /// <param name="other">Instance of MainResponse to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(MainResponse other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Status == other.Status ||
                    this.Status != null &&
                    this.Status.Equals(other.Status)
                );
        }

        /// <summary>
        /// Gets the hash code
        /// </summary>
        /// <returns>Hash code</returns>
        public override int GetHashCode()
        {
            // credit: http://stackoverflow.com/a/263416/677735
            unchecked // Overflow is fine, just wrap
            {
                int hash = 41;
                // Suitable nullity checks etc, of course :)
                if (this.Status != null)
                    hash = hash * 59 + this.Status.GetHashCode();
                return hash;
            }
        }
    }

}

[jimschubert]

@loupatrick @wing328 I checked this out, and I don't see a reason to use = null rather than = default(dataType). This would handle all cases, including nullable and non-nullable enums.

I'll open a PR for this approach to be evaluated.

[wing328]

@loupatrick the fix has been merged into master. Please pull the master to give it a try.

Warning: Using default() for an enum is NOT the same as null! An enum is just a primitive type internally(usually int). As a result default(EnumType) equals 0. And the element with value 0 in EnumType might be an actual value with a vastly different meaning than null/none! You'd pretty much get random data (what ever may be the first element in an enum) instead of null. This could mess things up big time!
The correct way to allow enums to be null would be to mark it as nullable (EnumType?) and have "null" as the default value, just as you do with an int.

[jimschubert]

@timhaovo default(EnumType?) produces null. this code should work as expected in current master.

Well, if it generates as default(EnumType?) that's fine. The OP just seems to propose using the non-nullable default(EnumType) as a solution to enums not accepting null, which is not fine at all.
If enums are correctly marked as nullable in ctor (they aren't in 2.2.1), then why switch to using default() anyway? Enums marked as nullable do accept null. And null is way less confusing than default(EnumType?) which is dangerously close to default(EnumType). default() always holds the risk of generating a value that's not actually null, so why not just use null to be sure?