Utilisation JSON.NET pour parser json date de format de Date(epochTime-offset)

Je suis en utilisant Json.net 7.0.1 en C# pour consommer une API rest. Le problème, c'est avec la date format de l'API utilise dans sa réponse JSON. Il ressemble à ceci:

/Date(1445301615000-0700)/

Qui est censé représenter une heure UTC 2015-10-19 17:40:15

Si vous branchez 1445301615000 dans un époque convertisseur, vous voyez que c'est 2015-10-20 00:40:15 . Il est 7 heures d'avance sur l'heure UTC. Ensuite, ils comprennent la -0700 sans doute pour compenser ce retour à l'UTC. Alors, dans un effort pour me donner une heure UTC, ils sont à m'envoyer UTC+7-0700. Pourquoi ils le font de cette façon je n'ai aucune idée, mais je ne peux pas changer cela.

Ma question est la meilleure façon de faire Json.NET analyser cette chaîne de date et DateTime de 2015-10-19 17:40:15 UTC. Je peux écrire une coutume JsonConverter de s'emparer de la valeur et de manipuler manuellement, mais je me demandais si il n'y a plus de méthode native.

J'ai essayé de changer le JsonSerializerSettings DateTimeZoneHandling propriété à toutes ses différentes valeurs. Réglage de l'heure Utc ignore simplement le décalage de fuseau horaire, produisant 2015-10-20 00:40:15. Le paramètre Local, non spécifié, ou RoundtripKind tous rendement 2015-10-19 20:40:15, je crois que c'est parce que mon fuseau horaire est UTC-4, de sorte qu'il est en train d'essayer d'appliquer l'ajustement de la principale valeur à la date de 2015-10-20 00:40.

J'ai aussi envisagé d'utiliser la DateFormatString propriété pour représenter la date prévue de la chaîne de format. Mais je ne pouvais pas trouver la bonne format de chaîne de caractères pour représenter cette epochtime offset format.

Voici un exemple simplifié:

Person person;
string json = @"{ 'Name': 'John', 
                  'LastSeen':'/Date(1445301615000-0700)/' }";   //1445301615000 = 2015-10-20 00:40:15

person = JsonConvert.DeserializeObject<Person>(json);
Console.WriteLine(person.LastSeen);     //10/19/2015 8:40:15 PM    Kind = Local

person = JsonConvert.DeserializeObject<Person>(json, new JsonSerializerSettings { DateFormatHandling = DateFormatHandling.MicrosoftDateFormat });
Console.WriteLine(person.LastSeen);     //10/19/2015 8:40:15 PM    Kind = Local

person = JsonConvert.DeserializeObject<Person>(json, new JsonSerializerSettings { DateTimeZoneHandling = DateTimeZoneHandling.Utc });
Console.WriteLine(person.LastSeen);     //10/20/2015 00:40:15 PM    Kind = Utc

//In all three, the -0700 portion is being ignored. I'd like person.LastSeen to be 10/19/2015 17:40:15.

De nouveau, je pourrais juste savoir que l'API va me donner UTC+7 et de faire le réglage de moi-même pour obtenir la vraie UTC. Mais je me demandais si Json.NET a natif façon de gérer ce type de chaîne de date.

Avez-vous lu newtonsoft.com/json/help/html/DatesInJSON.htm ?
J'ai, en effet, et beaucoup de l'entourage de la documentation. J'ai trouvé beaucoup de choses au sujet de l'analyse d'une normal "Microsoft Format" date string Date(1445301615000), mais rien à propos de ce format particulier avec la -0700 décalage ajouté.

OriginalL'auteur Benjamin | 2015-10-19

  1. 6

    /Date(1445301615000-0700)/

    Qui est censé représenter une heure UTC 2015-10-19 17:40:15

    Désolé, c'est incorrect. L'heure UTC est 2015-10-20 00:45:15. Votre valeur correspond à la local temps, dans une zone avec un -07:00 décalage à cet instant.

    Dans ce tordu format, l'horodatage partie est toujours basé uniquement sur l'heure UTC. Le décalage est supplémentaire de l'information. Il ne change pas le timestamp. Vous pouvez donner un décalage différent, ou d'omettre entièrement et c'est toujours le même moment dans le temps.

    Toutes les conditions suivantes sont équivalentes, à l'égard de point-à-temps.

    /Date(1445301615000-0700)/
/Date(1445301615000)/
2015-10-20T00:40:15Z
2015-10-19T17:40:15-07:00

    Avis que, dans le format ISO, le décalage ne modifier la valeur, mais dans le MME format, il ne le fait pas.

    Il serait mieux si vous n'avez pas utilisé ce format ISO8601 est beaucoup plus saine choix pour JSON. Toutefois, si vous êtes coincé avec elle, alors il est préférable de ne pas le désérialiser un DateTime. Au lieu de cela, utilisez un DateTimeOffset.

    Considérer:

    string s = "\"/Date(1445301615000-0700)/\"";
DateTime dt = JsonConvert.DeserializeObject<DateTime>(s);
Console.WriteLine(dt.Kind); //Local

    Ce n'est pas bon. en gros, si il y a tout décalage, il pense que c'est votre fuseau horaire local, où il pourrait être, mais peut-être pas.

    string s = "\"/Date(1445301615000)/\"";
DateTime dt = JsonConvert.DeserializeObject<DateTime>(s);
Console.WriteLine(dt.Kind); //Utc

    C'est ok, mais vous avez perdu la trace de l'heure locale.

    string s = "\"/Date(1445301615000-0700)/\"";
DateTimeOffset dto = JsonConvert.DeserializeObject<DateTimeOffset>(s);
Console.WriteLine(dto); //10/19/2015 5:40:15 PM -07:00

    C'est beaucoup mieux. Et si vous souhaitiez un UTC DateTime, puis:

    string s = "\"/Date(1445301615000-0700)/\"";
DateTimeOffset dto = JsonConvert.DeserializeObject<DateTimeOffset>(s);
DateTime utc = dto.UtcDateTime;
Console.WriteLine(utc); //10/20/2015 12:40:15 AM

    Ainsi, la principale leçon est que, quel que soit le format, s'il y a décalage de fuseau horaire de l'information présente dans les données, puis les désérialiser à DateTimeOffset. Lors de l'utilisation DateTime pourrait de travail dans certains cas, vous demandez .NET pour interpréter le décalage et d'appliquer le comportement par défaut, qui, souvent, ne sera pas le souhaité comportement.

    Yep, je suis d'accord à 100% que les décideurs de l'API sont de détourner le format de la date. Je l'ai élevé comme un bogue avec eux, mais ne s'attendait pas grand chose... pour l'instant, dans leurs esprits,/Date(1445301615000-0700)/ = UTC 2015-10-19 17:40:15. Fou, je sais, mais d'où mes problèmes. Merci pour l'excellente explication, et la suggestion d'utiliser DateTimeOffset à la place. Je pense que ce sera la meilleure façon d'aller. Merci!
    Vous pourrait compenser de votre côté, mais alors quand ils ont corrigé le bug, alors vous aurez à vous détendre. Pour compenser, ne dto.UtcDateTime + dto.Offset. (ce qu'est un hack, en effet!) Point à ce post si ils ont besoin d'éclaircissements ou de leur donner mon e-mail. 🙂

    OriginalL'auteur Matt Johnson

  2. 3

    La -hhmm indique qu'une, heure locale, a été sérialisé, pas une heure UTC. .NET, comme beaucoup d'autres plates-formes, reconnaît le concept de fuseaux horaires. Dans .NET, par exemple, la DateTime classe a une propriété indiquant quel type de date/heure vous avez affaire. Vous pouvez construire explicitement la date/temps de différents types. Le débogueur est terrible pour ne pas le signaler, mais vous pouvez le voir avec le code suivant.

    var dt1 = new DateTime(2015, 01, 01, 00, 00, 00); //defaults to DateTimeKind.Unspecified
var dt2 = new DateTime(2015, 01, 01, 00, 00, 00, DateTimeKind.Local);
var dt3 = new DateTime(2015, 01, 01, 00, 00, 00, DateTimeKind.Utc);
var dt4 = new DateTime(2015, 01, 01, 00, 00, 00, DateTimeKind.Unspecified);
Debug.WriteLine(dt1.Kind); //writes "Unspecified"
Debug.WriteLine(dt2.Kind); //writes "Local"
Debug.WriteLine(dt3.Kind); //writes "Utc"
Debug.WriteLine(dt4.Kind); //writes "Unspecified"

    Ensuite, vous pouvez voir l'effet de la DateTimeKind a sur le Json avec le suivant

    //local time -- default datetime handling from JSON.NET
{
    var dateTime = DateTime.Now;
    var jsonObject = new JObject {["dateTime"] = dateTime};
    var jsonString = jsonObject.ToString();
    Debug.WriteLine(jsonString); //uses "2015-10-19T18:13:53.4698565-04:00" form
}
//UTC time -- default datetime handling from JSON.NET
{
    var dateTime = DateTime.Now.ToUniversalTime();
    var jsonObject = new JObject {["dateTime"] = dateTime };
    var jsonString = jsonObject.ToString();
    Debug.WriteLine(jsonString); //uses "2015-10-19T22:13:53.5166571Z" form
}
//local time -- Microsoft-like datetime handling from JSON.NET
{
    var dateTime = DateTime.Now;
    var jsonObject = new JObject {["dateTime"] = dateTime };
    var jsonString = JsonConvert.SerializeObject(jsonObject, new JsonSerializerSettings { DateFormatHandling = DateFormatHandling.MicrosoftDateFormat });
    Debug.WriteLine(jsonString); //uses "/Date(1445292833516-0400)/" format
}
//local time -- Microsoft-like datetime handling from JSON.NET
{
    var dateTime = DateTime.Now.ToUniversalTime();
    var jsonObject = new JObject {["dateTime"] = dateTime };
    var jsonString = JsonConvert.SerializeObject(jsonObject, new JsonSerializerSettings { DateFormatHandling = DateFormatHandling.MicrosoftDateFormat });
    Debug.WriteLine(jsonString); //uses "/Date(1445292833579)/" form
}
    Bonne info, merci. Bien sûr, dans mon cas, je suis en train de désérialiser plutôt que de sérialiser. Je crois réglage DateFormatHanding = MicrosoftDataFormat seulement affecte la façon dont json est écrit, et non pas comment il est lu. Je vais ajouter un exemple plus détaillé à ma question.
    C'est surtout la bonne info, même si je recommande de DateTime.UtcNow au lieu de DateTime.Now.ToUniversalTime(). Toutefois, il n'est pas tout à fait de l'adresse de la désérialisation préoccupation. Encore un +1.
    Compris. Je viens de la fourniture de l'arrière-plan sur la façon dont cette valeur a été là. A été en supposant que l'OP ne pouvait deviner le reste lui-même. 🙂

    OriginalL'auteur Michael Gunter