Використання перетворювачів Json.NET для десериалізації властивостей

У мене є визначення класу, яке містить властивість, що повертає інтерфейс.

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

    public ISomething Thing { get; set; }
}

Спроба серіалізації класу Foo за допомогою Json.NET видає мені повідомлення про помилку на кшталт: "Не вдалося створити екземпляр типу" ISomething ". ISomething може бути інтерфейсом або абстрактним класом."

Чи існує атрибут Json.NET або конвертер, який дозволив би мені вказати конкретний Somethingклас для використання під час десеріалізації?

Одне з речей, яке ви можете зробити з Json.NET :

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

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

TypeNameHandlingпрапор додасть$type властивість в форматі JSON, який дозволяє Json.NET знати , який конкретний тип він повинен десеріалізациі об'єкта в. Це дозволяє вам десериалізувати об'єкт, одночасно виконуючи інтерфейс або абстрактний базовий клас.

Однак недоліком є ​​те, що це дуже специфічно для Json.NET. $type буде повністю кваліфікований тип, тому, якщо ви серіалізуєте його за допомогою інформації про тип, десериалізатор також повинен його зрозуміти.

Документація: Налаштування серіалізації за допомогою Json.NET

Ви можете досягти цього за допомогою класу JsonConverter. Припустимо, у вас є клас із властивістю інтерфейсу;

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

Ваш JsonConverter відповідає за серіалізацію та десеріалізацію базового майна;

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

Коли ви працюєте з організацією, десеріалізованою за допомогою Json.Net, базовий IPerson для властивості Owner матиме тип Tycoon.

Замість передачі настроюваного об'єкта JsonSerializerSettings JsonConvert.SerializeObject () з параметром TypeNameHandling.Objects, як уже згадувалося, ви можете просто позначити це властивість інтерфейсу атрибутом, щоб згенерований JSON не роздувався властивостями "$ type" на КОЖНОМУ об’єкті:

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

В найновішій версії незалежного перетворювача Newtonsoft Json ви можете встановити конструктор із конкретним типом, що стосується властивості взаємодії.

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

Поки щось реалізує ISomething, це повинно працювати. Також не ставте порожній конструктор за замовчуванням, якщо перетворювач JSon намагається це використовувати, ви повинні змусити його використовувати конструктор, що містить конкретний тип.

PS. це також дозволяє зробити ваших установників приватними.

У мене була та ж проблема, тому я придумав власний конвертер, який використовує аргумент відомих типів.

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

Я визначив два методи розширення для десериалізації та серіалізації:

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

Ви можете визначити свій власний спосіб порівняння та ідентифікації типів у конвертерах, я використовую лише ім'я класу.

Зазвичай я завжди використовував рішення, TypeNameHandlingяк пропонував DanielT, але у випадках, коли тут я не контролював вхідний JSON (і тому не можу переконатися, що він включає $typeвластивість), я написав спеціальний конвертер, який просто дозволяє чітко вказати тип бетону:

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

Тут просто використовується реалізація серіалізатора за замовчуванням від Json.Net, одночасно вказуючи конкретний тип.

Вихідний код та огляд доступні в цьому дописі в блозі .

Я просто хотів закінчити приклад, який @Daniel T. показав нам вище:

Якщо ви використовуєте цей код для серіалізації об’єкта:

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

Код для десеріалізації json повинен виглядати так:

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

Ось як json пристосовується при використанні TypeNameHandlingпрапора:

Я дивувався цьому самому, але боюся, цього не можна зробити.

Давайте подивимось на це так. Ви передаєте JSon.net рядок даних і тип, для десериалізації. Що робити JSON.net, коли потрапляє на щось ISomething? Він не може створити новий тип ISomething, оскільки ISomething не є об’єктом. Він також не може створити об'єкт, який реалізує ISomething, оскільки він не знає, який із багатьох об'єктів, які можуть успадкувати ISomething, йому слід використовувати. Інтерфейси - це те, що можна автоматично серіалізувати, але не автоматично десеріалізувати.

Що б я зробив, це було б поглянути на заміну ISomething базовим класом. Використовуючи це, ви могли б отримати ефект, який шукаєте.

Ось посилання на статтю, написану ScottGu

На основі цього я написав певний код, який, на мою думку, може бути корисним

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

І ось як би ви це назвали

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}

Якщо я це правильно розумію, я не думаю, що вам потрібно вказувати конкретний клас, який реалізує інтерфейс для серіалізації JSON.