Кастинг інтерфейсів для десеріалізації в JSON.NET

Я намагаюся налаштувати зчитувач, який буде приймати в JSON об’єкти з різних веб-сайтів (думаю, скрабовування інформації) та переводив їх у об'єкти C #. Зараз я використовую JSON.NET для процесу десеріалізації. Проблема, з якою я стикаюся, полягає в тому, що він не знає, як обробляти властивості рівня інтерфейсу в класі. Отже, щось із природи:

public IThingy Thing

Виведе помилку:

Не вдалося створити екземпляр типу IThingy. Тип - це інтерфейс або абстрактний клас, і його неможливо створити.

Надзвичайно важливо, щоб це був IThingy на відміну від Thingy, оскільки код, над яким я працюю, вважається чутливим, а тестування модулів є надзвичайно важливим. Знущання з об’єктів для атомних тестових скриптів неможливо з повноцінними об'єктами типу Thingy. Вони повинні бути інтерфейсом.

Я деякий час переглядав документацію JSON.NET, і питання, які я міг знайти на цьому веб-сайті, пов’язані з цим, виникають понад рік тому. Будь-яка допомога?

Крім того, якщо це має значення, моя програма написана на .NET 4.0.

@SamualDavis запропонував чудове рішення у пов’язаному питанні , яке я підсумую тут.

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

Ось приклад:

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

(Скопійовано з цього питання )

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

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

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

Огляд доступний у цій публікації блогу . Вихідний код нижче:

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

Навіщо використовувати перетворювач? Існує нативна функціональність Newtonsoft.Jsonдля вирішення цієї точної проблеми:

Набір TypeNameHandlingв JsonSerializerSettingsдоTypeNameHandling.Auto

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

Це додасть кожен тип до json, який не має бути конкретним екземпляром типу, а інтерфейсом або абстрактним класом.

Переконайтеся, що ви використовуєте однакові налаштування для серіалізації та десеріалізації .

Я перевірив це, і він працює як шарм, навіть зі списками.

Веб-результат пошуку результатів із посиланнями на сайт

⚠️ ПОПЕРЕДЖЕННЯ :

Використовуйте це лише для json з відомого та надійного джерела. Користувач snipsnipsnip правильно зазначив, що це справді вразливість.

Див. CA2328 та SCS0028 для отримання додаткової інформації.

Джерело та альтернативна ручна реалізація: Code Inside Blog

Щоб увімкнути десяріалізацію декількох реалізацій інтерфейсів, ви можете використовувати JsonConverter, але не через атрибут:

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

DTOJsonConverter відображає кожен інтерфейс з конкретною реалізацією:

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 потрібен лише для десеріалізатора. Процес серіалізації незмінний. Об'єкту Json не потрібно вставляти імена конкретних типів.

Ця публікація ТА пропонує те саме рішення на крок далі із загальним JsonConverter.

Використовуйте цей клас для відображення абстрактного типу в реальний тип:

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

... і при десеріалізації:

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

        JsonConvert.DeserializeObject(json, type, settings);

Ніколас Вестбі запропонував чудове рішення у приголомшливій статті .

Якщо ви хочете десеріалізувати JSON до одного з багатьох можливих класів, що реалізують такий інтерфейс:

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

Ви можете використовувати спеціальний конвертер JSON:

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

І вам потрібно буде прикрасити властивість "Profession" атрибутом JsonConverter, щоб він міг використовувати ваш спеціальний конвертер:

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

А потім ви можете передавати свій клас за допомогою інтерфейсу:

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

Ви можете спробувати дві речі:

Реалізуйте модель спробу / розбору:

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

Або, якщо ви можете це зробити у вашій об'єктній моделі, реалізуйте конкретний базовий клас між IPerson та вашими листовими об'єктами та деріаріалізуйте його.

Перший може потенційно вийти з ладу під час виконання, другий вимагає змін у вашій об'єктній моделі та гомогенізує вихід до найменшого загального знаменника.

Я вважав це корисним. Ви також можете.

Приклад використання

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

Спеціальний конвертер створення

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

Документація Json.NET

Для тих, хто може бути цікавим про ConcreteListTypeConverter, на який посилався Олівер, ось моя спроба:

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

Чому це варто, я зрештою змушений з цим боротися здебільшого сам. Кожен об’єкт має метод Deserialize (string jsonStream) . Кілька фрагментів:

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

У цьому випадку новий Thingy (string) - це конструктор, який викликатиме метод Deserialize (рядок jsonStream) відповідного конкретного типу. Ця схема буде йти вниз і вниз, поки ви не дістанетесь до базових точок, які json.NET може просто обробити.

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

І так далі. Ця настройка дозволила мені надати установки json.NET, з якими вона може працювати без необхідності переробляти велику частину самої бібліотеки або використовувати незграбні спроби / розбору моделей, які б завалили всю нашу бібліотеку через кількість об'єктів, що беруть участь. Це також означає, що я можу ефективно обробляти будь-які зміни json на конкретному об’єкті, і мені не потрібно турбуватися про все, що стосується об'єкта. Це аж ніяк не ідеальне рішення, але воно працює досить добре з нашого модуля та інтеграційного тестування.

Припустимо, налаштування автоматичного факсу на зразок наступного:

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

Тоді припустимо, що ваш клас такий:

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

Отже, використання роздільної здатності в десеріалізації може бути таким:

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

Докладніші відомості ви можете знайти на веб-сайті http://www.newtonsoft.com/json/help/html/DeserializeWithDependencyInjection.htm

Жоден об'єкт ніколи не буде IThingy, оскільки інтерфейси всі абстрактні за визначенням.

Об'єкт ви , що був першим серіалізовать був якийсь - то конкретного типу, реалізації абстрактного інтерфейсу. Потрібно, щоб цей самий конкретний клас відроджував серіалізовані дані.

Отриманий об'єкт буде мати якийсь - то тип , який реалізує абстрактний інтерфейс , якого ви шукаєте.

З документації випливає, що ви можете використовувати

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

при десаріалізації повідомляти JSON.NET про тип бетону.

Моє рішення цього рішення, яке мені подобається, оскільки воно загальноприйняте, таке:

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

}

Можна, очевидно, і тривіально перетворити його в ще більш загальний конвертер, додавши конструктор, який взяв аргумент типу словник <Тип, Тип>, за допомогою якого інстанціювати змінну екземпляра конверсій.

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

Я вирішив створити проксі-клас під час виконання, який обгортає об'єкт, повернутий Newtonsoft.

Перевага такого підходу полягає в тому, що він не потребує конкретної реалізації класу і може обробляти будь-яку глибину вкладених інтерфейсів автоматично. Більше про це можна побачити на моєму блозі .

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

        }
    }



}

Використання:

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

Використовуйте цей JsonK knownTypes , це дуже подібний спосіб використання, він просто додає дискримінатор до json:

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

Тепер , коли ви серіалізовать об'єкт JSON буде додати "$type"з "myClass"значенням , і він буде використовувати для десеріалізациі

Json:

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

Моє рішення було додано елементи інтерфейсу в конструкторі.

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

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