C# 如何让JavaScriptSerializer将子对象视为普通的旧字符串？

我的程序中有JSON，如下所示：

{
    "Foo": "some string",
    "Bar": { "Quux" : 23 }
}

我如何使用

JavaScriptSerializer

来解析它，但将条值视为字符串而不是子对象？正如预期的那样，下面的代码引发了一个异常

反序列化之后，我希望

thing.Bar

包含字符串

{“Quux”：23}

。 有没有一个简单的方法来实现这一点

class Thing
{
    public string Foo { get; set; }
    public string Bar { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        string json = "{ \"Foo\": \"some string\", \"Bar\": { \"Quux\": 23 }}";
        var serializer = new JavaScriptSerializer();
        var thing = serializer.Deserialize<Thing>(json);
    }
}

类的东西
{
公共字符串Foo{get；set；}
公共字符串条{get；set；}
}
班级计划
{
静态void Main（字符串[]参数）
{
字符串json=“{\'Foo\”：\'some string\”，\'Bar\：{\'qux\“：23}}”；
var serializer=新的JavaScriptSerializer（）；
var thing=serializer.Deserialize（json）；
}
}

您是否尝试过引用栏中的内容

{
    "Foo": "some string",
    "Bar": "{ 'Quux' : 23 }"
}

---

您想实现自己的JavaScriptConverter来实现这一点。。。这里有一个例子

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Web.Script.Serialization;
using System.Collections.ObjectModel;

namespace ConsoleApplication1
{
    [Serializable]
    public class Thing
    {
        public string Foo { get; set; }
        public string Bar { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var json = "{\"Foo\":\"some string\",\"Bar\":{\"Quux\":23}}";
            var serializer = new JavaScriptSerializer();
            serializer.RegisterConverters(new JavaScriptConverter[] {
                new StringConverter()           
            });
            var thing = serializer.Deserialize<Thing>(json);

            Console.WriteLine(thing.Bar);
        }
    }

    public class StringConverter : JavaScriptConverter
    {
        public override IEnumerable<Type> SupportedTypes
        {
            get { return new ReadOnlyCollection<Type>(new List<Type>(new Type[] { typeof(string) })); }
        }

        public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            throw new NotImplementedException();
        }

        public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            var i = dictionary.First();
            return "{ \"" + i.Key + "\" : " + i.Value + " }";
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Xml；
使用System.Web.Script.Serialization；
使用System.Collections.ObjectModel；
命名空间控制台应用程序1
{
[可序列化]
公共类事物
{
公共字符串Foo{get；set；}
公共字符串条{get；set；}
}
班级计划
{
静态void Main（字符串[]参数）
{
var json=“{\'Foo\'：\'some string\'，\'Bar\'：{\'quox\'：23}}”；
var serializer=新的JavaScriptSerializer（）；
serializer.RegisterConverters（新的JavaScriptConverter[]{
新的StringConverter（）
});
var thing=serializer.Deserialize（json）；
控制台写入线（东西条）；
}
}
公共类StringConverter:JavaScriptConverter
{
公共覆盖IEnumerable SupportedTypes
{
获取{return new ReadOnlyCollection（new List（new Type[]{typeof（string）}））；}
}
公共重写IDictionary序列化（对象obj、JavaScriptSerializer序列化程序）
{
抛出新的NotImplementedException（）；
}
公共重写对象反序列化（IDictionary dictionary、类型、JavaScriptSerializer序列化程序）
{
var i=dictionary.First（）；
返回“{\”“+i.Key+”\：“+i.Value+”}”；
}
}
}

感谢您的回答，这非常有帮助。它对我提供的样品非常有效。不幸的是，Quux可能比23这样的数字更复杂，它可以是任何JSON对象，有自己的子对象和子对象。。。我在每个JavaScriptConverter实现中都看到了这一点：

返回新的ReadOnlyCollection（新列表（新类型[]{typeof（…）}））--为什么选择这样实现SupportedTypes属性？为什么不简单地
返回新的[]{typeof（string）}？我不太记得了，但我想这只是因为我懒惰，从其他地方剪切和粘贴代码：）。