Truyền các giao diện để khử lưu huỳnh trong JSON.NET

Tôi đang cố gắng thiết lập một trình đọc sẽ lấy các đối tượng JSON từ các trang web khác nhau (nghĩ là quét thông tin) và dịch chúng thành các đối tượng C #. Tôi hiện đang sử dụng JSON.NET cho quá trình khử lưu huỳnh. Vấn đề tôi gặp phải là nó không biết cách xử lý các thuộc tính cấp giao diện trong một lớp. Vì vậy, một cái gì đó của bản chất:

public IThingy Thing

Sẽ tạo ra lỗi:

Không thể tạo một thể hiện của loại IThingy. Loại là một giao diện hoặc lớp trừu tượng và không thể được khởi tạo.

Điều tương đối quan trọng là phải có một ITakeny trái ngược với Thingy vì mã tôi đang làm việc được coi là nhạy cảm và thử nghiệm đơn vị là rất quan trọng. Không thể nhạo báng các đối tượng cho các kịch bản thử nghiệm nguyên tử với các đối tượng chính thức như Thingy. Chúng phải là một giao diện.

Bây giờ tôi đã xem qua tài liệu của JSON.NET và các câu hỏi tôi có thể tìm thấy trên trang này liên quan đến vấn đề này đều có từ hơn một năm trước. Có ai giúp đỡ không?

Ngoài ra, nếu có vấn đề, ứng dụng của tôi được viết bằng .NET 4.0.

@SamualDavis đã cung cấp một giải pháp tuyệt vời trong một câu hỏi liên quan , mà tôi sẽ tóm tắt ở đây.

Nếu bạn phải giải tuần tự hóa một luồng JSON thành một lớp cụ thể có các thuộc tính giao diện, bạn có thể bao gồm các lớp cụ thể làm tham số cho hàm tạo cho lớp! Trình giải nén NewtonSoft đủ thông minh để tìm ra rằng nó cần sử dụng các lớp cụ thể đó để giải tuần tự hóa các thuộc tính.

Đây là một ví dụ:

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

(Sao chép từ câu hỏi này )

Trong trường hợp tôi không có quyền kiểm soát JSON đến (và vì vậy không thể đảm bảo rằng nó bao gồm thuộc tính $ type) Tôi đã viết một trình chuyển đổi tùy chỉnh chỉ cho phép bạn xác định rõ ràng loại cụ thể:

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

Điều này chỉ sử dụng triển khai serializer mặc định từ Json.Net trong khi chỉ định rõ ràng loại cụ thể.

Một cái nhìn tổng quan có sẵn trên bài đăng blog này . Mã nguồn dưới đây:

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

Tại sao nên sử dụng bộ chuyển đổi? Có một chức năng riêng Newtonsoft.Jsonđể giải quyết vấn đề chính xác này:

Đặt TypeNameHandlingtrong JsonSerializerSettingsđểTypeNameHandling.Auto

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

Điều này sẽ đặt mọi loại vào json, không được coi là một thể hiện cụ thể của một loại mà là một giao diện hoặc một lớp trừu tượng.

Đảm bảo rằng bạn đang sử dụng cùng các cài đặt để tuần tự hóa và giải tuần tự hóa .

Tôi đã thử nó, và nó hoạt động như một lá bùa, thậm chí với các danh sách.

Kết quả tìm kiếm Kết quả web với các liên kết trang web

⚠️ CẢNH BÁO :

Chỉ sử dụng điều này cho json từ một nguồn được biết đến và đáng tin cậy. Người dùng snipsnipsnip đã đề cập chính xác rằng đây thực sự là một vunerability.

Xem CA 2328 và SCS0028 để biết thêm thông tin.

Nguồn và triển khai thủ công thay thế: Code Inside Blog

Để cho phép khử lưu trữ nhiều triển khai giao diện, bạn có thể sử dụng JsonConverter nhưng không thông qua một thuộc tính:

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

DTOJsonConverter ánh xạ từng giao diện với cách triển khai cụ thể:

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 chỉ được yêu cầu cho trình giải nén. Quá trình tuần tự hóa là không thay đổi. Đối tượng Json không cần nhúng tên loại cụ thể.

Bài đăng SO này cung cấp cùng một giải pháp một bước nữa với JsonConverter chung.

Sử dụng lớp này, để ánh xạ kiểu trừu tượng thành kiểu thực:

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

... và khi khử lưu huỳnh:

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

        JsonConvert.DeserializeObject(json, type, settings);

Nicholas Westby cung cấp một giải pháp tuyệt vời trong một bài viết tuyệt vời .

Nếu bạn muốn Deserializing JSON đến một trong nhiều lớp có thể thực hiện giao diện như thế:

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

Bạn có thể sử dụng trình chuyển đổi JSON tùy chỉnh:

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

Và bạn sẽ cần trang trí thuộc tính "Profession" bằng thuộc tính JsonConverter để cho nó biết sử dụng trình chuyển đổi tùy chỉnh của bạn:

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

Và sau đó, bạn có thể truyền lớp của mình bằng Giao diện:

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

Hai điều bạn có thể thử:

Thực hiện mô hình thử / phân tích cú pháp:

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

Hoặc, nếu bạn có thể làm như vậy trong mô hình đối tượng của mình, hãy triển khai một lớp cơ sở cụ thể giữa IPerson và các đối tượng lá của bạn và giải tuần tự hóa nó.

Cái đầu tiên có khả năng thất bại trong thời gian chạy, cái thứ hai yêu cầu thay đổi mô hình đối tượng của bạn và đồng nhất hóa đầu ra thành mẫu số chung thấp nhất.

Tôi thấy điều này hữu ích. Bạn cũng có thể

Cách sử dụng ví dụ

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

Chuyển đổi sáng tạo tùy chỉnh

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

Tài liệu của Json.NET

Đối với những người có thể tò mò về ConcreteListTypeConverter được Oliver tham chiếu, đây là nỗ lực của tôi:

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

Đối với những gì nó có giá trị, cuối cùng tôi đã phải tự mình xử lý việc này. Mỗi đối tượng có một phương thức Deserialize (chuỗi jsonStream) . Một vài đoạn của nó:

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

Trong trường hợp này, Thingy (chuỗi) mới là một hàm tạo sẽ gọi phương thức Deserialize (chuỗi jsonStream) của loại bê tông thích hợp. Lược đồ này sẽ tiếp tục đi xuống và đi xuống cho đến khi bạn đến các điểm cơ bản mà json.NET có thể xử lý.

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

Vv và Vv. Thiết lập này cho phép tôi cung cấp các thiết lập json.NET mà nó có thể xử lý mà không phải cấu trúc lại một phần lớn của thư viện hoặc sử dụng các mô hình thử / phân tích khó sử dụng có thể làm hỏng toàn bộ thư viện của chúng tôi do số lượng đối tượng liên quan. Điều đó cũng có nghĩa là tôi có thể xử lý hiệu quả mọi thay đổi json trên một đối tượng cụ thể và tôi không cần phải lo lắng về mọi thứ mà đối tượng chạm vào. Đây không phải là giải pháp lý tưởng, nhưng nó hoạt động khá tốt từ thử nghiệm tích hợp và đơn vị của chúng tôi.

Giả sử cài đặt tự động như sau:

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

Sau đó, giả sử lớp của bạn là như thế này:

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

Do đó, việc sử dụng trình phân giải trong khử lưu huỳnh có thể như sau:

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

Bạn có thể xem thêm chi tiết trong http://www.newtonsoft.com/json/help/html/DeserializeWithDependencyInjection.htmlm

Không có đối tượng sẽ không bao giờ được một IThingy như các giao diện đều là trừu tượng theo định nghĩa.

Đối tượng bạn có lần đầu tiên được đăng tuần tự là một loại cụ thể , thực hiện giao diện trừu tượng . Bạn cần phải có cùng bê tông lớp hồi sinh dữ liệu nối tiếp.

Các đối tượng kết quả sau đó sẽ có một số loại mà cụ các trừu tượng giao diện bạn đang tìm kiếm.

Từ tài liệu này, bạn có thể sử dụng

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

khi giải tuần tự hóa để thông báo cho JSON.NET về loại cụ thể.

Giải pháp của tôi cho vấn đề này, mà tôi thích bởi vì nó rất chung chung, như sau:

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

}

Rõ ràng, bạn có thể chuyển đổi nó thành một trình chuyển đổi tổng quát hơn bằng cách thêm một hàm tạo lấy một đối số kiểu Dictionary <Type, Type> để khởi tạo biến đối tượng chuyển đổi.

Vài năm và tôi đã có một vấn đề tương tự. Trong trường hợp của tôi, có các giao diện lồng nhau rất nhiều và ưu tiên tạo các lớp cụ thể trong thời gian chạy để nó hoạt động với một lớp chung.

Tôi quyết định tạo một lớp proxy trong thời gian chạy kết thúc đối tượng được trả lại bởi Newtonsoft.

Ưu điểm của phương pháp này là nó không yêu cầu triển khai cụ thể lớp và có thể tự động xử lý bất kỳ độ sâu nào của các giao diện lồng nhau. Bạn có thể xem thêm về nó trên blog của tôi .

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

        }
    }



}

Sử dụng:

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

Sử dụng JsonKnownTypes này , cách sử dụng rất giống nhau, nó chỉ cần thêm phân biệt đối xử vào json:

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

Bây giờ khi bạn tuần tự hóa đối tượng trong json sẽ được thêm "$type"bằng"myClass" giá trị và nó sẽ được sử dụng cho deserialize

Json:

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

Giải pháp của tôi đã được thêm các yếu tố giao diện trong hàm tạo.

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

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