C# JsonConvert反序列化对象区分大小写

我试图将字符串内容反序列化为对象，但我希望内容区分大小写。只有当字符串具有小写属性时，代码才会成功；如果字符串具有大写属性，代码才会失败。课程内容如下：

internal class ResponseList
{
    [DataMember]
    [JsonProperty]
    internal List<Response> Value { get; set; }
}

internal class Response
{
    [DataMember]
    [JsonProperty]
    internal string Id { get; set; }

    [DataMember]
    [JsonProperty]
    internal string Location { get; set; }

    [DataMember]
    [JsonProperty]
    internal PlanClass Plan { get; set; }
}

internal class PlanClass
{
    [DataMember]
    [JsonProperty]
    internal string Name { get; set; }

    [DataMember]
    [JsonProperty]
    internal string Product { get; set; }

    [DataMember]
    [JsonProperty]
    internal string Publisher { get; set; }
}

只有在内容为以下情况下，代码才会成功：

{
  "value": [
    {
      "id": "id1",
      "location": "location1",
      "plan": {
        "name": "free",
        "product": "product1",
        "publisher": "publisher1"
      }
    }
    ]
}

即使其中一个键为大写，也会失败。例如

{
  "value": [
    {
      "Id": "id1",
      "Location": "location1",
      "plan": {
        "Name": "free",
        "product": "product1",
        "publisher": "publisher1"
      }
    }
    ]
}

请注意，只有键/属性名称应为小写。值可以是大写。

---

有没有办法使JsonConvert.Deserializeobject区分大小写

您可以编写自定义转换器来处理此用例。关于递归检查所有键名的需要，我使用了

var json=@“{”id“：”id1“，”name“：”name1“，”type“：”type1“}”；
var json2=@“{”id“：”id1“，”Name“：”name1“，”type“：”type1“}”；
JsonSerializerSettings设置=新建JsonSerializerSettings（）
{
ContractResolver=新的CamelCasePropertyNamesContractResolver（），
转换器=新列表{new CamelCaseOnlyConverter（）}
};
var response=JsonConvert.DeserializeObject（json，设置）；
var response2=JsonConvert.DeserializeObject（json2，设置）；
公共类CamelCaseOnlyConverter:JsonConverter
{
公共覆盖布尔CanConvert（类型objectType）
{
返回true；
}
公共重写对象ReadJson（JsonReader reader，类型objectType，
对象存在值，JsonSerializer序列化程序）
{
if（reader.TokenType==JsonToken.Null）
返回null；
var token=（JObject）JToken.Load（reader）；
var isCamelCased=真；
WalkNode（令牌，空，
t=>
{
var nameFirstChar=t.Name[0].ToString（）；
如果（！nameFirstChar.Equals）（nameFirstChar.ToLower（），
StringComparison.CurrentCulture）
{
isCamelCased=假；
返回；
}
});
如果（！isCamelCased）返回null；
返回token.ToObject（objectType）；
}
公共重写void WriteJson（JsonWriter writer，对象值，
JsonSerializer（序列化程序）
{
JObject o=（JObject）JToken.FromObject（值）；
o、 书面（作者）；
}
专用静态void WalkNode（JToken节点，
Action objectAction=null，
Action propertyAction=null）
{ 
if（node.Type==JTokenType.Object）
{
if（objectAction！=null）objectAction（（JObject）节点）；
foreach（node.Children（）中的JProperty子级）
{
如果（propertyAction！=null）propertyAction（子级）；
WalkNode（child.Value、objectAction、propertyAction）；
}
}
else if（node.Type==JTokenType.Array）
foreach（在node.Children（）中的JToken子节点）
WalkNode（子节点、objectAction、propertyAction）；
}
}

---

第一个字符串将返回水合对象。第二个字符串将提前终止，返回null。

@Romonov sure thing。更新后的答案将正确拒绝第二个字符串。这非常有效@罗蒙诺夫太棒了，很乐意帮忙：）

{
  "value": [
    {
      "Id": "id1",
      "Location": "location1",
      "plan": {
        "Name": "free",
        "product": "product1",
        "publisher": "publisher1"
      }
    }
    ]
}

var json = @"{""id"": ""id1"",""name"": ""name1"",""type"": ""type1""}";
var json2 = @"{""id"": ""id1"",""Name"": ""name1"",""type"": ""type1""}";

JsonSerializerSettings settings = new JsonSerializerSettings()
{
    ContractResolver = new CamelCasePropertyNamesContractResolver(),
    Converters = new List<JsonConverter> { new CamelCaseOnlyConverter() }
};

var response = JsonConvert.DeserializeObject<Response>(json, settings);
var response2 = JsonConvert.DeserializeObject<Response>(json2, settings);

public class CamelCaseOnlyConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return true;
    }

    public override object ReadJson(JsonReader reader, Type objectType, 
        object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
            return null;

        var token = (JObject)JToken.Load(reader);

        var isCamelCased = true;
        WalkNode(token, null,
        t =>
        {
            var nameFirstChar = t.Name[0].ToString();
            if (!nameFirstChar.Equals(nameFirstChar.ToLower(), 
                StringComparison.CurrentCulture))
            {
                isCamelCased = false;
                return;
            }
        });

        if (!isCamelCased) return null;

        return token.ToObject(objectType);
    }

    public override void WriteJson(JsonWriter writer, object value, 
        JsonSerializer serializer)
    {
        JObject o = (JObject)JToken.FromObject(value);
        o.WriteTo(writer);
    }

    private static void WalkNode(JToken node,
                            Action<JObject> objectAction = null,
                            Action<JProperty> propertyAction = null)
    { 
        if (node.Type == JTokenType.Object)
        {
            if (objectAction != null) objectAction((JObject)node);
            foreach (JProperty child in node.Children<JProperty>())
            {
                if (propertyAction != null) propertyAction(child);
                WalkNode(child.Value, objectAction, propertyAction);
            }
        }
        else if (node.Type == JTokenType.Array)
            foreach (JToken child in node.Children())
                WalkNode(child, objectAction, propertyAction);
    }
}