Casting-Schnittstellen für die Deserialisierung in JSON.NET

Ich versuche, einen Reader einzurichten, der JSON-Objekte von verschiedenen Websites aufnimmt (Think Information Scraping) und sie in C # -Objekte übersetzt. Ich verwende derzeit JSON.NET für den Deserialisierungsprozess. Das Problem, auf das ich stoße, ist, dass es nicht weiß, wie man Eigenschaften auf Schnittstellenebene in einer Klasse behandelt. Also etwas von der Natur:

public IThingy Thing

Wird den Fehler erzeugen:

Es konnte keine Instanz vom Typ IThingy erstellt werden. Typ ist eine Schnittstelle oder abstrakte Klasse und kann nicht instanziiert werden.

Es ist relativ wichtig, dass es sich um ein IThingy im Gegensatz zu einem Thingy handelt, da der Code, an dem ich arbeite, als vertraulich angesehen wird und Unit-Tests sehr wichtig sind. Das Verspotten von Objekten für Atomtestskripte ist mit vollwertigen Objekten wie Thingy nicht möglich. Sie müssen eine Schnittstelle sein.

Ich habe jetzt schon eine Weile über die Dokumentation von JSON.NET nachgedacht, und die Fragen, die ich auf dieser Website dazu finden konnte, stammen alle von vor über einem Jahr. Irgendeine Hilfe?

Wenn es darauf ankommt, ist meine App auch in .NET 4.0 geschrieben.

@SamualDavis bot eine großartige Lösung für eine verwandte Frage , die ich hier zusammenfassen werde.

Wenn Sie einen JSON-Stream in eine konkrete Klasse mit Schnittstelleneigenschaften deserialisieren müssen, können Sie die konkreten Klassen als Parameter in einen Konstruktor für die Klasse aufnehmen! Der NewtonSoft-Deserializer ist intelligent genug, um herauszufinden, dass er diese konkreten Klassen zum Deserialisieren der Eigenschaften verwenden muss.

Hier ist ein Beispiel:

public class Visit : IVisit
{
    /// <summary>
    /// This constructor is required for the JSON deserializer to be able
    /// to identify concrete classes to use when deserializing the interface properties.
    /// </summary>
    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; }
}

(Von dieser Frage kopiert )

In Fällen, in denen ich keine Kontrolle über den eingehenden JSON hatte (und daher nicht sicherstellen kann, dass er eine $ type-Eigenschaft enthält), habe ich einen benutzerdefinierten Konverter geschrieben, mit dem Sie nur den konkreten Typ explizit angeben können:

public class Model
{
    [JsonConverter(typeof(ConcreteTypeConverter<Something>))]
    public ISomething TheThing { get; set; }
}

Dies verwendet nur die Standard-Serializer-Implementierung von Json.Net, während der konkrete Typ explizit angegeben wird.

Eine Übersicht finden Sie in diesem Blogbeitrag . Der Quellcode ist unten:

public class ConcreteTypeConverter<TConcrete> : 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<TConcrete>(reader);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        //use the default serialization - it works fine
        serializer.Serialize(writer, value);
    }
}

Warum einen Konverter verwenden? Es gibt eine native Funktionalität Newtonsoft.Json, um genau dieses Problem zu lösen:

Stellen Sie TypeNameHandlingdas JsonSerializerSettingsin einTypeNameHandling.Auto

JsonConvert.SerializeObject(
  toSerialize,
  new JsonSerializerSettings()
  {
    TypeNameHandling = TypeNameHandling.Auto
  });

Dadurch wird jeder Typ in den JSON eingefügt, der nicht als konkrete Instanz eines Typs, sondern als Schnittstelle oder abstrakte Klasse gespeichert wird.

Stellen Sie sicher, dass Sie dieselben Einstellungen für die Serialisierung und Deserialisierung verwenden .

Ich habe es getestet und es funktioniert wie ein Zauber, auch mit Listen.

Suchergebnisse Web-Ergebnis mit Site-Links

⚠️ WARNUNG :

Verwenden Sie dies nur für JSON aus einer bekannten und vertrauenswürdigen Quelle. Benutzer snipsnipsnip richtig erwähnt, dass dies in der Tat eine Vunerability ist.

Weitere Informationen finden Sie unter CA2328 und SCS0028 .

Quelle und eine alternative manuelle Implementierung: Code Inside Blog

Um die Deserialisierung mehrerer Schnittstellenimplementierungen zu ermöglichen, können Sie JsonConverter verwenden, jedoch nicht über ein Attribut:

Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Converters.Add(new DTOJsonConverter());
Interfaces.IEntity entity = serializer.Deserialize(jsonReader);

DTOJsonConverter ordnet jede Schnittstelle einer konkreten Implementierung zu:

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 wird nur für den Deserializer benötigt. Der Serialisierungsprozess bleibt unverändert. Das Json-Objekt muss keine konkreten Typnamen einbetten.

Dieser SO-Beitrag bietet die gleiche Lösung einen Schritt weiter mit einem generischen JsonConverter.

Verwenden Sie diese Klasse, um den abstrakten Typ dem realen Typ zuzuordnen:

public class AbstractConverter<TReal, TAbstract> : JsonConverter where TReal : TAbstract
{
    public override Boolean CanConvert(Type objectType) 
        => objectType == typeof(TAbstract);

    public override Object ReadJson(JsonReader reader, Type type, Object value, JsonSerializer jser) 
        => jser.Deserialize<TReal>(reader);

    public override void WriteJson(JsonWriter writer, Object value, JsonSerializer jser) 
        => jser.Serialize(writer, value);
}

... und wenn deserialisieren:

        var settings = new JsonSerializerSettings
        {
            Converters = {
                new AbstractConverter<Thing, IThingy>(),
                new AbstractConverter<Thing2, IThingy2>()
            },
        };

        JsonConvert.DeserializeObject(json, type, settings);

Nicholas Westby bot eine großartige Lösung in einem großartigen Artikel .

Wenn Sie JSON in eine von vielen möglichen Klassen deserialisieren möchten, die eine solche Schnittstelle implementieren:

public class Person
{
    public IProfession Profession { get; set; }
}

public interface IProfession
{
    string JobTitle { get; }
}

public class Programming : IProfession
{
    public string JobTitle => "Software Developer";
    public string FavoriteLanguage { get; set; }
}

public class Writing : IProfession
{
    public string JobTitle => "Copywriter";
    public string FavoriteWord { get; set; }
}

public class Samples
{
    public static Person GetProgrammer()
    {
        return new Person()
        {
            Profession = new Programming()
            {
                FavoriteLanguage = "C#"
            }
        };
    }
}

Sie können einen benutzerdefinierten JSON-Konverter verwenden:

public class ProfessionConverter : JsonConverter
{
    public override bool CanWrite => false;
    public override bool CanRead => 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;
    }
}

Außerdem müssen Sie die Eigenschaft "Profession" mit einem JsonConverter-Attribut dekorieren, damit Sie wissen, dass Sie Ihren benutzerdefinierten Konverter verwenden können:

    public class Person
    {
        [JsonConverter(typeof(ProfessionConverter))]
        public IProfession Profession { get; set; }
    }

Und dann können Sie Ihre Klasse mit einem Interface besetzen:

Person person = JsonConvert.DeserializeObject<Person>(jsonString);

Zwei Dinge, die Sie versuchen könnten:

Implementieren Sie ein Try / Parse-Modell:

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<Heir>(reader);

    if (richDude == null)
    {
        richDude = serializer.Deserialize<Magnate>(reader);
    }

    if (richDude == null)
    {
        richDude = serializer.Deserialize<Tycoon>(reader);
    }

    return richDude;
  }

  public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
  {
    // Left as an exercise to the reader :)
    throw new NotImplementedException();
  }
}

Wenn Sie dies in Ihrem Objektmodell tun können, implementieren Sie eine konkrete Basisklasse zwischen IPerson und Ihren Blattobjekten und deserialisieren Sie diese.

Der erste kann möglicherweise zur Laufzeit fehlschlagen, der zweite erfordert Änderungen an Ihrem Objektmodell und homogenisiert die Ausgabe auf den kleinsten gemeinsamen Nenner.

Ich fand das nützlich. Du könntest auch.

Beispiel Verwendung

public class Parent
{
    [JsonConverter(typeof(InterfaceConverter<IChildModel, ChildModel>))]
    IChildModel Child { get; set; }
}

Benutzerdefinierter Erstellungskonverter

public class InterfaceConverter<TInterface, TConcrete> : CustomCreationConverter<TInterface>
    where TConcrete : TInterface, new()
{
    public override TInterface Create(Type objectType)
    {
        return new TConcrete();
    }
}

Json.NET-Dokumentation

Für diejenigen, die neugierig auf den ConcreteListTypeConverter sind, auf den Oliver verwiesen hat, ist hier mein Versuch:

public class ConcreteListTypeConverter<TInterface, TImplementation> : 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<List<TImplementation>>(reader);
        return res.ConvertAll(x => (TInterface) x);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        serializer.Serialize(writer, value);
    }
}

Für das, was es wert ist, musste ich mich größtenteils selbst darum kümmern. Jedes Objekt verfügt über eine Deserialize- Methode (Zeichenfolge jsonStream) . Ein paar Ausschnitte davon:

JObject parsedJson = this.ParseJson(jsonStream);
object thingyObjectJson = (object)parsedJson["thing"];
this.Thing = new Thingy(Convert.ToString(thingyObjectJson));

In diesem Fall ist new Thingy (Zeichenfolge) ein Konstruktor, der die Deserialize- Methode (Zeichenfolge jsonStream) des entsprechenden konkreten Typs aufruft . Dieses Schema wird weiter nach unten und unten verschoben, bis Sie zu den Basispunkten gelangen, die json.NET gerade verarbeiten kann.

this.Name = (string)parsedJson["name"];
this.CreatedTime = DateTime.Parse((string)parsedJson["created_time"]);

Und so weiter und so fort. Mit diesem Setup konnte ich json.NET-Setups bereitstellen, die verarbeitet werden können, ohne dass ein großer Teil der Bibliothek selbst umgestaltet werden muss oder unhandliche Try / Parse-Modelle verwendet werden müssen, die aufgrund der Anzahl der beteiligten Objekte unsere gesamte Bibliothek blockiert hätten. Dies bedeutet auch, dass ich alle JSON-Änderungen an einem bestimmten Objekt effektiv verarbeiten kann und mich nicht um alles kümmern muss, was das Objekt berührt. Es ist keineswegs die ideale Lösung, aber es funktioniert recht gut mit unseren Unit- und Integrationstests.

Angenommen, eine Autofac-Einstellung wie die folgende:

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 = () => _container.Resolve(objectType);
        }  

        return contract;
    }
}

Nehmen wir dann an, Ihre Klasse ist wie folgt:

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; }
    }
}

Daher könnte die Verwendung des Resolvers bei der Deserialisierung wie folgt aussehen:

ContainerBuilder builder = new ContainerBuilder();
builder.RegisterType<TaskRepository>().As<ITaskRepository>();
builder.RegisterType<TaskController>();
builder.Register(c => new LogService(new DateTime(2000, 12, 12))).As<ILogger>();

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<TaskController>(json, new JsonSerializerSettings
{
    ContractResolver = contractResolver
});

Console.WriteLine(controller.Repository.GetType().Name);

Weitere Informationen finden Sie unter http://www.newtonsoft.com/json/help/html/DeserializeWithDependencyInjection.htm

Kein Objekt wird immer sein , eine iThingy als Schnittstellen alle abstrakten per Definition.

Das Objekt, das Sie zuerst serialisiert haben, war von einem konkreten Typ und implementierte die abstrakte Schnittstelle. Sie müssen den gleichen Beton haben Klasse muss die serialisierten Daten wiederbeleben.

Das resultierende Objekt ist dann von einem Typ, der die von Ihnen gesuchte abstrakte Schnittstelle implementiert .

Aus der Dokumentation folgt, dass Sie verwenden können

(Thingy)JsonConvert.DeserializeObject(jsonString, typeof(Thingy));

beim Deserialisieren, um JSON.NET über den konkreten Typ zu informieren.

Meine Lösung für diese, die ich mag, weil sie sehr allgemein ist, lautet wie folgt:

/// <summary>
/// Automagically convert known interfaces to (specific) concrete classes on deserialisation
/// </summary>
public class WithMocksJsonConverter : JsonConverter
{
    /// <summary>
    /// The interfaces I know how to instantiate mapped to the classes with which I shall instantiate them, as a Dictionary.
    /// </summary>
    private readonly Dictionary<Type,Type> conversions = new Dictionary<Type,Type>() { 
        { typeof(IOne), typeof(MockOne) },
        { typeof(ITwo), typeof(MockTwo) },
        { typeof(IThree), typeof(MockThree) },
        { typeof(IFour), typeof(MockFour) }
    };

    /// <summary>
    /// Can I convert an object of this type?
    /// </summary>
    /// <param name="objectType">The type under consideration</param>
    /// <returns>True if I can convert the type under consideration, else false.</returns>
    public override bool CanConvert(Type objectType)
    {
        return conversions.Keys.Contains(objectType);
    }

    /// <summary>
    /// Attempt to read an object of the specified type from this reader.
    /// </summary>
    /// <param name="reader">The reader from which I read.</param>
    /// <param name="objectType">The type of object I'm trying to read, anticipated to be one I can convert.</param>
    /// <param name="existingValue">The existing value of the object being read.</param>
    /// <param name="serializer">The serializer invoking this request.</param>
    /// <returns>An object of the type into which I convert the specified objectType.</returns>
    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));
        }
    }

    /// <summary>
    /// Not yet implemented.
    /// </summary>
    /// <param name="writer">The writer to which I would write.</param>
    /// <param name="value">The value I am attempting to write.</param>
    /// <param name="serializer">the serializer invoking this request.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

}}

Sie können es offensichtlich und trivial in einen noch allgemeineren Konverter konvertieren, indem Sie einen Konstruktor hinzufügen, der ein Argument vom Typ Dictionary <Typ, Typ> verwendet, mit dem die Instanzvariable der Konvertierung instanziiert wird.

Einige Jahre später hatte ich ein ähnliches Problem. In meinem Fall gab es stark verschachtelte Schnittstellen und eine Präferenz für das Generieren der konkreten Klassen zur Laufzeit, damit es mit einer generischen Klasse funktioniert.

Ich habe beschlossen, zur Laufzeit eine Proxy-Klasse zu erstellen, die das von Newtonsoft zurückgegebene Objekt umschließt.

Der Vorteil dieses Ansatzes besteht darin, dass keine konkrete Implementierung der Klasse erforderlich ist und jede Tiefe verschachtelter Schnittstellen automatisch verarbeitet werden kann. Sie können mehr darüber in meinem Blog sehen .

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<InterfaceType>(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 && 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");
            }

        }
    }



}

Verwendung:

var jObj = JObject.Parse(input);
InterfaceType proxyObject = jObj.toProxy<InterfaceType>();

Verwenden Sie diese JsonKnownTypes , es ist sehr ähnlich zu verwenden, es fügt nur einen Diskriminator zu json hinzu:

[JsonConverter(typeof(JsonKnownTypeConverter<Interface1>))]
[JsonKnownType(typeof(MyClass), "myClass")]
public interface Interface1
{  }
public class MyClass : Interface1
{
    public string Something;
}

Wenn Sie nun ein Objekt in json serialisieren, wird es "$type"mit dem "myClass"Wert addiert und zum Deserialisieren verwendet

Json:

{"Something":"something", "$type":"derived"}

Meine Lösung wurde die Schnittstellenelemente im Konstruktor hinzugefügt.

public class Customer: ICustomer{
     public Customer(Details details){
          Details = details;
     }

     [JsonProperty("Details",NullValueHnadling = NullValueHandling.Ignore)]
     public IDetails Details {get; set;}
}