C# 基于属性的模型部分序列化

我正在寻找一种使用Json将模型部分序列化为Json的方法。我想在父对象的属性上定义部分序列化的外观。因此，对于不同的父模型，部分序列化看起来可能不同。为了说明我在这里想要的内容，请使用以下代码：

private class MyTestObject
{
    [SerializeOnly("TestValue1")]
    [SerializeOnly("TestValue3")]
    public ComplexTestObject Property1 { get; set; }

    public MyTestObject()
    {
       Property1 = new ComplexTestObject();
    }
}

private class ComplexTestObject
{
    public string TestValue1 { get; set; }
    public string TestValue2 { get; set; }
    public string TestValue3 { get; set; }
    public ComplexTestObject()
    {
        TestValue1 = "value1";
        TestValue2 = "value2";
        TestValue3 = "value3";
    }
}

现在，当我序列化类

MyTestObject

的实例时，我希望得到以下Json：

{
    "Property1" : {
        "TestValue1" : "value1",
        "TestValue3" : "value3",
    }
}

您可以看到，

SerializeOnly

用于定义要序列化的属性

为了实现这一点，我可以创建一个

SerializeOnlyAttribute

。在自定义Serialization ContractResolver中尝试使用时，我只能看到特定成员的属性，因此无法看到任何

SerializationOnlyAttribute

，因为它们位于父级

有没有一种简单的方法可以通过Json.Net实现所需的行为？编写自定义JsonConverter是可能的，但是如何构建这样一个自定义JsonConverter，以便只处理属性，而仍然使用默认的转换器？

C#已经有了一个属性来帮助您完成这项工作

---

您可以通过两个部分来解决此问题：

• 创建可以接受要序列化的属性名称列表的自定义JsonConverter
• 创建一个自定义ContractResolver，用于查找至少应用了一个

  [SerializeOnly]

  属性的属性，并将自定义转换器应用于这些属性，传递从应用属性收集的子属性名称列表

以下是解析程序的外观：

class CustomResolver : DefaultContractResolver
{
    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        IList<JsonProperty> props = base.CreateProperties(type, memberSerialization);
        foreach (JsonProperty prop in props)
        {
            if (!prop.PropertyType.IsPrimitive && prop.PropertyType != typeof(string))
            {
                PropertyInfo pi = type.GetProperty(prop.UnderlyingName);
                if (pi != null && pi.CanRead)
                {
                    var childPropertiesToSerialize = pi.GetCustomAttributes<SerializeOnly>()
                                                       .Select(att => att.PropertyName);
                    if (childPropertiesToSerialize.Any())
                    {
                        prop.Converter = new CustomConverter(childPropertiesToSerialize);
                    }
                }
            }
        }
        return props;
    }
}

输出：

{
  "Property1": {
    "TestValue1": "value1",
    "TestValue3": "value3"
  },
  "Property2": {
    "TestValue2": "value2"
  }
}

---

Fiddle:

首先在Json.Net中，这将是[JsonIgnore]。其次，完整属性没有序列化，但我想部分序列化它。我想定义父母的行为！令人惊叹的！我喜欢这个解决方案！Thx:-）没问题；很高兴我能帮忙。

class CustomConverter : JsonConverter
{
    private HashSet<string> propertiesToSerialize;

    public CustomConverter(IEnumerable<string> propertiesToSerialize)
    {
        this.propertiesToSerialize = new HashSet<string>(propertiesToSerialize);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        writer.WriteStartObject();
        foreach (PropertyInfo prop in value.GetType().GetProperties())
        {
            if (prop.CanRead && propertiesToSerialize.Contains(prop.Name))
            {
                writer.WritePropertyName(prop.Name);
                serializer.Serialize(writer, prop.GetValue(value));
            }
        }
        writer.WriteEndObject();
    }

    public override bool CanRead
    {
        get { return false; }
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override bool CanConvert(Type objectType)
    {
        throw new NotImplementedException();
    }
}

class Program
{
    static void Main(string[] args)
    {
        var test = new MyTestObject();
        var settings = new JsonSerializerSettings();
        settings.ContractResolver = new CustomResolver();
        settings.Formatting = Formatting.Indented;
        var json = JsonConvert.SerializeObject(test, settings);
        Console.WriteLine(json);
    }

    class MyTestObject
    {
        [SerializeOnly("TestValue1")]
        [SerializeOnly("TestValue3")]
        public ComplexTestObject Property1 { get; set; }

        [SerializeOnly("TestValue2")]
        public ComplexTestObject Property2 { get; set; }

        public MyTestObject()
        {
            Property1 = new ComplexTestObject();
            Property2 = new ComplexTestObject();
        }
    }

    class ComplexTestObject
    {
        public string TestValue1 { get; set; }
        public string TestValue2 { get; set; }
        public string TestValue3 { get; set; }
        public ComplexTestObject()
        {
            TestValue1 = "value1";
            TestValue2 = "value2";
            TestValue3 = "value3";
        }
    }
}

{
  "Property1": {
    "TestValue1": "value1",
    "TestValue3": "value3"
  },
  "Property2": {
    "TestValue2": "value2"
  }
}