Question

我知道很多人都以这种或那种方式面临着同样的问题，但我很困惑的是，在JavaScriptSerializer无法实现的情况下，Newtonsoft JSON Serializer如何才能正确处理这种情况。 / p>

我将使用另一个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中的Shadows）声明一个隐藏具有相同名称的继承属性的属性。要解决歧义，请包括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.
        }

当子类中使用“new”时，JavaScriptSerializer抛出AmbiguousMatchException

1 个答案: