James Newton-King : Project, Json.NET

Json.NET 5.0 Release 5 – DefaultSettings and Extension Data

James Newton-King — Wed, 08 May 2013 09:56:05 GMT

DefaultSettings

If you have used Json.NET then you will be familiar with JsonSerializerSettings. This class has been an extremely successful at providing an simple way for developers to customize Json.NET.

With Json.NET’s increasing popularity and its use by more third party frameworks, a problem I have noticed is a developer has to customize serializer settings in multiple places. If you want your HtmlHelper.ToJson extension method, Web API services and SignalR to serialize JSON the same way across an application then you have to manually share a JsonSerializerSettings instance between them and figure out how each different framework allows you to customize Json.NET.

The solution I have come up with is to add global default settings. Set once with JsonConvert.DefaultSettings in an application, the default settings will automatically be used by all calls to JsonConvert.SerializeObject/DeserializeObject, and JToken.ToObject/FromObject. Any user supplied settings to these calls will override the default settings.

// settings will automatically be used by JsonConvert.SerializeObject/DeserializeObject

JsonConvert.DefaultSettings = () => new JsonSerializerSettings

    Formatting = Formatting.Indented,

    ContractResolver = new CamelCasePropertyNamesContractResolver()

};

Employee e = new Employee

    FirstName = "Eric",

    LastName = "Example",

    BirthDate = new DateTime(1980, 4, 20, 0, 0, 0, DateTimeKind.Utc),

    Department = "IT",

    JobTitle = "Web Dude"

};

string json = JsonConvert.SerializeObject(e);

// {

//   "firstName": "Eric",

//   "lastName": "Example",

//   "birthDate": "1980-04-20T00:00:00Z",

//   "department": "IT",

//   "jobTitle": "Web Dude"

// }

Because there are cases where JSON should not be customized, e.g. a Facebook or Twitter library, by default JsonSerializer won’t use DefaultSettings, providing an opt-out for those frameworks or for places in your application that shouldn’t use default settings. To create a JsonSerializer that does use them there is a new JsonSerializer.CreateDefault() method.

In the short term there will be some third party libraries that don’t use default settings that should, and some third party libraries that do use default settings that shouldn’t. If you encounter a situation where DefaultSettings doesn’t work for you then continue to customize Json.NET settings like you do today.

In the long term DefaultSettings will hopefully provide a simple, standard way to developers to customize JSON in .NET applications.

Extension Data

The second new feature in Json.NET 5.0 Release 5 is ~~copied~~ inspired by WCF’s IExtensibleDataObject.

Extension data is a JSON object’s values that aren’t matched to a .NET property during deserialization. By placing the JsonExtensionDataAttribute on a dictionary all unused values are automatically added to that dictionary and are accessible by you.

public class DirectoryAccount

  // normal deserialization

  public string DisplayName { get; set; }

  // these properties are set in OnDeserialized

  public string UserName { get; set; }

  public string Domain { get; set; }

  [JsonExtensionData]

  private IDictionary<string, JToken> _additionalData;

  [OnDeserialized]

  private void OnDeserialized(StreamingContext context)

    // SAMAccountName is not deserialized to any property

    // and so it is added to the extension data dictionary

    string samAccountName = (string)_additionalData["SAMAccountName"];

    Domain = samAccountName.Split('\\')[0];

    UserName = samAccountName.Split('\\')[1];

Changes

Here is a complete list of what has changed since Json.NET 5.0 Release 4.

New feature – Added global default serialization settings with JsonConvert.DefaultSettings
New feature – Added extension data support with JsonExtensionDataAttribute
New feature – Added NullValueHandling and DefaultValueHandling support to serializing dynamic types
Change – Changed some explicit interface methods on JArray to public to support use with ImpromtuInterface
Fix – Fixed deserializing non-ISO formatted date dictionary keys
Fix – Fixed values not being set when deserializing with DefaultValueHandling.IgnoreAndPopulate
Fix – Fixed deserializing with type named handling and assemblies loaded with Assembly.LoadFrom
Fix - Fixed deserializing Regexes when using StringEnumConverter
Fix – Fixed serializing and deserializing typed DataSets

Links

Json.NET CodePlex Project

Json.NET 5.0 Release 5 Download – Json.NET source code and assemblies

Json.NET 5.0 Release 4 – Performance

James Newton-King — Thu, 25 Apr 2013 08:24:18 GMT

This release of Json.NET ships with many performance improvements, and is over 30% faster serializing and deserializing JSON compared to Json.NET 4.5.

Json.NET extends its performance lead over DataContractJsonSerializer and continues to be significantly faster than JavaScriptSerializer which is used by ASP.NET MVC.

Compiled Expressions on Windows 8 and Windows Phone 8

An additional performance improvement specific to Windows 8 and Windows Phone 8 is the switch from the serializer internally using latebound reflection to compiled expressions. In exchange for a small one off cost the first time a type is serialized, compiled expressions are considerably faster than latebound reflection and provide an additional speed boost to Json.NET on Win8 and WP8.

Changes

Here is a complete list of what has changed since Json.NET 5.0 Release 1.

New feature - Added JsonWriter.SetWriteState to support inheritance from JsonWriter implementations
Change - Changed .NET 4.5 portable library and WinRT library to use compiled expressions reflection
Fix - Fixed error serializing non-generic types that implement IEnumerable<T>

Links

Json.NET CodePlex Project

Json.NET 5.0 Release 4 Download – Json.NET source code and assemblies

Json.NET 5.0 Release 1 – .NET 4.5, BigInteger, Read-Only Collections

James Newton-King — Sun, 07 Apr 2013 07:13:00 GMT

New and Updated Libraries

In Json.NET 5.0 there are a bunch of library version changes:

Added .NET 4.5 library
Added portable library targeting .NET 4.5 + WP8 + Win8
Removed the Silverlight library.
Removed the Windows Phone library

Upgrading library versions allows Json.NET to support new .NET features such as dynamic and async across more platforms.

A baseline portable class library still supports all platforms (.NET 4 + WP7 + SL5 + Win8) so have no fear Silverlight and Windows Phone developers, even though the dedicated libraries have been removed you can continue use the latest version of Json.NET on Silverlight/Windows Phone with a portable class library.

Note that the assembly version number of Json.NET 5.0 hasn't changed and is still 4.5.0.0 to avoid assembly redirect issues. Read more about assembly version numbers here.

Serializing NaN and Infinity Floating Point Values

Json.NET no longer serializes NaN and positive and negative infinity floating point values as symbols, which is invalid JSON. With 5.0 the new default is to serialize those values as strings, e.g. "NaN" instead of NaN. There is no change to serializing normal floating point numbers.

A FloatFormatHandling setting has been added so you can control how NaN and infinity values are serialized.

string json;

IList<double> d = new List<double> {1.1, double.NaN, double.PositiveInfinity};

json = JsonConvert.SerializeObject(d);

// [1.1,"NaN","Infinity"]

json = JsonConvert.SerializeObject(d, new JsonSerializerSettings {FloatFormatHandling = FloatFormatHandling.Symbol});

// [1.1,NaN,Infinity]

json = JsonConvert.SerializeObject(d, new JsonSerializerSettings {FloatFormatHandling = FloatFormatHandling.DefaultValue});

// [1.1,0.0,0.0]

BigInteger and Read-Only Collections

Json.NET 5.0 adds support for BigInteger. Now when reading and writing JSON there is no limit on the maximum size of integers Json.NET can handle.

There is also support for read-only collection interfaces (IReadOnlyList<T> and IReadOnlyDictionary<TKey, TValue>) which were added in .NET 4.5. As long as there is an IEnumerable<T> constructor then Json.NET will deserialize to the read-only collection for you.

string json = @"[

  9000000000000000000000000000000000000000000000001

]";

var l = JsonConvert.DeserializeObject<IReadOnlyList<BigInteger>>(json);

BigInteger nineQuindecillionAndOne = l[0];

// 9000000000000000000000000000000000000000000000001

Performance

There are many performance and memory improvements in Json.NET 5.0, especially when serializing and deserializing collections, and Json.NET in Windows 8 Store apps.

Changes

Here is a complete list of what has changed since Json.NET 4.5 Release 11.

New feature - Added .NET 4.5 library
New feature - Added portable library targeting .NET 4.5, Win8, WP8
New feature - Added Path to JToken
New feature - Added BigInteger support
New feature - Added IReadOnlyCollection<T> and IReadOnlyDictionary<TKey, TValue> support
New feature - Added FloatFormatHandling to JsonWriter/JsonSerializer/JsonSerializerSettings
New feature - Added DateFormatString to JsonWriter/JsonSerializer/JsonSerializerSettings
New feature - Added support for multiple serialization events and use base type serialization events
New feature - Added DeserializeAnonymousType overload with JsonSerializerSettings
New feature - Added support for specifying root type when serializing JSON with TypeNameHandling.Auto
New feature - Added support for creating lists and dictionaries with an IEnumerable<T> constructor
New feature - Added IConvertible support to JValue
New feature - Added support for serializing custom IConvertible values
New feature - Added support for deserializing IList
New feature - Added support for converting byte array JValues to Guid
New feature - Added support for deserializing byte arrays to Guid
Change - NaN and Infinity floating point values are serialized as strings by default
Change - Minor breaking changes to JsonSchema type
Change - Upgraded Windows Phone assembly to WP8
Change - DateTime IDictionary keys are now serialized in ISO date format
Change - DataContractAttribute is no longer inherited to match DataConctractSerializer behavior
Change - StringEnumConverter converts empty strings to null for nullable enums
Change - Guids serialize to a binary UUID in BSON instead of a string
Remove - Removed SL4 library
Remove - Removed WP7 library
Fix - Fixed JTokenWriter returning a null reference
Fix - Fixed static fields to no longer be included with fields serialization
Fix - Fixed recursively reading type wrapper objects when deserializing
Fix - Fixed incorrect namespace when converting XML to JSON
Fix - Fixed poor performance when serializing/deserialize dynamic objects
Fix - Fixed StringEnumConverter to throw JsonSerializerException on error
Fix - Fixed hidden properties not being serialized

Links

Json.NET CodePlex Project

Json.NET 5.0 Release 1 Download – Json.NET source code and assemblies

Json.NET 4.5 Release 11 - Serialization Tracing

James Newton-King — Tue, 20 Nov 2012 10:16:17 GMT

Serialization Tracing

The major new feature this release is serialization tracing. Using the ITraceWriter interface you can log and debug what is happening inside the Json.NET serializer when serializing and deserializing JSON.

Staff staff = new Staff();

staff.Name = "Arnie Admin";

staff.Roles = new List<string> { "Administrator" };

staff.StartDate = DateTime.Now;

ITraceWriter traceWriter = new MemoryTraceWriter();

JsonConvert.SerializeObject(

  staff,

  new JsonSerializerSettings { TraceWriter = traceWriter, Converters = { new JavaScriptDateTimeConverter() } });

Console.WriteLine(traceWriter);

// 2012-11-11T12:08:42.761 Info Started serializing Newtonsoft.Json.Tests.Serialization.Staff. Path ''.

// 2012-11-11T12:08:42.785 Info Started serializing System.DateTime with converter Newtonsoft.Json.Converters.JavaScriptDateTimeConverter. Path 'StartDate'.

// 2012-11-11T12:08:42.791 Info Finished serializing System.DateTime with converter Newtonsoft.Json.Converters.JavaScriptDateTimeConverter. Path 'StartDate'.

// 2012-11-11T12:08:42.797 Info Started serializing System.Collections.Generic.List`1[System.String]. Path 'Roles'.

// 2012-11-11T12:08:42.798 Info Finished serializing System.Collections.Generic.List`1[System.String]. Path 'Roles'.

// 2012-11-11T12:08:42.799 Info Finished serializing Newtonsoft.Json.Tests.Serialization.Staff. Path ''.

Json.NET has two implementations of ITraceWriter: MemoryTraceWriter which keeps messages in memory for simple debugging like the example above, and DiagnosticsTraceWriter which writes messages to any System.Diagnostics.TraceListeners your application is using.

To write messages using your existing logging framework implement a custom version of ITraceWriter.

Read more about trace writing here: Debugging with Serialization Tracing

JSON String Escaping

By default Json.NET only escapes control characters like new line when serializing text. New in this release is the StringEscapeHandling property on JsonTextWriter. Using StringEscapeHandling you can choose to escape HTML characters (<, >, &, ', ") or escape all non-ASCII characters.

JToken.ToObject Performance

The LINQ to JSON JToken class has a ToObject method on it for converting the JSON token to a .NET type. In previous versions of Json.NET this method always used the JsonSerializer behind the scenes to do the conversion which was unnecessary for converting simple types like strings, numbers, booleans, dates, etc.

Json.NET 4.5 Release 11 now checks whether the object being converted to is a simple type and if so it skips using the JsonSerializer. The end result is ToObject is now 400% faster for most types.

Changes

Here is a complete list of what has changed since Json.NET 4.5 Release 10.

New feature - Added ITraceWriter, MemoryTraceWriter, DiagnosticsTraceWriter
New feature - Added StringEscapeHandling with options to escape HTML and non-ASCII characters
New feature - Added non-generic JToken.ToObject methods
New feature - Deserialize ISet<T> properties as HashSet<T>
New feature - Added implicit conversions for Uri, TimeSpan, Guid
New feature - Missing byte, char, Guid, TimeSpan and Uri explicit conversion operators added to JToken
New feature - Special case so Version type is correctly deserialized
Change - Silverlight and Windows Phone assemblies in NuGet are strong named again
Change - Improved CamelCasePropertyNamesContractResolver camel casing property names
Change – Explicit JValue conversions are more flexible when converting values
Fix - Fixed QuoteChar not being used when writing DateTimes, TimeSpans, Uris and Guids
Fix - Fixed JValue constructors for Uri, TimeSpan, Guid assigning incorrect JTokenType
Fix - Fixed ReferenceLoopHandling not being used when serializing ISerializable and dynamic values
Fix - Fixed potential null reference error when getting attributes
Fix - Fixed .NET 2.0 build incorrectly referencing DateTimeOffset

Links

Json.NET CodePlex Project

Json.NET 4.5 Release 11 Download – Json.NET source code and assemblies

Json.NET 4.5 Release 10 – Portable Class Library on NuGet

James Newton-King — Mon, 08 Oct 2012 06:18:41 GMT

Json.NET's major new feature this release is the portable class library assembly is available over NuGet. This is made possible by NuGet 2.1 supporting portable class libraries. Read more about NuGet 2.1 here.

Case insensitive JObject GetValue and TryGetValue

To simplify getting property values without worrying about the property name's case a couple of helper methods have been added to JObject. GetValue and TryGetValue will first attempt to get a property value with the exact case after which it will ignore case and the first matching property will be returned.

JObject o = JObject.Parse(@"{

  'name': 'Lower',

  'NAME': 'Upper'

}");

string exactMatch = (string)o.GetValue("NAME", StringComparison.OrdinalIgnoreCase);

// Upper

string ignoreCase = (string)o.GetValue("Name", StringComparison.OrdinalIgnoreCase);

// Lower

In this example the first call to GetValue with "NAME" exactly matches the second property. The second call to GetValue with "Name" doesn’t exactly match any of the properties so a case insensitive search is made and the first property is returned.

Changes

Here is a complete list of what has changed since Json.NET 4.5 Release 9.

New feature - Added Portable build to NuGet package
New feature - Added GetValue and TryGetValue with StringComparison to JObject
Change - Improved duplicate object reference id error message
Fix - Fixed error when comparing empty JObjects
Fix - Fixed SecAnnotate warnings
Fix - Fixed error when comparing DateTime JValue with a DateTimeOffset JValue
Fix - Fixed serializer sometimes not using DateParseHandling setting
Fix - Fixed error in JsonWriter.WriteToken when writing a DateTimeOffset
Fix - Fixed error when serializing emitted classes that have null constructor parameter names
Fix - Fixed empty strings not correctly deserializing as null onto nullable properties

Links

Json.NET CodePlex Project

Json.NET 4.5 Release 10 Download – Json.NET source code and assemblies