Imagine that you have the following interface:
public interface IProduct
{
int Id { get; set; }
decimal UnitPrice { get; set; }
}
This is an interface, and so may have a number of implementations; however, we know that every implementation will contain at least 2 fields, and what type they will be. If we wanted to serialise this, we’d probably write something like this:
private static string SerialiseProduct(IProduct product)
{
string json = JsonConvert.SerializeObject(product);
return json;
}
If you were to call this from a console app, it would work fine:
static void Main(string[] args)
{
IProduct product = new Product()
{
Id = 1,
UnitPrice = 12.3m
};
string json = SerialiseProduct(product);
Console.WriteLine(json);
Okay, so far so good. Now, let’s deserialise:
private static IProduct DeserialiseProduct(string json)
{
IProduct product = JsonConvert.DeserializeObject<IProduct>(json);
return product;
}
And let’s call it:
static void Main(string[] args)
{
IProduct product = new Product()
{
Id = 1,
UnitPrice = 12.3m
};
string json = SerialiseProduct(product);
Console.WriteLine(json);
IProduct product2 = DeserialiseProduct(json);
Console.WriteLine(product2.Id);
Console.ReadLine();
}
So, that runs fine:
Newtonsoft.Json.JsonSerializationException: ‘Could not create an instance of type SerialiseInterfaceJsonNet.IProduct. Type is an interface or abstract class and cannot be instantiated.
No.
Why?
The reason is that you can’t create an interface; for example:
That doesn’t even compile, but effectively, that’s what’s happening behind the scenes.
Converters
Json.Net allows the use of something called a converter. What that means is that I can inject functionality into the deserialisation process that tells Json.Net what to do with this interface. Here’s a possible converter for our class:
class ProductConverter : JsonConverter
{
public override bool CanConvert(Type objectType)
{
return (objectType == typeof(IProduct));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
return serializer.Deserialize(reader, typeof(Product));
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
serializer.Serialize(writer, value, typeof(Product));
}
}
It’s a relatively simple interface, you tell it how to identify your class, and then how to read and write the Json.
Finally, you just need to tell the converter to use this:
private static IProduct DeserialiseProduct(string json)
{
var settings = new JsonSerializerSettings();
settings.Converters.Add(new ProductConverter());
IProduct product = JsonConvert.DeserializeObject<IProduct>(json, settings);
return product;
}
By using the settings parameter.
References
http://www.jerriepelser.com/blog/custom-converters-in-json-net-case-study-1/