C# 序列化另一个对象中的整数数组

我们使用一个自定义序列化程序将c#对象序列化为json格式，以便与REST API接口。API希望接收以下格式的数据：

    "product": {
        "sku": "211554",
        "extras": [{
                "code": "cost",
                "value": "3.99"
            }, {
                "code": "start_date",
                "value": "2017-01-31T14:27:49.3032432+00:00"
            }, {
                "code": "end_date",
                "value": "2017-02-01T14:27:49.3042537+00:00"
            }, {
                "code": "ids",
                "value": [
                    "1",
                    "2",
                    "3",
                    "19"
                ]
            }
        ]
    }

serialiser部分只返回来自的结果

JsonConvert.SerializeObject(obj, _Settings);

但结果是

"product": {
            "sku": "211554",
            "extras": [{
                    "code": "cost",
                    "value": "3.99"
                }, {
                    "code": "start_date",
                    "value": "2017-01-31T14:56:05.4683698+00:00"
                }, {
                    "code": "end_date",
                    "value": "2017-02-01T14:56:05.4693696+00:00"
                }, {
                    "code": "ids",
                    "value": "System.Int32[]"
                }
            ]
        }

序列化程序似乎在复杂的嵌套对象类型上工作得很好，但对于简单的嵌套类型，例如上面“ids”部分中的int数组，则不起作用

你知道需要做什么才能让序列化程序在简单嵌套类型上递归工作吗

更新

以下是自定义序列化程序：

        public class CustomSerializer : ISerializer, IDeserializer
        {
            private JsonSerializerSettings _Settings;

            public CustomSerializer()
            {
                ContentType = "application/json";

                _Settings = new JsonSerializerSettings
                {
                    MissingMemberHandling = MissingMemberHandling.Ignore,
                    NullValueHandling = NullValueHandling.Ignore,
                    DefaultValueHandling = DefaultValueHandling.Include
                };
            }


            public string Serialize(object obj)
            {
                var result = JsonConvert.SerializeObject(obj, _Settings);
                return result;
            }

            public T Deserialize<T>(IRestResponse response)
            {
                if (response == null) return default(T);
                if (response.Content.StartsWith("{\"messages\":{")) return default(T);

                return response.Content == "[]" ? default(T) : JsonConvert.DeserializeObject<T>(response.Content, _Settings);
            }

...

    }

var result = new CustomSerializer().Serialize(product);

公共类CustomSerializer:ISerializer、IDeserializer
{
私有JsonSerializerSettings\u设置；
公共CustomSerializer（）
{
ContentType=“应用程序/json”；
_设置=新JsonSerializerSettings
{
MissingMemberHandling=MissingMemberHandling.Ignore，
NullValueHandling=NullValueHandling.Ignore，
DefaultValueHandling=DefaultValueHandling。包括
};
}
公共字符串序列化（对象obj）
{
var result=JsonConvert.SerializeObject（obj，_设置）；
返回结果；
}
公共T反序列化（iRestreponse响应）
{
if（response==null）返回默认值（T）；
if（response.Content.StartsWith（“{\”messages\“：{”）返回默认值（T）；
返回response.Content==“[]”？默认值（T）：JsonConvert.DeserializeObject（response.Content，_设置）；
}
...
}

据我所知，这与您的自定义序列化程序无关。我假设问题在于您正在序列化的类以及如何创建它的实例，但由于您没有按照我的要求显示它，因此我无法确定地告诉您

我能做的是向您展示我如何创建正确序列化的类

要序列化的类：

    public class Extra
    {
        public string code { get; set; }
        public object value { get; set; }
    }

    public class Product
    {
        public string sku { get; set; }
        public List<Extra> extras { get; set; }
    }

    public class RootObject
    {
        public Product product { get; set; }
    }

json的输出

：

{
"product":{
    "sku":"211554",
    "extras":[
    {
        "code":"cost",
        "value":"3.99"
    },
    {
        "code":"start_date",
        "value":"2017-01-31T14:27:49.3032432+00:00"
    },
    {
        "code":"ids",
        "value":[
            1,
            2,
            3,
            19
        ]
    }
    ]
}
}

---

问题可能出在正在序列化的类型的定义中，特别是在定义“extras”属性的方式上。在没有看到该类型的情况下，我使用您发布的自定义序列化程序测试了以下内容，模拟了可能的实现：

public class Product
{
    public string SKU { get; set; }

    public ExtraInfo[] Extras { get; set; }

    public class ExtraInfo
    {
        public string Code { get; set; }
        public object Value { get; set; }
    }
}

要序列化的对象：

var product = new Product()
{
    SKU = "1234",
    Extras = new[]
    {
        new Product.ExtraInfo() { Code = "cost", Value = 3.99 },
        new Product.ExtraInfo() { Code = "ids", Value = new [] { 1, 2, 3 } }
    }
};

使用自定义序列化程序序列化：

        public class CustomSerializer : ISerializer, IDeserializer
        {
            private JsonSerializerSettings _Settings;

            public CustomSerializer()
            {
                ContentType = "application/json";

                _Settings = new JsonSerializerSettings
                {
                    MissingMemberHandling = MissingMemberHandling.Ignore,
                    NullValueHandling = NullValueHandling.Ignore,
                    DefaultValueHandling = DefaultValueHandling.Include
                };
            }


            public string Serialize(object obj)
            {
                var result = JsonConvert.SerializeObject(obj, _Settings);
                return result;
            }

            public T Deserialize<T>(IRestResponse response)
            {
                if (response == null) return default(T);
                if (response.Content.StartsWith("{\"messages\":{")) return default(T);

                return response.Content == "[]" ? default(T) : JsonConvert.DeserializeObject<T>(response.Content, _Settings);
            }

...

    }

var result = new CustomSerializer().Serialize(product);

结果JSON:

{  
   "SKU":"1234",
   "Extras":[  
      {  
         "Code":"cost",
         "Value":3.99
      },
      {  
         "Code":"ids",
         "Value":[  
            1,
            2,
            3
         ]
      }
   ]
}

---

问题似乎来自您使用的自定义序列化程序。您的示例JSON无效，并且您还没有显示

obj

的外观。我认为Serialise有一个ToString（）获取类型而不是值的某个地方。显示自定义序列化程序代码是因为值将类型从double、datetime更改为array吗？抱歉，在我发布我的时没有看到您的答案。您的速度更快，但我认为我们在同一页：）原来问题是由以前处理某些数据格式的深层次上引起的上面的序列化程序被调用。添加了一个额外的案例来正确管理它，现在它可以正常工作。我将您的标记为答案，因为这是一个可靠的解释，可能会帮助其他人。谢谢Equalsk