Newtonsoft.JSON 无法转换具有 TypeConverter 属性的模型

Question

我有一个 C# MVC 应用程序，它将数据作为 JSON 字符串存储在 XML 文档和 MySQL DB 表中。

最近我收到了在MySQL数据库字段中存储JSON字符串的需求，通过Newtonsoft.Json转换成C#对象，所以我决定实现一个TypeConverter将 JSON 字符串转换为自定义 C# 模型。

不幸的是，当 TypeConverter 属性添加到我的 C# 模型时，我无法在解决方案中的任何地方使用以下命令来反序列化我的 JSON 字符串：

JsonConvert.DeserializeObject<Foo>(json);

删除该属性可解决问题，但这会阻止我将 MySQL DB 字段转换为自定义 C# 对象。

这是我添加了 TypeConverter 属性的 C# 模型：

using System.ComponentModel;

[TypeConverter(typeof(FooConverter))]
public class Foo
{
    public bool a { get; set; }
    public bool b { get; set; }
    public bool c { get; set; }
    public Foo(){}
}

这是我的 TypeConverter 类：

using Newtonsoft.Json;
using System;
using System.ComponentModel;

    public class FooConverter : TypeConverter
    {
        public override bool CanConvertFrom(ITypeDescriptorContext context, System.Type sourceType)
        {
            if (sourceType == typeof(string))
            {
                return true;
            }
            return base.CanConvertFrom(context, sourceType);
        }
        public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
        {
            if (value is string)
            {
                string s = value.ToString().Replace("\\","");
                Foo f = JsonConvert.DeserializeObject<Foo>(s);
                return f;
            }
            return base.ConvertFrom(context, culture, value);
        }
    }
}

将属性添加到 Foo 类后，我立即收到以下错误：

无法将当前 JSON 对象（例如 {"name":"value"}）反序列化为“Models.Foo”类型，因为该类型需要 JSON 字符串值才能正确反序列化。

要修复此错误，要么将 JSON 更改为 JSON 字符串值，要么将反序列化类型更改为正常的 .NET 类型（例如，不是像整数这样的原始类型，而不是像数组这样的集合类型或List) 可以从 JSON 对象反序列化。 JsonObjectAttribute 也可以添加到类型中，以强制它从 JSON 对象反序列化。

我正在使用以下字符串（无需添加 TypeConverter 属性即可完美运行）：

"{\"Foo\":{\"a\":true,\"b\":false,\"c\":false}}"

不知道这里发生了什么，有什么想法吗？

非常感谢！！！

更新

我发现在接受 Test Class with Foo 作为属性 的 MVC API 控制器 或接受 的控制器上的操作也存在问题当 TypeConverter 属性 被添加到 Foo 类时，Foo 作为一个对象。

这是一个有问题的测试控制器示例：

public class TestController : ApiController
{
    [AcceptVerbs("POST", "GET")]
    public void PostTestClass(TestClass t)
    {
        // Returns null when TypeConverter attribute is added to the Foo Class
        return t.Foo; 
    }
    AcceptVerbs("POST", "GET")]
    public void PostFooObj(Foo f)
    {
        // Returns null when TypeConverter attribute is added to the Foo Class
        return f;
    }
}

当上述任一操作通过 AJAX 接收具有以下结构的 JSON 时，TypeConverter 可能会导致覆盖 WebAPI 模型绑定的问题并返回 null：

// eg. PostTestClass(TestClass T)
{'Foo': {'a': false,'b': true,'c': false}};

// eg. PostFooObj(Foo f)
{'a': false,'b': true,'c': false}

将TypeConverter Attribute添加到Foo类时，一旦找到路由，就会调用FooConverter TypeConverter类上的以下方法：

    public override bool CanConvertFrom(ITypeDescriptorContext context, System.Type sourceType)
    {
        if (sourceType == typeof(string))
        {
            return true;
        }
        return base.CanConvertFrom(context, sourceType);
    }

ApiController 的操作未调用 FooConverter TypeController 上的 ConvertFrom 方法，这可能是问题的原因。

这也是类似的情况，没有 TypeConverter 属性，控制器的操作也可以正常工作。

非常感谢任何进一步的帮助！

非常感谢。

Answer 1

如果您的结构不是类，则在尝试（反）序列化 Nullable<Foo> 时，接受的答案仍将进入无限递归。

为避免如下修改 CreateContract：

        protected override JsonContract CreateContract(Type objectType)
        {
            if (typeof(T).IsAssignableFrom(objectType)
                || Nullable.GetUnderlyingType(objectType) != null && typeof(T).IsAssignableFrom(Nullable.GetUnderlyingType(objectType)))
            {
                var contract = this.CreateObjectContract(objectType);
                contract.Converter = null; // Also null out the converter to prevent infinite recursion.
                return contract;
            }
            return base.CreateContract(objectType);
        }

Answer 2

避免这种行为的简单方法是从转换检查中删除 OR 即删除 || destinationType == typeof(string)

下面的例子..

    public class DepartmentBindModelConverter : TypeConverter
    {
        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        {
            return destinationType == typeof(DepartmentViewModel); // Removed || destinationType == typeof(string), to allow newtonsoft json convert model with typeconverter attribute
        }

        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (value == null)
                return null;

            if (destinationType == typeof(DepartmentViewModel) && value is DepartmentBindModel)
            {
                var department = (DepartmentBindModel) value;

                return new DepartmentViewModel
                {
                    Id = department.Id,
                    Name = department.Name,
                    GroupName = department.GroupName,
                    ReturnUrl = department.ReturnUrl
                };

            }

            return base.ConvertTo(context, culture, value, destinationType);
        }
    }
}

Answer 3

这里发生了一些事情。首先，一个初步的问题：即使没有应用TypeConverter，你的JSON也不对应你的类Foo，它对应于一些包含Foo属性的容器类，例如：

public class TestClass
{
    public Foo Foo { get; set; }
}

即鉴于您的 JSON 字符串，以下内容将不起作用：

var json = "{\"Foo\":{\"a\":true,\"b\":false,\"c\":false}}";
var foo = JsonConvert.DeserializeObject<Foo>(json);

但以下会：

var test = JsonConvert.DeserializeObject<TestClass>(json);

我怀疑这只是问题中的一个错误，所以我假设您正在寻找反序列化包含属性 Foo 的类。

您看到的主要问题是 Json.NET 如果存在 TypeConverter 将尝试使用 TypeConverter 将要序列化的类转换为 JSON 字符串。来自docs：

原始类型

.Net：TypeConverter（可转换为字符串）
JSON：字符串

但是在您的 JSON 中，Foo 不是 JSON 字符串，它是 JSON 对象，因此一旦应用类型转换器，反序列化就会失败。嵌入的字符串如下所示：

{"Foo":"{\"a\":true,\"b\":false,\"c\":false}"}

注意所有引号是如何被转义的。即使您更改了 Foo 对象的 JSON 格式以匹配此，您的反序列化仍然会失败，因为 TypeConverter 和 Json.NET 尝试递归地相互调用。

因此，您需要做的是全局禁用 Json.NET 对 TypeConverter 的使用并回退到默认序列化，同时在所有其他情况下保留使用 TypeConverter。这有点棘手，因为没有 Json.NET attribute 可以申请禁用类型转换器，而是需要一个特殊的合约解析器加上一个特殊的 JsonConverter 才能使用它：

public class NoTypeConverterJsonConverter<T> : JsonConverter
{
    static readonly IContractResolver resolver = new NoTypeConverterContractResolver();

    class NoTypeConverterContractResolver : DefaultContractResolver
    {
        protected override JsonContract CreateContract(Type objectType)
        {
            if (typeof(T).IsAssignableFrom(objectType))
            {
                var contract = this.CreateObjectContract(objectType);
                contract.Converter = null; // Also null out the converter to prevent infinite recursion.
                return contract;
            }
            return base.CreateContract(objectType);
        }
    }

    public override bool CanConvert(Type objectType)
    {
        return typeof(T).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        return JsonSerializer.CreateDefault(new JsonSerializerSettings { ContractResolver = resolver }).Deserialize(reader, objectType);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        JsonSerializer.CreateDefault(new JsonSerializerSettings { ContractResolver = resolver }).Serialize(writer, value);
    }
}

并像这样使用它：

[TypeConverter(typeof(FooConverter))]
[JsonConverter(typeof(NoTypeConverterJsonConverter<Foo>))]
public class Foo
{
    public bool a { get; set; }
    public bool b { get; set; }
    public bool c { get; set; }
    public Foo() { }
}

public class FooConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, System.Type sourceType)
    {
        if (sourceType == typeof(string))
        {
            return true;
        }
        return base.CanConvertFrom(context, sourceType);
    }
    public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
    {
        if (value is string)
        {
            string s = value.ToString();
            //s = s.Replace("\\", "");
            Foo f = JsonConvert.DeserializeObject<Foo>(s);
            return f;
        }
        return base.ConvertFrom(context, culture, value);
    }
}

例如fiddle。

最后，您可能还应该在类型转换器中实现ConvertTo 方法，请参阅How to: Implement a Type Converter。