Default value for DateTime: shouldn't it contain a timezone offset?

[WolfgangHG]

I have a model class with this DateTime default:

[DefaultValue(typeof(DateTime), "1900-12-31 20:00:00")]
public DateTime Date { get; set; }

I picked this syntax from WinForms designer properties - there it is the way to make the designer not serialize a control property if the current value matches the default value.

In the generated json file, a "T" is added, so you probably do something special already.

  "components": {
    "schemas": {
      "WeatherForecast": {
        "type": "object",
        "properties": {
          "date": {
            "type": "string",
            "format": "date-time",
            "default": "1900-12-31T20:00:00"
          },

But according to the spec at https://swagger.io/docs/specification/v3_0/data-models/data-types/#strings, it should be the date-time notation as defined by RFC 3339, section 5.6.
So, here either "Z" or "+00:00" is missing. A valid timezone cannot be chosen I think.

I ran into this problem when working on default value handling in Kiota - parsing of the datetime value failed for some client languages (e.g. Java or PHP)

A sample model file can be found in https://github.com/WolfgangHG/Swashbuckle_Discussion3709/ (used for a previous discussion) - start the project using the launch profile "WebApiSwaggerVersion".

[martincostello]

In the generated json file, a "T" is added, so you probably do something special already.

All we do is this:

Swashbuckle.AspNetCore/src/Swashbuckle.AspNetCore.SwaggerGen/SchemaGenerator/SchemaGenerator.cs

Lines 577 to 595 in ef008b6

	private System.Text.Json.Nodes.JsonNode GenerateDefaultValue(
	DataContract dataContract,
	Type modelType,
	object defaultValue)
	{
	// If the types do not match (e.g. a default which is an integer is specified for a double),
	// attempt to coerce the default value to the correct type so that it can be serialized correctly.
	// See https://github.com/domaindrivendev/Swashbuckle.AspNetCore/issues/2885 and
	// https://github.com/domaindrivendev/Swashbuckle.AspNetCore/issues/2904.
	var defaultValueType = defaultValue?.GetType();
	if (defaultValueType != null && defaultValueType != modelType)
	{
	dataContract = GetDataContractFor(defaultValueType);
	}
	var defaultAsJson = dataContract.JsonConverter(defaultValue);
	return JsonModelFactory.CreateFromJson(defaultAsJson);
	}

The value will get converted based on the default JSON serialization rules for DateTime for your application, which in your case appears to be the MVC defaults: code.

[WolfgangHG]

Thanks for the reply. Still trying to understand the issue....

Could I add a JsonConverter that looks like this?

  public class MyDateFormatConverter : System.Text.Json.Serialization.JsonConverter<DateTime>
  {
    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
    {
      writer.WriteStringValue(value.ToUniversalTime());
    }

    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
      reader.TryGetDateTime(out DateTime read);
      //Read as UTC? Convert to DateTime without timezone information.
      DateTime newDate = new DateTime(read.Ticks, kind: DateTimeKind.Local);;
      return newDate;
    }
  }

and register it like this?

services.AddControllers().AddJsonOptions( options =>
{
  options.JsonSerializerOptions.Converters.Add(new MyDateFormatConverter());
});

I tested only "WriteString", and it creates the excpected default value "1900-12-31T00:00:00Z" in the JSON file. "ReadString" might be wrong.

I tried to change the DefaultValueAttribute of the property and added "Z" to the string, but it resulted in an offset of one hour (german timezone is "+1").

All seems to be a matter of the fact the the DateTime parsed from the DefaultValueAttribute value has "Kind = LocalTime", and JSON serialization converts it to UTC.

Probably it would be better to use DateTimeOffset for the property, but internalization is not relevant for my app....

[WolfgangHG]

Did some more research, but I am still confused ;-).

Our real rest service still uses Newtonsoft instead of "System.Text.Json", so the code differs a bit.

I added a subclass of Newtonsoft.Json.Converters.IsoDateTimeConverter, which overrides WriteJson. Here, the DateTime value is checked: if the Kind is DateTimeKind.Unspecified, I convert it to a new DateTime value with same ticks, but Kind = DateTimeKind.Local:

public class DateTimeConverter : IsoDateTimeConverter
{
  public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
  {
    DateTime datVal = (DateTime)value;

    if (datVal.Kind == DateTimeKind.Unspecified)
    {
      DateTime datLocal = new DateTime(datVal.Ticks, DateTimeKind.Local);
      base.WriteJson(writer, datLocal, serializer);
    }
    else
    {
      base.WriteJson(writer, value, serializer);
    }
  }
}

Now all DateTime values in service responses or OpenAPI description defaults have the proper timezone.

The method ReadJson did not needed to be overriden, because my testing client (created by NSwag) already worked with DateTimeOffset properties on the client side. Here, I have to make sure that I create a datetime value like this:

DateTimeOffset someDate = new DateTime(2025, 5, 23, 13, 30, 24, DateTimeKind.Local);

And when invoking the API endpoint with e.g. Restfox and specifying a DateTime value without timezone, the IsoDateTimeConverter returned a "DateTime" object with Kind = DateTimeKind.Unspecified, which worked fine for me.

The converter is registered like this:

public void ConfigureServices(IServiceCollection services)
{
  services.AddControllers().AddNewtonsoftJson(options =>
  {
	options.SerializerSettings.Converters.Add(new DateTimeConverter());
  });
  ... 
}