Json.Net属性忽略所有属性

Question

Is there an attribute to tell json.net to ignore all properties of a class but include all fields (regardless of access modifiers) ?

If not is there a way to create one ?

Basically I want one attribute decorating the class that will have the equivalent effect to putting [JsonIgnore] infront of each property.

Answer 1

If you mark your class with [JsonObject(MemberSerialization.Fields)] , that will get you most of the way there. This attribute tells Json.Net that you want it to serialize all fields in a class, regardless of access modifiers, but not properties.

However, if you have any auto properties in your class (ie those declared with { get; set; } ) then this attribute will cause the compiler-generated backing fields to be serialized as well, which you may not want. To suppress those, you will need to use a custom IContractResolver . You can create one by inheriting from the DefaultContractResolver and overriding the CreateProperty method. In that method, check whether the class has the [JsonObject(MemberSerialization.Fields)] attribute applied, and if so, check whether the member is a compiler-generated field. If it is, then set it to be ignored.

class CustomResolver : DefaultContractResolver
{
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty prop = base.CreateProperty(member, memberSerialization);
        JsonObjectAttribute attr = prop.DeclaringType.GetCustomAttribute<JsonObjectAttribute>();
        if (attr != null && attr.MemberSerialization == MemberSerialization.Fields && 
            member.GetCustomAttribute<CompilerGeneratedAttribute>() != null)
        {
            prop.Ignored = true;
        }
        return prop;
    }
}

To use the resolver, you need to pass it to the SerializeObject method via the JsonSerializerSettings :

var settings = new JsonSerializerSettings
{
    ContractResolver = new CustomResolver(),
    Formatting = Formatting.Indented
};
string json = JsonConvert.SerializeObject(yourObject, settings);

Here is a proof of concept: https://dotnetfiddle.net/aNXWbn

Answer 2

You can add [JsonObject(MemberSerialization.OptIn)] attribute to your class, then everything will be ignored unless you explicitly Opt-In by using a [JsonProperty] attribute on the members.

[JsonObject(MemberSerialization.OptIn)]
public class Address
{
    [JsonProperty]
    private string _field1 = "bob";

    public string Line1 { get; set; }

    public string Line2 { get; set; }

    public string Line3 { get; set; }
}

For example

using System;
using AutoFixture;
using Newtonsoft.Json;

public class Program
{
    public static void Main()
    {
        var fixture = new Fixture();
        var address = fixture.Create<Address>(); // Create an address filled with junk

        var json = JsonConvert.SerializeObject(address);

        Console.WriteLine(json);
    }
}

Will output:

{"_field1":"bob"}

Answer 3

You could create a custom IContractResolver and decide to serialize depending on a custom attribute you created:

public class IgnorePropertyResolver : DefaultContractResolver
{
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        var property = base.CreateProperty(member, memberSerialization);

        //Todo: Check your custom attribute. You have MemberInfo here to navigate to your class and GetCustomAttributes<>
        //e.g: property.ShouldSerialize = member.DeclaringType.GetCustomAttribute<JsonIgnoreAllProperties>() == null;
        property.ShouldSerialize = false; 
        return property;
    }
}

Then you need to register it as default, which depends on your environment. Or you are using it directly, then you even do not need an attribute:

string json =
    JsonConvert.SerializeObject(
        product,
        Formatting.Indented,
        new JsonSerializerSettings
        {
            ContractResolver = new IgnorePropertyResolver()
        }
    );

---

An attribute is created for example by:

public class JsonIgnoreAllPropertiesAttribute : Attribute
{
}

And Used:

[JsonIgnoreAllProperties]
public class ClassToSerialize
{
     public int Ignored { get;set; }
     public int Serialized;
}