如何将数组反序列化为包装对象？

Question

我希望 Json.NET 反序列化器能够直接使用：ArrayWrapper[] Array { get; set; } 属性。

我应该写自定义JsonConverter 还是有更简单的方法？

public class Obj {

    //public ArrayWrapper[] Array { get; set; } // I want it to work!!!

    [JsonProperty( "array" )]
    public int[][] Array_ { get; set; }

    [JsonIgnore]
    public ArrayWrapper[] Array => Array_.Select( i => new ArrayWrapper( i ) ).ToArray();

}

public struct ArrayWrapper {

    private readonly int[] array;

    public int Item0 => array[ 0 ];
    public int Item1 => array[ 1 ];

    public ArrayWrapper(int[] array) {
        this.array = array;
    }

    public static implicit operator ArrayWrapper(int[] array) {
        return new ArrayWrapper( array );
    }
}

注意：数组数组由此 API 返回：https://github.com/binance-exchange/binance-official-api-docs/blob/master/rest-api.md#klinecandlestick-data。我想将内部数组转换为对象。

Answer 1

如果您只是想在代理包装器对象中捕获一个集合，那么最简单的方法是让包装器看起来是 Json.NET 的只读集合。为此，您必须：

• 为某些T（此处为int）实现IEnumerable<T>。
• 添加一个构造函数，该构造函数将IEnumerable<T> 用于相同的T。 （从实验来看，采用T [] 的构造函数是不够的。）

因此，如果您将ArrayWrapper 定义如下：

public struct ArrayWrapper : IEnumerable<int>
{
    private readonly int[] array;

    public int Item0 { get { return array[ 0 ]; } }
    public int Item1 { get { return array[ 1 ]; } }

    public ArrayWrapper(int[] array) {
        this.array = array;
    }

    public ArrayWrapper(IEnumerable<int> enumerable) 
    {
        this.array = enumerable.ToArray();
    }

    public static implicit operator ArrayWrapper(int[] array) {
        return new ArrayWrapper( array );
    }

    public IEnumerator<int> GetEnumerator()
    {
        return (array ?? Enumerable.Empty<int>()).GetEnumerator();
    }

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion
}

您将能够将Obj 序列化和反序列化为以下 JSON：

{"Array":[[1,101]]}

演示小提琴 #1 here.

但是，在您提到的 cmets 中，您的数组实际上有一个固定的架构，如 Public Rest API for Binance: Kline/Candlestick data 中所述。如果是这样，您可以采用从this answer 到 C#: Parsing a non-JSON array-only api response to a class object with x properties 的方法，该方法专门针对 Binance Kline/Candlestick 数据：

• 为您的数据定义明确的数据模型。
• 用[JsonProperty(Order = N)] 标记每个属性以指示相对数组位置。 （可以改用[DataContract] 和[DataMember(Order = N)]。）
• 使用转换器ObjectToArrayConverter<ArrayWrapper>() 从this answer 到C# JSON.NET - Deserialize response that uses an unusual data structure。

即对于您问题中显示的具体模型，修改其定义如下：

[JsonConverter(typeof(ObjectToArrayConverter<ArrayWrapper>))]
public struct ArrayWrapper
{
    [JsonProperty(Order = 1)]
    public int Item0 { get; set; }
    [JsonProperty(Order = 2)]
    public int Item1 { get; set; }
}

您将能够（反）序列化相同的 JSON。请注意，转换器是完全通用的，并且可以在将具有固定模式的数组（反）序列化为对象的模式出现时重复使用。

（您可能还想将struct 更改为class，因为可变结构是discouraged。）

演示小提琴 #2 here 和 #3 here 显示了将 JsonConverter 属性应用于可序列化属性之一。

Answer 2

我制作了我的ArrayToObjectConverter 版本。

我的ArrayToObjectConverter 只需将JArray 转换为JObject 属性：Item1、Item2、Item3... 并反序列化此对象。

public class ArrayToObjectConverter : JsonConverter {

    public override bool CanRead => true;
    public override bool CanWrite => true;


    public override bool CanConvert(Type type) {
        return false;
    }

    public override object ReadJson(JsonReader reader, Type type, object existingInstance, JsonSerializer serializer) {
        var contract = (JsonObjectContract) serializer.ContractResolver.ResolveContract( type );
        var instance = existingInstance ?? contract.DefaultCreator();

        var array = JArray.Load( reader );
        var obj = Convert( array );
        serializer.Populate( obj.CreateReader(), instance );
        return instance;
    }

    public override void WriteJson(JsonWriter writer, object instance, JsonSerializer serializer) {
        var contract = (JsonObjectContract) serializer.ContractResolver.ResolveContract( instance.GetType() );
        var properties = contract.Properties.Where( IsSerializable );

        var values = properties.Select( i => i.ValueProvider.GetValue( instance ) );
        serializer.Serialize( writer, values );
    }


    // Helpers
    private static JObject Convert(JArray array) {
        var obj = new JObject();
        for (var i = 0; i < array.Count; i++) {
            obj.Add( "Item" + i, array[ i ] );
        }
        return obj;
    }

    private static bool IsSerializable(JsonProperty property) {
        return !property.Ignored && property.Readable && property.Writable;
    }


}

您应该将ArrayToObjectConverter 与这样的对象一起使用：

[JsonConverter( typeof( ArrayToObjectConverter ) )]
public class Obj {

    [JsonProperty]
    internal string Item0 { get; set; }
    [JsonProperty]
    internal decimal Item1 { get; set; }

    [JsonIgnore]
    public string Text { get => Item0; set => Item0 = value; }
    [JsonIgnore]
    public decimal Number { get => Item1; set => Item1 = value; }

}

只有我不确定JsonObjectContract.Properties 是否总是有正确的顺序。