Passing UTC DateTime to Web API HttpGet Method results in local time

Question 1

The query string parameter value you are sending 2014-04-01T00:00:00Z is UTC time. So, the same gets translated to a time based on your local clock and if you call ToUniversalTime(), it gets converted back to UTC.

So, what exactly is the question? If the question is why is this happening if sent in as query string but not when posted in request body, the answer to that question is that ASP.NET Web API binds the URI path, query string, etc using model binding and the body using parameter binding. For latter, it uses a media formatter. If you send JSON, the JSON media formatter is used and it is based on JSON.NET.

Since you have specified DateTimeZoneHandling.Utc, it uses that setting and you get the date time kind you want. BTW, if you change this setting to DateTimeZoneHandling.Local, then you will see the same behavior as model binding.

Question 2

If you want the conversion to be transparent, then you could use a custom TypeConverter:

public sealed class UtcDateTimeConverter : DateTimeConverter
{
    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
    {
        return ((DateTime)base.ConvertFrom(context, culture, value)).ToUniversalTime();
    }
}

and wire it up using:

TypeDescriptor.AddAttributes(typeof(DateTime), new TypeConverterAttribute(typeof(UtcDateTimeConverter)));

Then the query string parameter will be instantiated as DateTimeKind.Utc.

Question 3

I ended up just using the ToUniversalTime() method as parameters come in.

Question 4

So, for those of you who do not wish to override string-to-date conversion in your entire application, and also don't want to have to remember to modify every method that takes a date parameter, here's how you do it for a Web API project.

Ultimately, the general instructions come from here:

https://learn.microsoft.com/en-us/aspnet/web-api/overview/formats-and-model-binding/parameter-binding-in-aspnet-web-api#model-binders

Here's the specialized instructions for this case:

In your "WebApiConfig" class, add the following:

    var provider = new SimpleModelBinderProvider(typeof(DateTime),new UtcDateTimeModelBinder());
    config.Services.Insert(typeof(ModelBinderProvider), 0, provider);

Create a new class called UtcDateTimeModelBinder:

public class UtcDateTimeModelBinder : IModelBinder
{
    public bool BindModel(HttpActionContext actionContext,
        ModelBindingContext bindingContext)
    {
        if (bindingContext.ModelType != typeof(DateTime)) return false;

        var val = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        if (val == null)
        {
            return false;
        }

        var key = val.RawValue as string;
        if (key == null)
        {
            bindingContext.ModelState.AddModelError(bindingContext.ModelName,
                "Wrong value type");
            return false;
        }

        DateTime result;
        if (DateTime.TryParse(key, out result))
        {
            bindingContext.Model = result.ToUniversalTime();
            return true;
        }

        bindingContext.ModelState.AddModelError(bindingContext.ModelName,
            "Cannot convert value to Utc DateTime");
        return false;
    }
}

Question 5

I finally find this code , it's not the main answer but it can be used in some cases :

var dateUtc = TimeZoneInfo.ConvertTimeToUtc(date);

Question 6

DateTimeOffset
Our versioned API classes are automapped to internal classes. Using DateTimeOffset in the URL parameter model of the API and adding a mapping DateTimeOffset => DateTime is effective at preventing the timezone conversion. I.E.

API Class:

public DateTimeOffset? SomeDateTime{ get; set; }

Internal Class:

public DateTime? SomeDateTime{ get; set; }

Mapping profile:

CreateMap<DateTimeOffset, DateTime>();

Question 7

[This answer expands on the answer from @SeanFausett]

I wanted to have an ISO 8601 date that could have a "Z" on the and the web api function would receive it as a Utc Kind DateTime. But if there was not a "Z", I did not want the conversion.

I also needed to convert dates from incoming POST JSON payloads. The function below can support converting a string to a DateTime, DateTime?, DateTimeOffset, or DateTimeOffset?

It's handy to have dates parse the same way whether form a JSON post or URL parameter. Feel free to tailor the conversion to suit your needs.

//Register the two converters
var jSettings = new Newtonsoft.Json.JsonSerializerSettings()
jSettings.Converters.Add(new UtcDateTimeConverterJSON());
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings = jSettings;

GlobalConfiguration.Configure(config =>
{
    TypeDescriptor.AddAttributes(typeof(DateTime), new TypeConverterAttribute(typeof(UtcDateTimeConverterURI)));
    WebApiConfig.Register(config);
}

//Date converter for URI parameters
public class UtcDateTimeConverterURI : DateTimeConverter
{
    public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
    {
        if (value?.GetType() == typeof(string))
        {
            return StringToDate(typeof(DateTime), (string)value, Path: "URI parameter");
        }
        else
        {
            return base.ConvertFrom(context, culture, value);
        }
    }

    /// <summary>
    /// Convert String to DateTime, DateTime?, DateTimeOffset, or DateTimeOffset?<br />
    /// Used for incoming JSON objects and URI parameters
    /// </summary>
    /// <param name="targetType">The type (i.e. typeof(DateTime))</param>
    /// <param name="sDate">string representation of date to be converted</param>
    /// <param name="Path">JSON Path in case of error, so the caller knows which parameter to fix</param>
    /// <returns></returns>
    /// <exception cref="Exception"></exception>
    public static object StringToDate(Type targetType, string sDate, string Path)
    {
        //if the object is a DateTime, determine if we need to return a UTC or Local date type
        bool returnUTC = false;

        //DateTime or DateTimeOffset return type
        bool isDateTimeOffset;
        if (targetType == typeof(DateTime?) || targetType == typeof(DateTime))
        {
            isDateTimeOffset = false;
        }
        else
        {
            isDateTimeOffset = true;
        }

        DateTimeOffset d;

        if (String.IsNullOrEmpty(sDate))
        {
            //if we have an empty string and the type is a nullable date, then return null... otherwise throw an error
            if (targetType == typeof(DateTime?))
            {
                return null;
            }
            else
            {
                throw new Exception(Path + " cannot be an empty Date");
            }
        }

        if (sDate[0] == '/')
        {
            // /Date(xxxxx)/ format
            sDate = sDate.Substring(6, sDate.Length - 8);
            var index = sDate.LastIndexOf('-');
            if (index == -1) index = sDate.LastIndexOf('+');
            if (index >= 0)
            {
                //lop off timezone offset
                sDate = sDate.Substring(0, index);
            }
            else
            {
                //no timezone offset, return as UTC
                returnUTC = true;
            }

            if (!Int64.TryParse(sDate, out var l))
            {
                //can't parse....
                throw new Exception(Path + " cannot be parsed as a Date");
            }
            else
            {
                d = DateTimeOffset.FromUnixTimeMilliseconds(l);
            }
        }
        else
        {
            //try and parse ISO8601 string
            if (!DateTimeOffset.TryParse(sDate, out d))
            {
                throw new Exception(Path + " cannot be parsed as a Date");
            }
            else
            {
                if (!isDateTimeOffset)
                {
                    //if UTC is specifically requested and we're not returning a DateTimeOffset, then make sure the return is UTC
                    if (d.Offset == TimeSpan.Zero && sDate[sDate.Length - 1] == 'Z') returnUTC = true;
                }
            }
        }

        if (isDateTimeOffset)
        {
            return d;
        }
        else
        {
            if (returnUTC)
            {
                return d.UtcDateTime;
            }
            else
            {
                //return the raw time passed in, forcing it to the "Local" Kind
                //for example:
                //"2020-03-27T12:00:00"       --> use 2020-03-27 12:00:00PM with Kind=Local
                //"2020-03-27T12:00:00-05:00" --> use 2020-03-27 12:00:00PM with Kind=Local
                return DateTime.SpecifyKind(d.DateTime, DateTimeKind.Local); //this will pull the raw time and force the Kind to "Local"
            }
        }
    }
}


//Date converter for JSON payloads
public class UtcDateTimeConverterJSON : DateTimeConverterBase
{
    public override bool CanRead
    {
        get
        {
            return true;
        }
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.Value == null || reader.TokenType == JsonToken.Date) return reader.Value;
        if (reader.TokenType != JsonToken.String) throw new Exception("Cannot parse Date");
    
        return UtcDateTimeConverterURI.StringToDate(objectType, (string)reader.Value, reader.Path);
    }
}