ASP.NET Core model binder deserilises UTC time string to local time rather than UTC time

[ZeanQin]

Describe the bug

When a user passes a UTC time string as query parameter of a GET request, the model binder converts it to a "Local" kind DateTime object rather than a UTC DateTime object. And the user has to call DateTime.ToUniversalTime() to convert it to utc time, or write custom model binder to change the behaviour globally.

To Reproduce

Steps to reproduce the behavior:

1. Send a GET request to an endpoint with a UTC time string such as https://<something>.com/{action}/{id}?time=2019-06-14T02:30:04.0576719Z
2. The time parameter in the corresponding controller is a local time

Expected behavior

The retrieved time should be a utc time.

[DamianEdwards]

Some repro code:

[Route("[controller]")]
public class TimeController : Controller
{
    public IActionResult Index(DateTime time)
    {
        var result = $"Current culture: {CultureInfo.CurrentCulture}";

        var rawTime = Request.Query["time"];
        result += $"\r\nRaw querystring value is: {rawTime}";

        // Format string "O" is ISO 8601 round-trippable https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-date-and-time-format-strings#Roundtrip
        result += $"\r\nModel-bound value is: {time.ToString("O")}, Kind is: {time.Kind}";

        var utcTime = time.ToUniversalTime();
        result += $"\r\nModel-bound converted to UTC time value is: {utcTime.ToString("O")}, Kind is: {utcTime.Kind}";

        var parsedTime = DateTime.Parse(rawTime);
        result += $"\r\nParsed time value is: {parsedTime.ToString("O")}, Kind is: {parsedTime.Kind}";

        var parsedTimeUtc = DateTime.Parse(rawTime, CultureInfo.CurrentCulture, DateTimeStyles.AdjustToUniversal);
        result += $"\r\nParsed UTC time value is: {parsedTimeUtc.ToString("O")}, Kind is: {parsedTimeUtc.Kind}";

        return Content(result);
    }
}

Result from request to https://localhost:44393/time?time=2019-06-14T02:30:04.0576719Z:

Current culture: en-US
Raw querystring value is: 2019-06-14T02:30:04.0576719Z
Model-bound value is: 2019-06-13T19:30:04.0576719-07:00, Kind is: Local
Model-bound converted to UTC time value is: 2019-06-14T02:30:04.0576719Z, Kind is: Utc
Parsed time value is: 2019-06-13T19:30:04.0576719-07:00, Kind is: Local
Parsed UTC time value is: 2019-06-14T02:30:04.0576719Z, Kind is: Utc

Same result is returned from same request when CultureInfo.CurrentCulture = CultureInfo.CurrentCulture = CultureInfo.InvariantCulture is executed before model binding runs is the same:

Current culture: 
Raw querystring value is: 2019-06-14T02:30:04.0576719Z
Model-bound value is: 2019-06-13T19:30:04.0576719-07:00, Kind is: Local
Model-bound converted to UTC time value is: 2019-06-14T02:30:04.0576719Z, Kind is: Utc
Parsed time value is: 2019-06-13T19:30:04.0576719-07:00, Kind is: Local
Parsed UTC time value is: 2019-06-14T02:30:04.0576719Z, Kind is: Utc

As can be seen, the model bound value is the same as the result of calling DateTime.Parse on the raw string. There doesn't appear to be a way to invoke DateTime.Parse such that it will detect the format of the original string and parse the result accordingly, rather one must call the overload that accepts a DateTimeStyles value and ensure the string passed matches. If we wanted to make this work in MVC we'd have to sniff the string value first to detect the trailing Z and in that case treat it specially.

Registering a custom model binder for DateTime with a different behavior will let you control this anyway you want however. For example, here's a custom DateTime model binder based on the in-box DecimalModelBinder I whipped up:

public class DateTimeModelBinderProvider : IModelBinderProvider
{
    // You could make this a property to allow customization
    internal static readonly DateTimeStyles SupportedStyles = DateTimeStyles.AdjustToUniversal | DateTimeStyles.AllowWhiteSpaces;

    /// <inheritdoc />
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        var modelType = context.Metadata.UnderlyingOrModelType;
        var loggerFactory = context.Services.GetRequiredService<ILoggerFactory>();
        if (modelType == typeof(DateTime))
        {
            return new UtcAwareDateTimeModelBinder(SupportedStyles, loggerFactory);
        }

        return null;
    }
}

public class UtcAwareDateTimeModelBinder : IModelBinder
{
    private readonly DateTimeStyles _supportedStyles;
    private readonly ILogger _logger;

    public UtcAwareDateTimeModelBinder(DateTimeStyles supportedStyles, ILoggerFactory loggerFactory)
    {
        if (loggerFactory == null)
        {
            throw new ArgumentNullException(nameof(loggerFactory));
        }

        _supportedStyles = supportedStyles;
        _logger = loggerFactory.CreateLogger<UtcAwareDateTimeModelBinder>();
    }

    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
        {
            throw new ArgumentNullException(nameof(bindingContext));
        }

        var modelName = bindingContext.ModelName;
        var valueProviderResult = bindingContext.ValueProvider.GetValue(modelName);
        if (valueProviderResult == ValueProviderResult.None)
        {
            // no entry
            return Task.CompletedTask;
        }

        var modelState = bindingContext.ModelState;
        modelState.SetModelValue(modelName, valueProviderResult);

        var metadata = bindingContext.ModelMetadata;
        var type = metadata.UnderlyingOrModelType;

        var value = valueProviderResult.FirstValue;
        var culture = valueProviderResult.Culture;

        object model;
        if (string.IsNullOrWhiteSpace(value))
        {
            model = null;
        }
        else if (type == typeof(DateTime))
        {
            // You could put custom logic here to sniff the raw value and call other DateTime.Parse overloads, e.g. forcing UTC
            model = DateTime.Parse(value, culture, _supportedStyles);
        }
        else
        {
            // unreachable
            throw new NotSupportedException();
        }

        // When converting value, a null model may indicate a failed conversion for an otherwise required
        // model (can't set a ValueType to null). This detects if a null model value is acceptable given the
        // current bindingContext. If not, an error is logged.
        if (model == null && !metadata.IsReferenceOrNullableType)
        {
            modelState.TryAddModelError(
                modelName,
                metadata.ModelBindingMessageProvider.ValueMustNotBeNullAccessor(
                    valueProviderResult.ToString()));
        }
        else
        {
            bindingContext.Result = ModelBindingResult.Success(model);
        }

        return Task.CompletedTask;
    }
}

You'd wire it up in Startup.cs like this:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers()
        .AddMvcOptions(options =>
        {
            options.ModelBinderProviders.Insert(0, new DateTimeModelBinderProvider());
        });
}

And here's the result of the action method above using this model binder:

Current culture: en-US
Raw querystring value is: 2019-06-14T02:30:04.0576719Z
Model-bound value is: 2019-06-14T02:30:04.0576719Z, Kind is: Utc
Model-bound converted to UTC time value is: 2019-06-14T02:30:04.0576719Z, Kind is: Utc
Parsed time value is: 2019-06-13T19:30:04.0576719-07:00, Kind is: Local
Parsed UTC time value is: 2019-06-14T02:30:04.0576719Z, Kind is: Utc

[alanextar]

Could please someone tells me where exactly datetime binding is processing?