Casting interfaces for deserialization in JSON NET

Question

I am trying to set up a reader that will take in JSON objects from various websites  think information scraping  and translate them into C  objects   I am currently using JSON NET for the deserialization process   The problem I am running into is that it does not know how to handle interface-level properties in a class   So something of the nature   public IThingy Thing   Will produce the error      Could not create an instance of type IThingy  Type is an interface or abstract class and cannot be instantiated    It is relatively important to have it be an IThingy as opposed to a Thingy since the code I am working on is considered sensitive and unit testing is highly important   Mocking of objects for atomic test scripts is not possible with fully-fledged objects like Thingy   They must be an interface   I ve been poring over JSON NET s documentation for a while now  and the questions I could find on this site related to this are all from over a year ago   Any help   Also  if it matters  my app is written in  NET 4 0

User · Answer

My solution was added the interface elements in the constructor   public class Customer  ICustomer       public Customer Details details             Details   details                JsonProperty  Details  NullValueHnadling   NullValueHandling Ignore        public IDetails Details  get  set

User · Answer

Use this JsonKnownTypes  it s very similar way to use  it just add discriminator to json    JsonConverter typeof JsonKnownTypeConverter lt Interface1 gt      JsonKnownType typeof MyClass    myClass    public interface Interface1      public class MyClass   Interface1       public string Something      Now when you serialize object in json will be add   type  with  myClass  value and it will be use for deserialize  Json     Something   something     type   derived

User · Answer

Suppose an autofac setting like the following   public class AutofacContractResolver   DefaultContractResolver       private readonly IContainer  container       public AutofacContractResolver IContainer container                 container   container             protected override JsonObjectContract CreateObjectContract Type objectType                JsonObjectContract contract   base CreateObjectContract objectType               use Autofac to create types that have been registered with it         if   container IsRegistered objectType                        contract DefaultCreator        gt   container Resolve objectType                        return contract            Then  suppose your class is like this    public class TaskController       private readonly ITaskRepository  repository      private readonly ILogger  logger       public TaskController ITaskRepository repository  ILogger logger                 repository   repository           logger   logger             public ITaskRepository Repository               get   return  repository               public ILogger Logger               get   return  logger              Therefore  the usage of the resolver in deserialization could be like   ContainerBuilder builder   new ContainerBuilder    builder RegisterType lt TaskRepository gt    As lt ITaskRepository gt     builder RegisterType lt TaskController gt     builder Register c   gt  new LogService new DateTime 2000  12  12    As lt ILogger gt      IContainer container   builder Build     AutofacContractResolver contractResolver   new AutofacContractResolver container    string json              Logger              Level   Debug                  ITaskRespository and ILogger constructor parameters are injected by Autofac  TaskController controller   JsonConvert DeserializeObject lt TaskController gt  json  new JsonSerializerSettings       ContractResolver   contractResolver      Console WriteLine controller Repository GetType   Name     You can see more details in http   www newtonsoft com json help html DeserializeWithDependencyInjection htm

User · Answer

Use this class  for mapping abstract type to real type  public class AbstractConverter lt TReal  TAbstract gt         JsonConverter where TReal   TAbstract       public override Boolean CanConvert Type objectType            gt  objectType    typeof TAbstract        public override Object ReadJson JsonReader reader  Type type  Object value  JsonSerializer jser            gt  jser Deserialize lt TReal gt  reader        public override void WriteJson JsonWriter writer  Object value  JsonSerializer jser            gt  jser Serialize writer  value         and when deserialize  var settings   new JsonSerializerSettings       Converters             new AbstractConverter lt Thing  IThingy gt             new AbstractConverter lt Thing2  IThingy2 gt               JsonConvert DeserializeObject json  type  settings

User · Answer

Nicholas Westby provided a great solution in a awesome article   If you want Deserializing JSON to one of many possible classes that implement an interface like that   public class Person       public IProfession Profession   get  set       public interface IProfession       string JobTitle   get       public class Programming   IProfession       public string JobTitle   gt   Software Developer       public string FavoriteLanguage   get  set       public class Writing   IProfession       public string JobTitle   gt   Copywriter       public string FavoriteWord   get  set       public class Samples       public static Person GetProgrammer                 return new Person                         Profession   new Programming                                 FavoriteLanguage    C                                      You can use a custom JSON converter   public class ProfessionConverter   JsonConverter       public override bool CanWrite   gt  false      public override bool CanRead   gt  true      public override bool CanConvert Type objectType                return objectType    typeof IProfession             public override void WriteJson JsonWriter writer          object value  JsonSerializer serializer                throw new InvalidOperationException  Use default serialization                public override object ReadJson JsonReader reader          Type objectType  object existingValue          JsonSerializer serializer                var jsonObject   JObject Load reader           var profession   default IProfession           switch  jsonObject  JobTitle   Value                          case  Software Developer                   profession   new Programming                    break              case  Copywriter                   profession   new Writing                    break                    serializer Populate jsonObject CreateReader    profession           return profession            And you will need to decorate the  Profession  property with a JsonConverter attribute to let it know to use your custom converter       public class Person                JsonConverter typeof ProfessionConverter            public IProfession Profession   get  set            And then  you can cast your class with an Interface   Person person   JsonConvert DeserializeObject lt Person gt  jsonString

User · Answer

SamualDavis provided a great solution in a related question  which I ll summarize here   If you have to deserialize a JSON stream into a concrete class that has interface properties  you can include the concrete classes as parameters to a constructor for the class   The NewtonSoft deserializer is smart enough to figure out that it needs to use those concrete classes to deserialize the properties     Here is an example   public class Visit   IVisit            lt summary gt          This constructor is required for the JSON deserializer to be able         to identify concrete classes to use when deserializing the interface properties           lt  summary gt      public Visit MyLocation location  Guest guest                Location   location          Guest   guest            public long VisitId   get  set        public ILocation Location   get   set        public DateTime VisitDate   get  set        public IGuest Guest   get  set

User · Answer

To enable deserialization of multiple implementations of interfaces  you can use JsonConverter  but not through an attribute   Newtonsoft Json JsonSerializer serializer   new Newtonsoft Json JsonSerializer    serializer Converters Add new DTOJsonConverter     Interfaces IEntity entity   serializer Deserialize jsonReader     DTOJsonConverter maps each interface with a concrete implementation   class DTOJsonConverter   Newtonsoft Json JsonConverter       private static readonly string ISCALAR FULLNAME   typeof Interfaces IScalar  FullName      private static readonly string IENTITY FULLNAME   typeof Interfaces IEntity  FullName        public override bool CanConvert Type objectType                if  objectType FullName    ISCALAR FULLNAME                objectType FullName    IENTITY FULLNAME                        return true                    return false             public override object ReadJson Newtonsoft Json JsonReader reader  Type objectType  object existingValue  Newtonsoft Json JsonSerializer serializer                if  objectType FullName    ISCALAR FULLNAME              return serializer Deserialize reader  typeof DTO ClientScalar            else if  objectType FullName    IENTITY FULLNAME              return serializer Deserialize reader  typeof DTO ClientEntity             throw new NotSupportedException string Format  Type  0  unexpected    objectType               public override void WriteJson Newtonsoft Json JsonWriter writer  object value  Newtonsoft Json JsonSerializer serializer                serializer Serialize writer  value             DTOJsonConverter is required only for the deserializer  The serialization process is unchanged  The Json object do not need to embed concrete types names   This SO post offers the same solution one step further with a generic JsonConverter

User · Answer

I found this useful  You might too    Example Usage  public class Parent        JsonConverter typeof InterfaceConverter lt IChildModel  ChildModel gt         IChildModel Child   get  set        Custom Creation Converter  public class InterfaceConverter lt TInterface  TConcrete gt    CustomCreationConverter lt TInterface gt      where TConcrete   TInterface  new         public override TInterface Create Type objectType                return new TConcrete              Json NET documentation

User · Answer

Two things you might try   Implement a try parse model   public class Organisation     public string Name   get  set        JsonConverter typeof RichDudeConverter      public IPerson Owner   get  set       public interface IPerson     string Name   get  set       public class Tycoon   IPerson     public string Name   get  set       public class Magnate   IPerson     public string Name   get  set      public string IndustryName   get  set       public class Heir  IPerson     public string Name   get  set      public IPerson Benefactor   get  set       public class RichDudeConverter   JsonConverter     public override bool CanConvert Type objectType          return  objectType    typeof IPerson           public override object ReadJson JsonReader reader  Type objectType  object existingValue  JsonSerializer serializer             pseudo-code     object richDude   serializer Deserialize lt Heir gt  reader        if  richDude    null                richDude   serializer Deserialize lt Magnate gt  reader              if  richDude    null                richDude   serializer Deserialize lt Tycoon gt  reader              return richDude         public override void WriteJson JsonWriter writer  object value  JsonSerializer serializer             Left as an exercise to the reader        throw new NotImplementedException            Or  if you can do so in your object model  implement a concrete base class between IPerson and your leaf objects  and deserialize to it     The first can potentially fail at runtime  the second requires changes to your object model and homogenizes the output to the lowest common denominator

User · Answer

My solution to this one  which I like because it is nicely general  is as follows        lt summary gt      Automagically convert known interfaces to  specific  concrete classes on deserialisation      lt  summary gt  public class WithMocksJsonConverter   JsonConverter            lt summary gt          The interfaces I know how to instantiate mapped to the classes with which I shall instantiate them  as a Dictionary           lt  summary gt      private readonly Dictionary lt Type Type gt  conversions   new Dictionary lt Type Type gt                 typeof IOne   typeof MockOne               typeof ITwo   typeof MockTwo               typeof IThree   typeof MockThree               typeof IFour   typeof MockFour                     lt summary gt          Can I convert an object of this type           lt  summary gt           lt param name  objectType  gt The type under consideration lt  param gt           lt returns gt True if I can convert the type under consideration  else false  lt  returns gt      public override bool CanConvert Type objectType                return conversions Keys Contains objectType                   lt summary gt          Attempt to read an object of the specified type from this reader           lt  summary gt           lt param name  reader  gt The reader from which I read  lt  param gt           lt param name  objectType  gt The type of object I m trying to read  anticipated to be one I can convert  lt  param gt           lt param name  existingValue  gt The existing value of the object being read  lt  param gt           lt param name  serializer  gt The serializer invoking this request  lt  param gt           lt returns gt An object of the type into which I convert the specified objectType  lt  returns gt      public override object ReadJson JsonReader reader  Type objectType  object existingValue  JsonSerializer serializer                try                       return serializer Deserialize reader  this conversions objectType                      catch  Exception                        throw new NotSupportedException string Format  Type  0  unexpected    objectType                              lt summary gt          Not yet implemented           lt  summary gt           lt param name  writer  gt The writer to which I would write  lt  param gt           lt param name  value  gt The value I am attempting to write  lt  param gt           lt param name  serializer  gt the serializer invoking this request  lt  param gt      public override void WriteJson JsonWriter writer  object value  JsonSerializer serializer                throw new NotImplementedException                 You could obviously and trivially convert it into an even more general converter by adding a constructor which took an argument of type Dictionary lt Type Type gt  with which to instantiate the conversions instance variable

User · Answer

For those that might be curious about the ConcreteListTypeConverter that was referenced by Oliver  here is my attempt   public class ConcreteListTypeConverter lt TInterface  TImplementation gt    JsonConverter where TImplementation   TInterface        public override bool CanConvert Type objectType                return true             public override object ReadJson JsonReader reader  Type objectType  object existingValue  JsonSerializer serializer                var res   serializer Deserialize lt List lt TImplementation gt  gt  reader           return res ConvertAll x   gt   TInterface  x              public override void WriteJson JsonWriter writer  object value  JsonSerializer serializer                serializer Serialize writer  value

User · Answer

Why use a converter  There is a native functionality in Newtonsoft Json to solve this exact problem   Set TypeNameHandling in the JsonSerializerSettings to TypeNameHandling Auto  JsonConvert SerializeObject    toSerialize    new JsonSerializerSettings           TypeNameHandling   TypeNameHandling Auto         This will put every type into the json  that is not held as a concrete instance of a type but as an interface or an abstract class   Make sure that you are using the same settings for serialization and deserialization   I tested it  and it works like a charm  even with lists   Search Results Web result with site links     WARNING   Only use this for json from a known and trusted source  User snipsnipsnip correctly mentioned that this is indeed a vunerability   See CA2328 and SCS0028 for more information     Source and an alternative manual implementation  Code Inside Blog

User · Answer

For what it s worth  I ended up having to handle this myself for the most part   Each object has a Deserialize string jsonStream  method   A few snippets of it   JObject parsedJson   this ParseJson jsonStream   object thingyObjectJson    object parsedJson  thing    this Thing   new Thingy Convert ToString thingyObjectJson      In this case  new Thingy string  is a constructor that will call the Deserialize string jsonStream  method of the appropriate concrete type   This scheme will continue to go downward and downward until you get to the base points that json NET can just handle   this Name    string parsedJson  name    this CreatedTime   DateTime Parse  string parsedJson  created time       So on and so forth   This setup allowed me to give json NET setups it can handle without having to refactor a large part of the library itself or using unwieldy try parse models that would have bogged down our entire library due to the number of objects involved   It also means that I can effectively handle any json changes on a specific object  and I do not need to worry about everything that object touches   It s by no means the ideal solution  but it works quite well from our unit and integration testing

User · Answer

No object will ever be an IThingy as interfaces are all abstract by definition   The object you have that was first serialized was of some concrete type  implementing the abstract interface  You need to have this same concrete class revive the serialized data   The resulting object will then be of some type that implements the abstract interface you are looking for   From the documentation it follows that you can use   Thingy JsonConvert DeserializeObject jsonString  typeof Thingy      when deserializing to inform JSON NET about the concrete type

User · Answer

Several years on and I had a similar issue  In my case there were heavily nested interfaces and a preference for generating the concrete classes at runtime so that It would work with a generic class   I decided to create a proxy class at run time that wraps the object returned by Newtonsoft   The advantage of this approach is that it does not require a concrete implementation of the class and can handle any depth of nested interfaces automatically  You can see more about it on my blog   using Castle DynamicProxy  using Newtonsoft Json Linq  using System  using System Reflection   namespace LL Utilities Std Json       public static class JObjectExtension               private static ProxyGenerator  generator   new ProxyGenerator             public static dynamic toProxy this JObject targetObject  Type interfaceType                         return  generator CreateInterfaceProxyWithoutTarget interfaceType  new JObjectInterceptor targetObject                       public static InterfaceType toProxy lt InterfaceType gt  this JObject targetObject                         return toProxy targetObject  typeof InterfaceType                          Serializable      public class JObjectInterceptor   IInterceptor               private JObject  target           public JObjectInterceptor JObject target                         target   target                    public void Intercept IInvocation invocation                         var methodName   invocation Method Name              if invocation Method IsSpecialName  amp  amp  methodName StartsWith  get                                   var returnType   invocation Method ReturnType                  methodName   methodName Substring 4                    if   target    null     target methodName     null                                        if  returnType GetTypeInfo   IsPrimitive    returnType Equals typeof string                                                   invocation ReturnValue   null                          return                                                            if  returnType GetTypeInfo   IsPrimitive    returnType Equals typeof string                                          invocation ReturnValue    target methodName  ToObject returnType                                     else                                       invocation ReturnValue     JObject  target methodName   toProxy returnType                                               else                               throw new NotImplementedException  Only get accessors are implemented in proxy                                          Usage   var jObj   JObject Parse input   InterfaceType proxyObject   jObj toProxy lt InterfaceType gt

User · Answer

Copied from this question   In cases where I have not had control over the incoming JSON  and so cannot ensure that it includes a  type property  I have written a custom converter that just allows you to explicitly specify the concrete type   public class Model        JsonConverter typeof ConcreteTypeConverter lt Something gt         public ISomething TheThing   get  set        This just uses the default serializer implementation from Json Net whilst explicitly specifying the concrete type   An overview are available on this blog post   Source code is below   public class ConcreteTypeConverter lt TConcrete gt    JsonConverter       public override bool CanConvert Type objectType                  assume we can convert to anything for now         return true             public override object ReadJson JsonReader reader  Type objectType  object existingValue  JsonSerializer serializer                  explicitly specify the concrete type we want to create         return serializer Deserialize lt TConcrete gt  reader              public override void WriteJson JsonWriter writer  object value  JsonSerializer serializer                  use the default serialization - it works fine         serializer Serialize writer  value

[c#] Casting interfaces for deserialization in JSON.NET

Examples related to c#

Examples related to .net

Examples related to json

Examples related to json.net