JavaScriptSerializer 在子类中使用“新”时抛出 AmbiguousMatchException

Question

我知道很多人都以某种方式面临同样的问题，但我感到困惑的是，Newtonsoft JSON Serializer 为何能够正确处理这种情况，而 JavaScriptSerializer 却无法做到。

我将使用在另一个 stackoverflow 线程 (JavascriptSerializer serializing property twice when "new" used in subclass) 中使用的相同代码示例

void Main()
{
    System.Web.Script.Serialization.JavaScriptSerializer serializer = new System.Web.Script.Serialization.JavaScriptSerializer();

    var json = serializer.Serialize(new Limited());
    Limited status = serializer.Deserialize<Limited>(json); --> throws AmbiguousMatchException
}

public class Full
{
    public String Stuff { get { return "Common things"; }  }
    public FullStatus Status { get; set; }

    public Full(bool includestatus)
    {
        if(includestatus)
            Status = new FullStatus();
    }
}

public class Limited : Full
{
    public new LimitedStatus Status { get; set; }

    public Limited() : base(false)
    {
        Status = new LimitedStatus();
    }
}

public class FullStatus 
{
    public String Text { get { return "Loads and loads and loads of things"; } }
}

public class LimitedStatus 
{
    public String Text { get { return "A few things"; } }
}

但如果我使用 Newtonsoft Json Serializer，一切正常。为什么？是否可以使用 JavaScriptSerializer 实现相同的目标？

void Main()
{
    var json = JsonConvert.SerializeObject(new Limited());
    Limited status = JsonConvert.DeserializeObject<Limited>(json);  ----> Works fine.
}

Answer 1

这在 Json.NET 中起作用的原因是它有特定的代码来处理这种情况。来自JsonPropertyCollection.cs：

/// <summary>
/// Adds a <see cref="JsonProperty"/> object.
/// </summary>
/// <param name="property">The property to add to the collection.</param>
public void AddProperty(JsonProperty property)
{
    if (Contains(property.PropertyName))
    {
        // don't overwrite existing property with ignored property
        if (property.Ignored)
            return;
        JsonProperty existingProperty = this[property.PropertyName];
        bool duplicateProperty = true;
        if (existingProperty.Ignored)
        {
            // remove ignored property so it can be replaced in collection
            Remove(existingProperty);
            duplicateProperty = false;
        }
        else
        {
            if (property.DeclaringType != null && existingProperty.DeclaringType != null)
            {
                if (property.DeclaringType.IsSubclassOf(existingProperty.DeclaringType))
                {
                    // current property is on a derived class and hides the existing
                    Remove(existingProperty);
                    duplicateProperty = false;
                }
                if (existingProperty.DeclaringType.IsSubclassOf(property.DeclaringType))
                {
                    // current property is hidden by the existing so don't add it
                    return;
                }
            }
        }
        if (duplicateProperty)
            throw new JsonSerializationException("A member with the name '{0}' already exists on '{1}'. Use the JsonPropertyAttribute to specify another name.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName, _type));
    }
    Add(property);
}

正如您在上面看到的，这里有特定的代码来优先选择派生类属性而不是具有相同名称和可见性的基类属性。

JavaScriptSerializer has no such logic。它只是调用Type.GetProperty(string, flags)

        PropertyInfo propInfo = serverType.GetProperty(memberName,
            BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);

在这种情况下这个方法是documented to throw an exception：

AmbiguousMatchException 发生的情况包括：

• 一个类型包含两个具有相同名称但参数数量不同的索引属性。要解决歧义，请使用指定参数类型的 GetProperty 方法的重载。

• 派生类型使用 new 修饰符（Visual Basic 中的阴影）声明一个隐藏同名继承属性的属性。要解决歧义，请包含 BindingFlags.DeclaredOnly 以将搜索限制为未继承的成员。

我不知道为什么微软没有为此添加逻辑到JavaScriptSerializer。这真的是一段非常简单的代码；也许它被DataContractJsonSerializer 黯然失色？

你确实有一个解决方法，就是写一个自定义的JavaScriptConverter：

public class LimitedConverter : JavaScriptConverter
{
    const string StuffName = "Stuff";
    const string StatusName = "Status";

    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        var limited = new Limited();
        object value;
        if (dictionary.TryGetValue(StuffName, out value))
        {
            // limited.Stuff = serializer.ConvertToType<string>(value); // Actually it's get only.
        }
        if (dictionary.TryGetValue(StatusName, out value))
        {
            limited.Status = serializer.ConvertToType<LimitedStatus>(value);
        }

        return limited;
    }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {
        var limited = (Limited)obj;
        if (limited == null)
            return null;
        var dict = new Dictionary<string, object>();
        if (limited.Stuff != null)
            dict.Add(StuffName, limited.Stuff);
        if (limited.Status != null)
            dict.Add(StatusName, limited.Status);
        return dict;
    }

    public override IEnumerable<Type> SupportedTypes
    {
        get { return new [] { typeof(Limited) } ; }
    }
}

然后像这样使用它：

        try
        {
            System.Web.Script.Serialization.JavaScriptSerializer serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
            serializer.RegisterConverters(new JavaScriptConverter[] { new LimitedConverter() });

            var json = serializer.Serialize(new Limited());
            Debug.WriteLine(json);
            var status = serializer.Deserialize<Limited>(json);
            var json2 = serializer.Serialize(status);
            Debug.WriteLine(json2);
        }
        catch (Exception ex)
        {
            Debug.Assert(false, ex.ToString()); // NO ASSERT.
        }