JavaScriptSerializer nicht Deserialisieren DateTime/TimeSpan Richtig

Habe ein problem, wo DateTime/TimeSpan scheint nicht zu Deserialisieren korrekt mit JavaScriptSerializer.
Wenn ich das Objekt wieder nach dem Deserialisieren die Zeitspanne ist leer und wenn ich mit DateTime-dann sind das mal alle aus dem Gleichgewicht geraten.
Habe Artikel zu finden, aber es hat nicht wirklich helfen, mir zu viel.
http://www.west-wind.com/weblog/ShowPost.aspx?id=471402

Jemand irgendwelche Ideen? Sollte ich vielleicht versuchen die json.net Bibliothek?

public class JsonFilter : ActionFilterAttribute
{
    public string Param { get; set; }
    public Type JsonDataType { get; set; }
    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        if (filterContext.HttpContext.Request.ContentType.Contains("application/json"))
        {
            string inputContent;
            using (var sr = new StreamReader(filterContext.HttpContext.Request.InputStream))
            {
                inputContent = sr.ReadToEnd();
            }

            JavaScriptSerializer serializer = new JavaScriptSerializer();
            var result = serializer.Deserialize(inputContent, JsonDataType);
            filterContext.ActionParameters[Param] = result;
        }
    }
}

public class RosterItem
{
    public RosterItem()
    {
        comments = new List<Form.Comment>();
    }
    public Boolean dirty { get; set; }
    public int id { get; set; }
    public int staffId { get; set; }
    public String description { get; set; }
    public int activityId { get; set; }
    public DateTime date { get; set; }
    public TimeSpan startTime { get; set; }
    public TimeSpan endTime { get; set; }
    public List<Form.Comment> comments { get; set; }
}

    [JsonFilter(Param = "rosterItem", JsonDataType = typeof(RosterItem))]
    public int SaveRosterEntry(RosterItem rosterItem)
    {
        RosterEntry rosterEntry = rosterEntryRepository.GetRosterEntry(rosterItem.id);
        if (rosterEntry == null)
        {
            rosterEntry = new RosterEntry();
            rosterEntryRepository.Add(rosterEntry);
        }
        rosterEntry.ActivityID = rosterItem.activityId;
        rosterEntry.StartTime = rosterItem.startTime;
        rosterEntry.EndTime = rosterItem.endTime;
        rosterEntry.RosterDate = rosterItem.date;
        rosterEntry.RosterEmployeeID = rosterItem.staffId;            
        rosterEntryRepository.Save();
        return rosterEntry.RosterEntryID;
    }
InformationsquelleAutor AllBlacks3Peat | 2010-12-08
  1. 3

    Fand ich die Antwort in dem folgenden Beitrag auf GitHub:

    https://github.com/NancyFx/Nancy/issues/336

    Im Grunde war die Antwort: zum erstellen einer neuen TimeSpanJsonConverter erbt JavaScriptConverter - und dann passieren, dass eine Instanz der serializer-Klasse:

    var serializer = new System.Web.Script.Serialization.JavaScriptSerializer()
serializer.RegisterConverters(new[] { new TimeSpanJsonConverter() });

    Die vollständige Klasse für die Referenz ist (geschrieben von GrumpyDev):

    public class TimeSpanJsonConverter : JavaScriptConverter
{
    public override IEnumerable<Type> SupportedTypes
    {
        get
        {
            return new[] { typeof(TimeSpan) };
        }
    }

    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        return new TimeSpan(
            this.GetValue(dictionary, "days"),
            this.GetValue(dictionary, "hours"),
            this.GetValue(dictionary, "minutes"),
            this.GetValue(dictionary, "seconds"),
            this.GetValue(dictionary, "milliseconds"));
    }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {
        var timeSpan = (TimeSpan)obj;

        var result = new Dictionary<string, object>
            {
                { "days", timeSpan.Days },
                { "hours", timeSpan.Hours },
                { "minutes", timeSpan.Minutes },
                { "seconds", timeSpan.Seconds },
                { "milliseconds", timeSpan.Milliseconds }
            };

        return result;
    }

    private int GetValue(IDictionary<string, object> dictionary, string key)
    {
        const int DefaultValue = 0;

        object value;
        if (!dictionary.TryGetValue(key, out value))
        {
            return DefaultValue;
        }

        if (value is int)
        {
            return (int)value;
        }

        var valueString = value as string;
        if (valueString == null)
        {
            return DefaultValue;
        }

        int returnValue;
        return !int.TryParse(valueString, out returnValue) ? DefaultValue : returnValue;
    }
}
    • Die Lösung ist für die Lösung TimeSpan-Serialisierung, aber ich denke, das Problem mit DateTime.
    InformationsquelleAutor Dan Diplo
  2. 0

    Wird dies das Problem lösen, wenn Sie jemals das gleiche problem haben.

    http://blog.devarchive.net/2008/02/serializing-datetime-values-using.html

    Alle DateTime-Objekte müssen explizit angegeben werden als UTC.

    InformationsquelleAutor AllBlacks3Peat
Schreibe einen Kommentar