Mentransmisikan antarmuka untuk deserialisasi di JSON.NET

Saya mencoba menyiapkan pembaca yang akan mengambil objek JSON dari berbagai situs web (pikirkan informasi scraping) dan menerjemahkannya ke dalam objek C #. Saya saat ini menggunakan JSON.NET untuk proses deserialization. Masalah yang saya hadapi adalah bahwa ia tidak tahu bagaimana menangani properti tingkat antarmuka di kelas. Jadi sesuatu yang alami:

public IThingy Thing

Akan menghasilkan kesalahan:

Tidak dapat membuat instance berjenis IThingy. Type adalah antarmuka atau kelas abstrak dan tidak dapat dipakai.

Relatif penting untuk menjadikannya sebagai IThingy dibandingkan dengan Thingy karena kode yang saya kerjakan dianggap sensitif dan pengujian unit sangat penting. Mocking objek untuk skrip pengujian atom tidak dimungkinkan dengan objek yang lengkap seperti Thingy. Mereka harus menjadi antarmuka.

Saya telah mempelajari dokumentasi JSON.NET untuk sementara waktu sekarang, dan pertanyaan yang dapat saya temukan di situs ini terkait dengan ini semuanya berasal lebih dari setahun yang lalu. Ada bantuan?

Selain itu, jika penting, aplikasi saya ditulis dalam .NET 4.0.

@SamualDavis memberikan solusi bagus untuk pertanyaan terkait , yang akan saya rangkum di sini.

Jika Anda harus deserialisasi aliran JSON menjadi kelas beton yang memiliki properti antarmuka, Anda dapat menyertakan kelas konkret sebagai parameter ke konstruktor untuk kelas tersebut! NewtonSoft deserializer cukup pintar untuk mengetahui bahwa ia perlu menggunakan kelas konkret tersebut untuk deserialisasi properti.

Berikut ini contohnya:

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

(Disalin dari pertanyaan ini )

Dalam kasus di mana saya tidak memiliki kendali atas JSON yang masuk (sehingga tidak dapat memastikan bahwa itu termasuk properti $ type) saya telah menulis konverter khusus yang hanya memungkinkan Anda untuk secara eksplisit menentukan jenis konkret:

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

Ini hanya menggunakan implementasi serializer default dari Json.Net sementara secara eksplisit menentukan tipe konkret.

Ringkasan tersedia di posting blog ini . Kode sumber di bawah ini:

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

Mengapa menggunakan konverter? Ada fungsi asli Newtonsoft.Jsonuntuk menyelesaikan masalah ini dengan tepat:

Set TypeNameHandlingdi JsonSerializerSettingskeTypeNameHandling.Auto

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

Ini akan menempatkan setiap tipe ke dalam json, yang tidak diadakan sebagai contoh konkret dari sebuah tipe tetapi sebagai antarmuka atau kelas abstrak.

Pastikan Anda menggunakan pengaturan yang sama untuk serialisasi dan deserialisasi .

Saya mengujinya, dan itu bekerja seperti pesona, bahkan dengan daftar.

Hasil Pencarian Hasil Web dengan link situs

⚠️ PERINGATAN :

Gunakan ini hanya untuk json dari sumber yang dikenal dan tepercaya. Snipsnipsnip pengguna dengan benar menyebutkan bahwa ini memang vunerabilitas.

Lihat CA2328 dan SCS0028 untuk informasi lebih lanjut.

Sumber dan implementasi manual alternatif: Code Inside Blog

Untuk mengaktifkan deserialisasi beberapa implementasi antarmuka, Anda dapat menggunakan JsonConverter, tetapi tidak melalui atribut:

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

DTOJsonConverter memetakan setiap antarmuka dengan implementasi konkret:

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 diperlukan hanya untuk deserializer. Proses serialisasi tidak berubah. Objek Json tidak perlu menyematkan nama tipe konkret.

Posting SO ini menawarkan solusi yang sama selangkah lebih maju dengan JsonConverter generik.

Gunakan kelas ini, untuk memetakan tipe abstrak ke tipe nyata:

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

... dan saat deserialize:

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

        JsonConvert.DeserializeObject(json, type, settings);

Nicholas Westby memberikan solusi hebat dalam artikel yang luar biasa .

Jika Anda ingin Deserializing JSON ke salah satu dari banyak kemungkinan kelas yang mengimplementasikan antarmuka seperti itu:

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

Anda dapat menggunakan konverter JSON khusus:

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

Dan Anda perlu menghias properti "Profesi" dengan atribut JsonConverter agar tahu cara menggunakan konverter khusus Anda:

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

Dan kemudian, Anda dapat mentransmisikan kelas Anda dengan Antarmuka:

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

Dua hal yang bisa Anda coba:

Menerapkan model coba / parse:

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

Atau, jika Anda dapat melakukannya dalam model objek Anda, terapkan kelas dasar konkret antara IPerson dan objek daun Anda, dan deserialisasi padanya.

Yang pertama berpotensi gagal pada waktu proses, yang kedua memerlukan perubahan pada model objek Anda dan menghomogenkan keluaran ke penyebut umum terendah.

Saya menemukan ini berguna. Anda mungkin juga.

Contoh Penggunaan

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

Konverter Pembuatan Kustom

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

Dokumentasi Json.NET

Bagi mereka yang mungkin penasaran dengan ConcreteListTypeConverter yang direferensikan oleh Oliver, berikut adalah upaya saya:

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

Untuk apa nilainya, saya akhirnya harus menangani ini sendiri untuk sebagian besar. Setiap objek memiliki a Deserialize (string jsonStream) . Beberapa cuplikannya:

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

Dalam hal ini, Thingy baru (string) adalah konstruktor yang akan memanggil metode Deserialize (string jsonStream) dari jenis beton yang sesuai. Skema ini akan terus berlanjut ke bawah dan ke bawah sampai Anda mencapai titik dasar yang bisa ditangani oleh json.NET.

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

Begitu seterusnya. Pengaturan ini memungkinkan saya untuk memberikan pengaturan json.NET yang dapat ditangani tanpa harus merefaktor sebagian besar pustaka itu sendiri atau menggunakan model coba / parse yang berat yang akan menghambat seluruh pustaka kami karena jumlah objek yang terlibat. Ini juga berarti bahwa saya dapat secara efektif menangani perubahan json apa pun pada objek tertentu, dan saya tidak perlu khawatir tentang semua yang disentuh objek. Ini sama sekali bukan solusi ideal, tetapi berfungsi dengan baik dari pengujian unit dan integrasi kami.

Misalkan pengaturan autofac seperti berikut:

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

Kemudian, misalkan kelas Anda seperti ini:

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

Oleh karena itu, penggunaan resolver dalam deserialization bisa seperti:

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

Anda dapat melihat detail lebih lanjut di http://www.newtonsoft.com/json/help/html/DeserializeWithDependencyInjection.htm

Tidak ada objek yang akan pernah menjadi sebuah IThingy sebagai antarmuka semua abstrak dengan definisi.

Objek yang Anda miliki yang pertama kali dibuat berseri adalah dari beberapa jenis konkret , menerapkan antarmuka abstrak . Anda harus memiliki beton yang sama kelas menghidupkan kembali data serial.

Objek yang dihasilkan kemudian akan dari beberapa jenis yang mengimplementasikan yang abstrak antarmuka yang Anda cari.

Dari dokumentasi berikut yang dapat Anda gunakan

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

saat deserializing untuk menginformasikan JSON.NET tentang jenis konkret.

Solusi saya untuk yang satu ini, yang saya suka karena cukup umum, adalah sebagai berikut:

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

}

Anda dapat dengan jelas dan mudah mengubahnya menjadi konverter yang lebih umum dengan menambahkan konstruktor yang mengambil argumen tipe Dictionary <Type, Type> yang dapat digunakan untuk membuat instance variabel instance konversi.

Beberapa tahun kemudian saya mengalami masalah serupa. Dalam kasus saya ada banyak antarmuka bersarang dan preferensi untuk menghasilkan kelas beton pada waktu proses sehingga akan bekerja dengan kelas generik.

Saya memutuskan untuk membuat kelas proxy pada waktu proses yang membungkus objek yang dikembalikan oleh Newtonsoft.

Keuntungan dari pendekatan ini adalah tidak memerlukan implementasi konkret kelas dan dapat menangani kedalaman antarmuka bersarang secara otomatis. Anda dapat melihat lebih banyak tentang itu di blog saya .

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

        }
    }



}

Pemakaian:

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

Gunakan JsonKnownTypes ini , cara penggunaannya sangat mirip, hanya menambahkan diskriminator ke json:

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

Sekarang ketika Anda membuat serial objek di json akan ditambahkan "$type"dengan"myClass" nilai dan itu akan digunakan untuk deserialize

Json:

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

Solusi saya menambahkan elemen antarmuka di konstruktor.

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

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