Verwenden von Json.NET-Konvertern zum Deserialisieren von Eigenschaften

Ich habe eine Klassendefinition, die eine Eigenschaft enthält, die eine Schnittstelle zurückgibt.

public class Foo
{ 
    public int Number { get; set; }

    public ISomething Thing { get; set; }
}

Beim Versuch, die Foo-Klasse mit Json.NET zu serialisieren, wird die folgende Fehlermeldung angezeigt: "Es konnte keine Instanz vom Typ 'ISomething' erstellt werden. ISomething kann eine Schnittstelle oder eine abstrakte Klasse sein."

Gibt es ein Json.NET-Attribut oder einen Konverter, mit dem ich eine konkrete SomethingKlasse angeben kann , die während der Deserialisierung verwendet werden soll?

Mit Json.NET können Sie unter anderem Folgendes tun :

var settings = new JsonSerializerSettings();
settings.TypeNameHandling = TypeNameHandling.Objects;

JsonConvert.SerializeObject(entity, Formatting.Indented, settings);

Das TypeNameHandlingFlag fügt $typedem JSON eine Eigenschaft hinzu, mit der Json.NET erkennt, in welchen konkreten Typ das Objekt deserialisiert werden soll. Auf diese Weise können Sie ein Objekt deserialisieren, während Sie eine Schnittstelle oder eine abstrakte Basisklasse erfüllen.

Der Nachteil ist jedoch, dass dies sehr Json.NET-spezifisch ist. Das $typewird ein vollständig qualifizierter Typ sein, also , wenn Sie es mit Typ - Informationen sind die Serialisierung ,, die Deserializer muss in der Lage sein , es so gut zu verstehen.

Dokumentation: Serialisierungseinstellungen mit Json.NET

Sie können dies durch die Verwendung der JsonConverter-Klasse erreichen. Angenommen, Sie haben eine Klasse mit einer Schnittstelleneigenschaft.

public class Organisation {
  public string Name { get; set; }

  [JsonConverter(typeof(TycoonConverter))]
  public IPerson Owner { get; set; }
}

public interface IPerson {
  string Name { get; set; }
}

public class Tycoon : IPerson {
  public string Name { get; set; }
}

Ihr JsonConverter ist für die Serialisierung und De-Serialisierung der zugrunde liegenden Eigenschaft verantwortlich.

public class TycoonConverter : JsonConverter
{
  public override bool CanConvert(Type objectType)
  {
    return (objectType == typeof(IPerson));
  }

  public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
  {
    return serializer.Deserialize<Tycoon>(reader);
  }

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

Wenn Sie mit einer über Json.Net deserialisierten Organisation arbeiten, ist die zugrunde liegende IPerson für die Owner-Eigenschaft vom Typ Tycoon.

Anstatt ein benutzerdefiniertes JsonSerializerSettings-Objekt mit der Option TypeNameHandling.Objects an JsonConvert.SerializeObject () zu übergeben, können Sie diese bestimmte Schnittstelleneigenschaft einfach mit einem Attribut markieren, damit der generierte JSON nicht mit den Eigenschaften "$ type" aufgebläht wird auf JEDEM Objekt:

public class Foo
{
    public int Number { get; set; }

    // Add "$type" property containing type info of concrete class.
    [JsonProperty( TypeNameHandling = TypeNameHandling.Objects )]
    public ISomething { get; set; }
}

In der neuesten Version des Newtonsoft Json-Konverters eines Drittanbieters können Sie einen Konstruktor mit einem konkreten Typ festlegen, der sich auf die Schnittstelle bezieht.

public class Foo
{ 
    public int Number { get; private set; }

    public ISomething IsSomething { get; private set; }

    public Foo(int number, Something concreteType)
    {
        Number = number;
        IsSomething = concreteType;
    }
}

Solange etwas etwas implementiert, sollte dies funktionieren. Setzen Sie auch keinen leeren Standardkonstruktor, falls der JSon-Konverter versucht, diesen zu verwenden. Sie müssen ihn zwingen, den Konstruktor zu verwenden, der den konkreten Typ enthält.

PS. Auf diese Weise können Sie Ihre Setter auch privat machen.

Hatte das gleiche Problem, also kam ich auf meinen eigenen Konverter, der bekannte Typenargumente verwendet.

public class JsonKnownTypeConverter : JsonConverter
{
    public IEnumerable<Type> KnownTypes { get; set; }

    public JsonKnownTypeConverter(IEnumerable<Type> knownTypes)
    {
        KnownTypes = knownTypes;
    }

    protected object Create(Type objectType, JObject jObject)
    {
        if (jObject["$type"] != null)
        {
            string typeName = jObject["$type"].ToString();
            return Activator.CreateInstance(KnownTypes.First(x =>typeName.Contains("."+x.Name+",")));
        }

        throw new InvalidOperationException("No supported type");
    }

    public override bool CanConvert(Type objectType)
    {
        if (KnownTypes == null)
            return false;

        return (objectType.IsInterface || objectType.IsAbstract) && KnownTypes.Any(objectType.IsAssignableFrom);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        // Load JObject from stream
        JObject jObject = JObject.Load(reader);
        // Create target object based on JObject
        var target = Create(objectType, jObject);
        // Populate the object properties
        serializer.Populate(jObject.CreateReader(), target);
        return target;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

Ich habe zwei Erweiterungsmethoden zum Deserialisieren und Serialisieren definiert:

public static class AltiJsonSerializer
{
    public static T DeserializeJson<T>(this string jsonString, IEnumerable<Type> knownTypes = null)
    {
        if (string.IsNullOrEmpty(jsonString))
            return default(T);

        return JsonConvert.DeserializeObject<T>(jsonString,
                new JsonSerializerSettings
                {
                    TypeNameHandling = TypeNameHandling.Auto, 
                    Converters = new List<JsonConverter>
                        (
                            new JsonConverter[]
                            {
                                new JsonKnownTypeConverter(knownTypes)
                            }
                        )
                }
            );
    }

    public static string SerializeJson(this object objectToSerialize)
    {
        return JsonConvert.SerializeObject(objectToSerialize, Formatting.Indented,
        new JsonSerializerSettings {TypeNameHandling = TypeNameHandling.Auto});
    }
}

Sie können Ihre eigene Art des Vergleichens und Identifizierens von Typen in den Konvertierungen definieren. Ich verwende nur den Klassennamen.

Normalerweise habe ich die Lösung immer mit verwendet, TypeNameHandlingwie von DanielT vorgeschlagen, aber in Fällen, in denen ich hier keine Kontrolle über den eingehenden JSON hatte (und daher nicht sicherstellen kann, dass er eine $typeEigenschaft enthält), habe ich einen benutzerdefinierten Konverter geschrieben, mit dem Sie nur explizit angeben können der konkrete Typ:

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

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

Der Quellcode und eine Übersicht finden Sie in diesem Blogbeitrag .

Ich wollte nur das Beispiel vervollständigen, das uns @Daniel T. oben gezeigt hat:

Wenn Sie diesen Code zum Serialisieren Ihres Objekts verwenden:

var settings = new JsonSerializerSettings();
settings.TypeNameHandling = TypeNameHandling.Objects;
JsonConvert.SerializeObject(entity, Formatting.Indented, settings);

Der Code zum Deserialisieren des JSON sollte folgendermaßen aussehen:

var settings = new JsonSerializerSettings(); 
settings.TypeNameHandling = TypeNameHandling.Objects;
var entity = JsonConvert.DeserializeObject<EntityType>(json, settings);

So wird ein JSON angepasst, wenn das TypeNameHandlingFlag verwendet wird:

Ich habe mich das Gleiche gefragt, aber ich fürchte, es geht nicht.

Schauen wir es uns so an. Sie übergeben JSon.net eine Datenfolge und einen Typ, in den Sie deserialisieren möchten. Was kann JSON.net tun, wenn es auf etwas trifft? Es kann keine neue Art von ISomething erstellen, da ISomething kein Objekt ist. Es kann auch kein Objekt erstellen, das ISomething implementiert, da es keine Ahnung hat, welches der vielen Objekte, die möglicherweise ISomething erben, verwendet werden soll. Schnittstellen können automatisch serialisiert, aber nicht automatisch deserialisiert werden.

Was ich tun würde, wäre zu versuchen, ISomething durch eine Basisklasse zu ersetzen. Auf diese Weise können Sie möglicherweise den gewünschten Effekt erzielen.

Hier ist ein Verweis auf einen Artikel von ScottGu

Auf dieser Grundlage habe ich einen Code geschrieben, der meiner Meinung nach hilfreich sein könnte

public interface IEducationalInstitute
{
    string Name
    {
        get; set;
    }

}

public class School : IEducationalInstitute
{
    private string name;
    #region IEducationalInstitute Members

    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    #endregion
}

public class Student 
{
    public IEducationalInstitute LocalSchool { get; set; }

    public int ID { get; set; }
}

public static class JSONHelper
{
    public static string ToJSON(this object obj)
    {
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        return serializer.Serialize(obj);
    }
    public  static string ToJSON(this object obj, int depth)
    {
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        serializer.RecursionLimit = depth;
        return serializer.Serialize(obj);
    }
}

Und so würden Sie es nennen

School myFavSchool = new School() { Name = "JFK High School" };
Student sam = new Student()
{
    ID = 1,
    LocalSchool = myFavSchool
};
string jSONstring = sam.ToJSON();

Console.WriteLine(jSONstring);
//Result {"LocalSchool":{"Name":"JFK High School"},"ID":1}

Wenn ich es richtig verstehe, müssen Sie meiner Meinung nach keine konkrete Klasse angeben, die die Schnittstelle für die JSON-Serialisierung implementiert.