Using JSON.net, how do I prevent serializing properties of a derived class, when used in a base class context?

Question

Given a data model:

[DataContract]
public class Parent
{
    [DataMember]
    public IEnumerable<ChildId> Children { get; set; }
}

[DataContract]
public class ChildId
{
    [DataMember]
    public string Id { get; set; }
}

[DataContract]
public class ChildDetail : ChildId
{
    [DataMember]
    public string Name { get; set; }
}

For implementation convenience reasons, there are times when the ChildId objects on the Parent are in fact ChildDetail objects. When I use JSON.net to serialize the Parent, they are written out with all of the ChildDetail properties.

Is there any way to instruct JSON.net (or any other JSON serializer, I'm not far enough into the project to be committed to one) to ignore derived class properties when serializing as a base class?

EDIT: It is important that when I serialize the derived class directly that I'm able to produce all the properties. I only want to inhibit the polymorphism in the Parent object.

Nick Craver · Accepted Answer · 2013-09-05 00:11:48Z

33

I use a custom Contract Resolver to limit which of my properties to serialize. This might point you in the right direction.

e.g.

/// <summary>
/// json.net serializes ALL properties of a class by default
/// this class will tell json.net to only serialize properties if they MATCH 
/// the list of valid columns passed through the querystring to criteria object
/// </summary>
public class CriteriaContractResolver<T> : DefaultContractResolver
{
    List<string> _properties;

    public CriteriaContractResolver(List<string> properties)
    {
        _properties = properties
    }

    protected override IList<JsonProperty> CreateProperties(
        JsonObjectContract contract)
    {
        IList<JsonProperty> filtered = new List<JsonProperty>();

        foreach (JsonProperty p in base.CreateProperties(contract))
            if(_properties.Contains(p.PropertyName)) 
                filtered.Add(p);

        return filtered;
    }
}

In the override IList function, you could use reflection to populate the list with only the parent properties perhaps.

Contract resolver is applied to your json.net serializer. This example is from an asp.net mvc app.

JsonNetResult result = new JsonNetResult();
result.Formatting = Formatting.Indented;
result.SerializerSettings.ContractResolver = 
    new CriteriaContractResolver<T>(Criteria);

edited Sep 5, 2013 at 0:11

Nick Craver

631k138 gold badges1.3k silver badges1.2k bronze badges

answered May 3, 2011 at 17:51

Jason Watts

3,8601 gold badge33 silver badges34 bronze badges

Sign up to request clarification or add additional context in comments.

8 Comments

David Kassa Over a year ago

This is exactly what I was looking for. A partial response based on fields passed in the URI. Thanks! [I wonder why this isn't a built in Contract Resolver]

Micah Over a year ago

Do you have an example of the IRestCriteria<T> class? Where does that come from?

Jason Watts Over a year ago

Micah - I should not have just cut and pasted probably. I have since changed this class to take in a List<string> of property names.

Gui Over a year ago

I dont think you should call base.CreateProperties, because you're not calling the new override method you've writted (with only accepts only one parameter), so you had to pass 2 parameters instead of just contract.

Rn222 Over a year ago

This does what I need - except how can I set this behaviour just for certain class types, or have different sets of properties included for different types?

|

Akku · Accepted Answer · 2013-05-03 06:27:26Z

26

I had the exact same problem and looked up how to build the ContractResolver I was actually looking for and that better answer this question. This only serializes the Properties of the Type T you actually want to serialize, but with this example you can also easily build similar approaches:

public class TypeOnlyContractResolver<T> : DefaultContractResolver
{
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);
        property.ShouldSerialize = instance => property.DeclaringType == typeof (T);
        return property;
    }
}

edited May 3, 2013 at 6:27

answered May 3, 2013 at 5:43

Akku

4,4624 gold badges50 silver badges68 bronze badges

3 Comments

Edi Over a year ago

Exactly what I was looking for - I have a base class that contains some properties that I don't want to be exposed.

fjch1997 Over a year ago

Consider changing to

property.ShouldSerialize = instance => property.DeclaringType == typeof(T) || typeof(T).IsSubclassOf(property.DeclaringType);

if the class you are trying to serialize is a subclass of some other class

Joost00719 Over a year ago

Doesn't work for a complex object because the objects in a list will be empty objects.

HellBrick · Accepted Answer · 2017-05-17 13:11:34Z

6

Having encountered a similar problem, this is the ContractResolver I came up with:

public class StrictTypeContractResolver : DefaultContractResolver
{
    private readonly Type _targetType;

    public StrictTypeContractResolver( Type targetType ) => _targetType = targetType;

    protected override IList<JsonProperty> CreateProperties( Type type, MemberSerialization memberSerialization )
        => base.CreateProperties
        (
            _targetType.IsAssignableFrom( type ) ? _targetType : type,
            memberSerialization
        );
}

It cuts off only the properties of targetType's descendants, without affecting the properties of its base classes or of other types that targetType's properties might reference. Which, depending on your needs, may or may not be an improvement over the other answers provided here at the time.

answered May 17, 2017 at 13:11

HellBrick

5571 gold badge6 silver badges10 bronze badges

1 Comment

martinoss Over a year ago

In my opinion the best solution, as it also works with referenced objects/nested structures.

Community · Accepted Answer · 2017-05-23 11:54:43Z

3

Check out the answers in this similar thread, particularly the IgnorableSerializerContractResolver in my answer and the nicer lambda version

Usage:

var jsonResolver = new IgnorableSerializerContractResolver();
// ignore single property
jsonResolver.Ignore(typeof(Company), "WebSites");
// ignore single datatype
jsonResolver.Ignore(typeof(System.Data.Objects.DataClasses.EntityObject));
var jsonSettings = new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Ignore, ContractResolver = jsonResolver };

edited May 23, 2017 at 11:54

CommunityBot

11 silver badge

answered Jun 5, 2013 at 14:41

drzaus

25.3k17 gold badges147 silver badges206 bronze badges

Comments

Bueller · Accepted Answer · 2011-05-03 17:06:58Z

1

I have not used JSON.Net in particular so not positive this will help you. If JSON.Net derives itself from the .Net serialization system then you should be able to add the [NonSerialized] attribute to your properties you do now wish to be serialized in the base class. When you call the serialize methods on the base class, serialization should then skip those elements.

answered May 3, 2011 at 17:06

Bueller

2,32417 silver badges11 bronze badges

3 Comments

Christopher Currie Over a year ago

Slightly different than what I want, which is that all of the base class properties are produced, and none of the derived class properties. I don't want to add [NonSeralized] to the derived class properties because there are times that I do want the derived class serialized as-is, just not when it's being used in a base class context.

Bueller Over a year ago

These links may help. Appears you will have to perform custom serialization. MSDN Article, CodeProject Article

Brad Moore Over a year ago

@Bueller This does not help if the class you inherit from is a native class which you can't modify.

martinoss · Accepted Answer · 2017-11-24 15:25:09Z

1

Haven't compared performance implications, but this is a working solution as well, and works with nested/referenced objects as well.

Derived d = new Derived();           
string jsonStringD = JsonConvert.SerializeObject(d);
Base b = new Base();
JsonConvert.PopulateObject(jsonStringD, b);
string jsonStringB = JsonConvert.SerializeObject(b);

edited Nov 24, 2017 at 15:25

answered Nov 24, 2017 at 11:51

martinoss

5,5082 gold badges48 silver badges56 bronze badges

Collectives™ on Stack Overflow

Using JSON.net, how do I prevent serializing properties of a derived class, when used in a base class context?

6 Answers 6

8 Comments

3 Comments

1 Comment

Comments

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

8 Comments

3 Comments

1 Comment

Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related