Table of Contents
Handling DateTime string-serialized values is often annoying when you're working on a multi-language project, especially when you're working with string-based data formats such as XML, CSV, JSON and such. Luckily enough, almost every programming language/framework can provide some native method - or third-party tool - that can solve these issues for you: for .NET and JSON, the most widely used is the exceptional Json.NET by Newtonsoft library, providing unvaluable features such as the SerializeObject and DeserializeObject methods which allows the developer to serialize-deserialize classes of (almost) any kind with ease.
For an extensive guide to Json.NET you can browse the official documentation, full of useful and easy-to-understand samples. In this post, assuming you already know how to effectively use the tool, I'll talk about a specific DateTime scenario: how to properly de-serialize a JSON input string containing one or more DateTime string representations written in either non-standard format, empty string or null value.
The Problem
Let's take the following JSON:
|
1 2 3 4 5 6 |
{ "Created": "20151217", "LastModified": "2015/12/18", "Published": "", "Deleted": null } |
Here's a perfect example of bad-generated JSON. I personally hate these kind of scenarios: not only we have two very different date formats (yyyyMMdd and yyyy/MM/dd), we also get some empty and null values instead of actual dates. Sadly, we can't be sure it won't be like that when you don't have control on the Json file itself. When it happens, let's see how we could de-serialize this Json in the following C# class:
|
1 2 3 4 5 6 7 8 9 10 11 |
public class MyDates { public MyDates() { } public DateTime Created { get; set; } public DateTime LastModified { get; set; } public DateTime? Published { get; set; } public DateTime? Deleted { get; set; } } |
As we can easily see, the MyDates class features 4 properties: two DateTime types and two DateTime? nullable types: if we were looking for a way to handle that badly-formatted Json, this can be a good start. However, should we try to use Json.NET to de-serialize the above Json like we did before, we would receive the following error:
ERROR: System.FormatException: String was not recognized as a valid DateTime.
The reason for that is easily understandable: those non-standard date formats and empty-string values are not supported by the default DateTimeConverter, which is expecting something like Date(1198908717056) instead.
The Solution
A very viable way to fix the issue is providing ourselves with a custom CustomDateTimeConverter, a tailor-made class where we can put all the rules we need to properly convert/de-serialize the various date and/or time formats we can possibly expect to receive, including non-standard formats, arbitrary formats, empty strings, null values and basically anything else.
Here's the CustomDateTimeConverter class that I'm using for most of my projects:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
using Newtonsoft.Json; using Newtonsoft.Json.Converters; using System; using System.Collections.Generic; using System.Globalization; using System.Linq; using System.Web; /// <summary> /// Custom converter for Json.Net to handle multiple datetime string format. /// </summary> public class CustomDateTimeConverter : DateTimeConverterBase { public static string[] DefaultInputFormats = new[] { "yyyyMMdd", "yyyy/MM/dd", "dd/MM/yyyy", "dd-MM-yyyy", "yyyyMMddHHmmss", "yyyy/MM/dd HH:mm:ss", "dd/MM/yyyy HH:mm:ss", "dd-MM-yyyy HH:mm:ss" }; public static string DefaultOutputFormat = "yyyyMMdd"; public static bool DefaultEvaluateEmptyStringAsNull = true; private string[] InputFormats = DefaultInputFormats; private string OutputFormat = DefaultOutputFormat; private bool EvaluateEmptyStringAsNull = DefaultEvaluateEmptyStringAsNull; public CustomDateTimeConverter() { } public CustomDateTimeConverter(string[] inputFormats, string outputFormat, bool evaluateEmptyStringAsNull = true) { if (inputFormats != null) InputFormats = inputFormats; if (outputFormat != null) OutputFormat = outputFormat; EvaluateEmptyStringAsNull = evaluateEmptyStringAsNull; } public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { string v = (reader.Value != null) ? reader.Value.ToString() : null; try { // The following line grants Nullable DateTime support. We will return (DateTime?)null if the Json property is null. if (String.IsNullOrEmpty(v) && Nullable.GetUnderlyingType(objectType) != null) { // If EvaluateEmptyStringAsNull is true an empty string will be treated as null, // otherwise we'll let DateTime.ParseExactwill throw an exception in a couple lines. if (v == null || EvaluateEmptyStringAsNull) return null; } return DateTime.ParseExact(v, InputFormats, CultureInfo.InvariantCulture, DateTimeStyles.None); } catch (Exception e) { throw new NotSupportedException(String.Format("ERROR: Input value '{0}' is not parseable using the following supported formats: {1}", v, string.Join(",", InputFormats))); } } public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { writer.WriteValue(((DateTime)value).ToString(OutputFormat)); } } |
As soon as you place the above code within a CustomDateTimeConverter.cs and add it to your project, you can use the class in the following way:
|
1 |
MyDates md = JsonConvert.DeserializeObject<MyDates>(json, new CustomDateTimeConverter()); |
As we can see by looking at the code, the class has been setup to accept the most common formats and to treat empty string values as they were null. It also provides an extended constructor that can accept a custom string, that can be used to handle any datetime format not included in the DefaultImputFormats array.
That's it for now: happy (de)serialization!
