反序列化时的备用属性名称

Question

关于这个问题：

使用Json.net进行序列化时，如何更改属性名称？

当然，太好了，但我能吃蛋糕吗？

我正在寻找的是一种令人赏心悦目的方式，即为属性指定一个替代名称，使字符串可以包含其中任何一个。

类似于：

[BetterJsonProperty(PropertyName = "foo_bar")]
public string FooBar { get; set; }

两个

{
     "FooBar": "yup"
}

和

{     
      "foo_bar":"uhuh"
}

将按预期反序列化。

因为没有属性的解决方案可以工作，或者类上有一个属性，比如：

 [AllowCStylePropertyNameAlternatives]

Answer 1

实现这一点的一种方法是创建一个自定义JsonConverter。这个想法是让转换器为我们感兴趣的对象枚举JSON属性名称，从名称中去掉非字母数字字符，然后尝试通过反射将它们与实际的对象属性匹配。以下是它在代码中的样子：

public class LaxPropertyNameMatchingConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType.IsClass;
    }
    public override bool CanWrite
    {
        get { return false; }
    }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        object instance = objectType.GetConstructor(Type.EmptyTypes).Invoke(null);
        PropertyInfo[] props = objectType.GetProperties();
        JObject jo = JObject.Load(reader);
        foreach (JProperty jp in jo.Properties())
        {
            string name = Regex.Replace(jp.Name, "[^A-Za-z0-9]+", "");
            PropertyInfo prop = props.FirstOrDefault(pi => 
                pi.CanWrite && string.Equals(pi.Name, name, StringComparison.OrdinalIgnoreCase));
            if (prop != null)
                prop.SetValue(instance, jp.Value.ToObject(prop.PropertyType, serializer));
        }
        return instance;
    }
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

要将自定义转换器与特定的类一起使用，可以使用[JsonConverter]属性来装饰该类，如下所示：

[JsonConverter(typeof(LaxPropertyNameMatchingConverter))]
public class MyClass
{
    public string MyProperty { get; set; }
    public string MyOtherProperty { get; set; }
}

下面是一个转换器的简单演示：

class Program
{
    static void Main(string[] args)
    {
        string json = @"
        [
            { 
                ""my property"" : ""foo"",
                ""my-other-property"" : ""bar"",
            },
            { 
                ""(myProperty)"" : ""baz"",
                ""myOtherProperty"" : ""quux""
            },
            { 
                ""MyProperty"" : ""fizz"",
                ""MY_OTHER_PROPERTY"" : ""bang""
            }
        ]";
        List<MyClass> list = JsonConvert.DeserializeObject<List<MyClass>>(json);
        foreach (MyClass mc in list)
        {
            Console.WriteLine(mc.MyProperty);
            Console.WriteLine(mc.MyOtherProperty);
        }
    }
}

输出：

foo
bar
baz
quux
fizz
bang

虽然这个解决方案在大多数情况下都可以完成任务，但如果您同意更改Json的想法，还有一个更简单的解决方案。Net源代码直接。事实证明，只需向Newtonsoft.Json.Serialization.JsonPropertyCollection类添加一行代码就可以完成同样的事情。在这个类中，有一个名为GetClosestMatchProperty()的方法，它看起来像这样：

public JsonProperty GetClosestMatchProperty(string propertyName)
{
    JsonProperty property = GetProperty(propertyName, StringComparison.Ordinal);
    if (property == null)
        property = GetProperty(propertyName, StringComparison.OrdinalIgnoreCase);
    return property;
}

在反序列化程序调用此方法时，JsonPropertyCollection包含要反序列化的类的所有属性，propertyName参数包含要匹配的JSON属性名的名称。正如您所看到的，该方法首先尝试精确的名称匹配，然后尝试不区分大小写的匹配。因此，我们已经在JSON和类属性名称之间进行了多对一映射。

如果您修改此方法以在匹配属性名称之前从属性名称中删除所有非字母数字字符，那么您可以获得所需的行为，而不需要任何特殊的转换器或属性。这是修改后的代码：

public JsonProperty GetClosestMatchProperty(string propertyName)
{
    propertyName = Regex.Replace(propertyName, "[^A-Za-z0-9]+", "");
    JsonProperty property = GetProperty(propertyName, StringComparison.Ordinal);
    if (property == null)
        property = GetProperty(propertyName, StringComparison.OrdinalIgnoreCase);
    return property;
}

当然，修改源代码也有问题，但我认为值得一提。

Answer 2

实现这一点的另一种方法是通过重写JsonReader和JsonWriter ，尽早拦截序列化/反序列化过程

public class CustomJsonWriter : JsonTextWriter
{
    private readonly Dictionary<string, string> _backwardMappings;
    public CustomJsonWriter(TextWriter writer, Dictionary<string, string> backwardMappings)
        : base(writer)
    {
        _backwardMappings = backwardMappings;
    }
    public override void WritePropertyName(string name)
    {
        base.WritePropertyName(_backwardMappings[name]);
    }
}
public class CustomJsonReader : JsonTextReader
{
    private readonly Dictionary<string, string> _forwardMappings;

    public CustomJsonReader(TextReader reader, Dictionary<string, string> forwardMappings )
        : base(reader)
    {
        _forwardMappings = forwardMappings;
    }
    public override object Value
    {
        get
        {
            if (TokenType != JsonToken.PropertyName)
                return base.Value;
            return _forwardMappings[base.Value.ToString()];
        }
    }
}

完成此操作后，您可以通过执行进行序列化

var mappings = new Dictionary<string, string>
{
    {"Property1", "Equivalent1"},
    {"Property2", "Equivalent2"},
};
var builder = new StringBuilder();
JsonSerializer.Create().Serialize(new CustomJsonWriter(new StringWriter(builder), mappings), your_object);

并通过进行反序列化

var mappings = new Dictionary<string, string>
{
    {"Equivalent1", "Property1"},
    {"Equivalent2", "Property2"},
};
var txtReader = new CustomJsonReader(new StringReader(jsonString), mappings);
var your_object = JsonSerializer.Create().Deserialize<Your_Type>(txtReader);