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

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

I do a lot of Azure development. While it is a great platform for setting up new environments, scaling instances and simple deployments; monitoring applications in Azure is difficult. It is a remote environment and because of the way Azure abstracts hosting for you there is no option to install your own software on the server.

Foglight for Azure Apps is a hosted service that sets up gathering information from Windows Azure for you. In this blog post I'm going to try out Foglight with a demo application I've put together for simulating a broken website (demo source code available at the end of the blog post).

Getting Started

Setting up Foglight for Azure Apps is really simple. Foglight has two configuration methods for adding an Azure deployment: manual configuration where you manually add details about each deployment you want to monitor, and automatic discovery where Foglight retrieves that information from Azure for you. I'm going to step through using the automatic discovery wizard.

With Foglight automatic discovery the only information you need is your role’s Azure Subscription ID. Subscription IDs can be found in the Windows Azure Management Portal by browsing to Settings -> Management Certificates.

The next step after copy/pasting your Subscription ID is to add a management certificate from Foglight to Azure. The download link for the certificate is in the wizard and it is uploaded in the same place where you got your Subscription ID.

Finally select the deployment you want to monitor and you’re finished.

Monitoring

The core of Foglight for Azure Apps are the monitors it provides to measure the health of your application. The first page you’ll come upon after setup is the dashboard which provides a nice summary of the state of your application. From this screen or from the menu you can drill into more detail about each monitor.

The availability page shows you whether your application is accessible from various locations around the world – useful for times when a user or users from a country report they can’t access your application. In the screenshot above I've activated server errors on my demo website which you can see showing up in orange in the availability graphs.

The health page lets you view health details about individual rolls in your application. Here you can see details like CPU, memory and disk usage, and HTTP traffic and bandwidth being used by each role. One nice feature here is Foglight aggregates everything together and provides an indication of whether the application is healthy or not. Seeing the health of an application in a graph over time lets you match user reported errors with past server problems. In the screenshot above I've active high CPU and memory usage in my demo application.

The services page shows the status of the Windows Azure services your application depends on (e.g. compute, databases, storage) in your application's region and the status of worldwide services (e.g. management portal, CDN). This is a useful tool when debugging a broken application to double check whether the issue is yours or is being caused by a problem in Azure infrastructure.

The top URLs page shows what URLs in an application are creating problems. URLs can either be the slowest pages in your application or the pages with the highest number of 404 and server errors.

Configuring Health and Alerts

An awesome feature of Foglight is the control you have over configuring health thresholds and sending alerts.

Once you're happy with the health thresholds (the screenshot above shows the default) you can then configure at what health level alerts should be emailed and who they should be emailed to.

Health alerts are one of the most important features when monitoring, letting you know about problems as soon as they happen rather than waiting until someone look at Foglight or hear about errors from your users.

One thing I’ve done in the past with errors is to send an SMS message to my phone. Foglight doesn’t have built in SMS support but it is simple to set up using IFTTT.

Wrapping Up

I found Foglight's monitoring easy to understand and fast to update. Really impressive is how simple Foglight is to setup, taking just a couple of minutes and requiring no changes to your application. Finally the Foglight’s health alerts will ensure you know about critical issues as they happen.

If you're deploying applications to Azure and it is important they are rock solid then I recommend you check Foglight for Azure Apps out.

Click here to download the Windows Azure JsonFormat application source code

Disclosure of Material Connection: I received one or more of the products or services mentioned above for free in the hope that I would mention it on my blog. Regardless, I only recommend products or services I use personally and believe my readers will enjoy. I am disclosing this in accordance with the Federal Trade Commission’s 16 CFR, Part 255: Guides Concerning the Use of Endorsements and Testimonials in Advertising.

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