JavaScriptSerializer和ASP.Net MVC模型绑定产生不同的结果

时间：2012-01-22 20:57:52

标签： json asp.net-mvc-3 model-binding

我看到了JSON反序列化问题，我无法解释或修复。

代码

public class Model
{
    public List<ItemModel> items { get; set; }
}
public class ItemModel
{

    public int sid { get; set; }
    public string name { get; set; }
    public DataModel data { get; set; }
    public List<ItemModel> items { get; set; }
}

public class DataModel
{
    public double? d1 { get; set; }
    public double? d2 { get; set; }
    public double? d3 { get; set; }
}

public ActionResult Save(int id, Model model) {
}

数据

{'items':[{'sid':3157,'name':'a name','items':[{'sid':3158,'name':'child name','data':{'d1':2,'d2':null,'d3':2}}]}]}

单元测试 - 通过

var jss = new JavaScriptSerializer();
var m = jss.Deserialize<Model>(json);
Assert.Equal(2, m.items.First().items.First().data.d1);

问题

相同的JSON字符串在发送到Save操作时，不会以相同的方式反序列化，特别是D1，D2和D3值都设置为NULL。总是

这里发生了什么，我该如何解决？

2 个答案:

答案 0 :(得分：27)

这听起来可能违反直觉，但你应该将这些双打作为字符串发送到json：

'data':{'d1':'2','d2':null,'d3':'2'}

这是我完整的测试代码，它使用AJAX调用此控制器操作，并允许绑定到模型的每个值：

$.ajax({
    url: '@Url.Action("save", new { id = 123 })',
    type: 'POST',
    contentType: 'application/json',
    data: JSON.stringify({
        items: [
            {
                sid: 3157,
                name: 'a name',
                items: [
                    {
                        sid: 3158,
                        name: 'child name',
                        data: {
                            d1: "2",
                            d2: null,
                            d3: "2"
                        }
                    }
                ]
            }
        ]
    }),
    success: function (result) {
        // ...
    }
});

为了说明尝试从JSON反序列化数字类型的问题的程度，让我们举几个例子：

  • public double? Foo { get; set; }
    • { foo: 2 } =＆gt; Foo = null
    • { foo: 2.0 } =＆gt; Foo = null
    • { foo: 2.5 } =＆gt; Foo = null
    • { foo: '2.5' } =＆gt; Foo = 2.5
  • public float? Foo { get; set; }
    • { foo: 2 } =＆gt; Foo = null
    • { foo: 2.0 } =＆gt; Foo = null
    • { foo: 2.5 } =＆gt; Foo = null
    • { foo: '2.5' } =＆gt; Foo = 2.5
  • public decimal? Foo { get; set; }
    • { foo: 2 } =＆gt; Foo = null
    • { foo: 2.0 } =＆gt; Foo = null
    • { foo: 2.5 } =＆gt; Foo = 2.5
    • { foo: '2.5' } =＆gt; Foo = 2.5

现在让我们对非可空类型做同样的事情：

  • public double Foo { get; set; }
    • { foo: 2 } =＆gt; Foo = 2.0
    • { foo: 2.0 } =＆gt; Foo = 2.0
    • { foo: 2.5 } =＆gt; Foo = 2.5
    • { foo: '2.5' } =＆gt; Foo = 2.5
  • public float Foo { get; set; }
    • { foo: 2 } =＆gt; Foo = 2.0
    • { foo: 2.0 } =＆gt; Foo = 2.0
    • { foo: 2.5 } =＆gt; Foo = 2.5
    • { foo: '2.5' } =＆gt; Foo = 2.5
  • public decimal Foo { get; set; }
    • { foo: 2 } =＆gt; Foo = 0
    • { foo: 2.0 } =＆gt; Foo = 0
    • { foo: 2.5 } =＆gt; Foo = 2.5
    • { foo: '2.5' } =＆gt; Foo = 2.5

结论：从JSON反序列化数字类型是一个很大的混乱。在JSON中使用字符串。当然，当您使用字符串时，请注意小数分隔符，因为它取决于文化。

我在评论部分询问为什么这会通过单元测试，但在ASP.NET MVC中不起作用。答案很简单：这是因为ASP.NET MVC做的不仅仅是对JavaScriptSerializer.Deserialize的简单调用，这是单元测试的作用。所以你基本上把苹果和橘子比较。

让我们深入了解会发生什么。在ASP.NET MVC 3中有一个内置的JsonValueProviderFactory，它在内部使用JavaScriptDeserializer类来反序列化JSON。正如您已经看到的，这在单元测试中有效。但是在ASP.NET MVC中还有更多内容，因为它还使用了一个默认的模型绑定器来负责实例化你的动作参数。

如果你看一下ASP.NET MVC 3的源代码，更具体地说是DefaultModelBinder.cs类，你会注意到为每个具有要设置值的属性调用的以下方法：

public class DefaultModelBinder : IModelBinder {

    ...............

    [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.Mvc.ValueProviderResult.ConvertTo(System.Type)", Justification = "The target object should make the correct culture determination, not this method.")]
    [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We're recording this exception so that we can act on it later.")]
    private static object ConvertProviderResult(ModelStateDictionary modelState, string modelStateKey, ValueProviderResult valueProviderResult, Type destinationType) {
        try {
            object convertedValue = valueProviderResult.ConvertTo(destinationType);
            return convertedValue;
        }
        catch (Exception ex) {
            modelState.AddModelError(modelStateKey, ex);
            return null;
        }
    }

    ...............

}

让我们更专注于以下几行：

object convertedValue = valueProviderResult.ConvertTo(destinationType);

如果我们假设你有一个Nullable<double>类型的属性，那么调试你的应用程序时会出现这种情况：

destinationType = typeof(double?);

这里没有惊喜。我们的目标类型是double?，因为这是我们在视图模型中使用的。

然后看看valueProviderResult：

enter image description here

在那里看到这个RawValue财产？你猜它的类型吗？

enter image description here

因此，此方法只会抛出异常，因为它显然无法将decimal的{​​{1}}值转换为2.5。

您是否注意到在这种情况下返回的值是多少？这就是为什么你最终在模型中使用double?。

这很容易验证。只需检查控制器操作中的null属性，您就会注意到它是ModelState.IsValid。当您检查添加到模型状态的模型错误时，您将看到：

  

参数从类型'System.Decimal'转换为type   'System.Nullable`1 [[System.Double，mscorlib，Version = 4.0.0.0，   Culture = neutral，PublicKeyToken = b77a5c561934e089]]'失败，因为没有   类型转换器可以在这些类型之间进行转换。

您现在可能会问，“但为什么RawValue属性在ValueProviderResult中的decimal类型？”。答案再次出现在ASP.NET MVC 3源代码中（是的，你现在应该已经下载了它）。我们来看看false文件，更具体地说是JsonValueProviderFactory.cs方法：

GetDeserializedObject

您是否注意到以下行：

public sealed class JsonValueProviderFactory : ValueProviderFactory {

    ............

    private static object GetDeserializedObject(ControllerContext controllerContext) {
        if (!controllerContext.HttpContext.Request.ContentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase)) {
            // not JSON request
            return null;
        }

        StreamReader reader = new StreamReader(controllerContext.HttpContext.Request.InputStream);
        string bodyText = reader.ReadToEnd();
        if (String.IsNullOrEmpty(bodyText)) {
            // no JSON data
            return null;
        }

        JavaScriptSerializer serializer = new JavaScriptSerializer();
        object jsonData = serializer.DeserializeObject(bodyText);
        return jsonData;
    }

    ............

}

您能猜出您的控制台上会打印以下代码段吗？

JavaScriptSerializer serializer = new JavaScriptSerializer();
object jsonData = serializer.DeserializeObject(bodyText);

是的，你猜对了，它是var serializer = new JavaScriptSerializer(); var jsonData = (IDictionary<string, object>)serializer .DeserializeObject("{\"foo\":2.5}"); Console.WriteLine(jsonData["foo"].GetType()); 。

您现在可能会问，“但为什么他们使用serializer.DeserializeObject方法而不是serializer.Deserialize在我的单元测试中？”这是因为ASP.NET MVC团队做出了使用decimal实现JSON请求绑定的设计决策，ValueProviderFactory不知道模型的类型。

现在看看您的单元测试与ASP.NET MVC 3的实际情况完全不同？通常应该解释为什么它通过，以及为什么控制器动作没有得到正确的模型值？

答案 1 :(得分：0)

解决方案1：传递标记为＆＃34; application / x-www-form-urlencoded＆＃34;的数据。在这种情况下，Nullable<double>被正确反序列化。 例如：

<script type="text/javascript">

$("#post-data").click(function () {
    $.ajax({
        url: "/info/create",
        type: "PUT",
        //  contentType: 'application/json', //default is application/x-www-form-urlencoded
        data: JSON.stringify({
            Dbl1: null, //pass double as null
            Dbl2: 56.3  //pass double with value
        }),
        dataType: "json"
    });

    return false;
});

解决方案2：改变双倍？小数？并将内容发送为＆＃34; application / json＆＃34;。感谢Darin的调查

相关问题
最新问题