How can I "un-JsonIgnore" an attribute in a derived class?

Question

I am using Newtonsoft's JsonSerializer to serialise some classes.

As I wanted to omit one field of my class in the serialisation process, I declared it as follow:

[JsonIgnore]
public int ParentId { get; set; }

This worked, but I am now facing a new problem : In a derived class, I would like this field to appear (and do so only in this specific derived class).

I have been looking through the documentation and on the Internet for a way to override this setting in child classes (I guess I need something like [JsonStopIgnore], but I couldn't find anything close).

---

• Is there any way for me to force JsonSerializer to pick up again this attribute ?
• Is it possible to explicitly mark an attribute as [JsonIgnore], but only in base class ?

Answer 1

The only way to "override" the behavior of the [JsonIgnore] attribute is to use a contract resolver, as @Yuval Itzchakov nicely explained in his answer.

However, there is another possible solution that might work for you: instead of using a [JsonIgnore] attribute, you could implement a ShouldSerializeParentId() method in your classes to control whether the ParentId property gets serialized. In the base class, make this method return false; then, override the method in the derived class to return true. (This feature is known as conditional property serialization in Json.Net.)

public class Base
{
    public int Id { get; set; }
    public int ParentId { get; set; }

    public virtual bool ShouldSerializeParentId()
    {
        return false;
    }
}

public class Derived : Base 
{ 
    public override bool ShouldSerializeParentId()
    {
        return true;
    }
}

Fiddle: https://dotnetfiddle.net/65sCSz

Answer 2

You can do this by creating a custom DefaultContractResolver and overriding its CreateProperty method.

For example, given a Foo base and a derived Bar:

public class Foo
{
    [JsonIgnore]
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Bar : Foo 
{ }

You can create the following contract resolver:

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

        property.Ignored = false;
        property.ShouldSerialize = propInstance => property.DeclaringType != typeof (T);
        return property;
    }
}

This will set all properties to Ignored = false, and then analyze them by the given predicate:

propInstance => property.DeclaringType != typeof (T);

Which in our case means "you should serialize only if they are not of type Foo" (since Foo is the DeclaryingType).

And then when you want to deserialize, you pass an instance of the contract resolver to JsonSerializerSettings:

var bar = new Bar();
var result = JsonConvert.SerializeObject(bar,
    new JsonSerializerSettings {ContractResolver = new MyTypeContractResolver<Bar>()});

Answer 3

I solved the same problem by using the new keyword on the property of the derived class.

public class Foo
{
    [JsonIgnore]
    public int ParentId { get; set; }
}

public class Bar: Foo
{
    [JsonProperty("ParentId")]
    public new int ParentId { get; set; }
}

Answer 4

You can probably simply overwrite ParentId in the derived class.

public new int ParentId
{
    get { return base.ParentId; }
    set { base.ParentId = value; }
}

Answer 5

I solved the same problem with a ghost property :

public class Foo
{
    [JsonIgnore]
    public int ParentId { get; set; }

    [NotMapped]
    public int FooParent { get; set; }
}

When I want to show this property quite always hidden, I populate it, other times it is null :

Foos.ForEach(x => x.FooParent = ParentId);