Newtonsoft ignore attributes?

I am currently using the same C# DTOs to pull data out of CouchDB, via LoveSeat which I am going to return JSON via an ASP MVC controller.

I am using the NewtonSoft library to seralise my DTOs before sending them down through the controller.

However, as CouchDB also uses NewtonSoft it is also respecting the property level NewtonSoft attributes such as

[JsonIgnore]
[JsonProperty("foo")]

Is there anyway to tell the newtonsoft library to ignore these attributes explicitly? LoveSeat allows me to provide my own implementation of IObjectSerializer, which gives me full control over netwonsofts JsonSerializerSettings. So, can I ignore the attributes by using those settings ?

I ask as the only alternative I can see at this point, is to dupe my DTOs. While not that's not terrible, it isn't great either.

The only other way I can see is to bring in my own version of the Newtonsoft.Json source into my project, with a different assembly name etc etc. But this way madness definitely lies and I will just dupe the DTOs before I go down this road.

I'm not sure if this is what you're after, but from what I understand you're looking for the [JsonIgnore] attribute. Stops properties from being serialized with the rest of the object into to JSON.

[JsonIgnore]
public string Whatever{ get; set; }

One suggestion that you may not like. For best practices, I recommend having two almost identical objects. One specifically for your Data Access Layer (Domain Object) which maps to your DB. And a separate DTO that your apps care about. This way the Domain Object will mostly contain more properties than the DTO and you can separate the concerns.

According to Json.NET documentation

You can add method to your class: public bool ShouldSerialize_________(){...} and fill in the blank with the name of the property you don't want to serialize. If the method returns false, the property will be ignored.

The example from the documentation doesn't want to serialize an employee's manager if the manager is the same employee.

public class Employee
{
    public string Name { get; set; }
    public Employee Manager { get; set; }

    public bool ShouldSerializeManager()
    {
        // don't serialize the Manager property if an employee is their own manager
        return (Manager != this);
    }
}

You could put some kind of inhibit setting on your class:

public class DTO
{
    [JsonIgnore]
    public bool IsWritingToDatabase { get; set; }
    public string AlwaysSerialize { get; set; }
    public string Optional { get; set; }

    public bool ShouldSerializeOptional()
    {
        return IsWritingToDatabase;
    }
}

But, this isn't much simpler than having two objects. So I would recommend doing as @zbugs says, and having separate definitions for API-side and DB-side.

I ended up making all properties I needed to only add attributes to virtual, and overriding them alone in another class, with the relevant newtonsoft attributes.

This allows me to have different serialisation behavior when de-serialising from CouchDB and serialising for a GET, without too much dupe. It is fine, and a bonus, that the two are coupled; any changes in the base i would want anyway.

It would still be nice to know if my original question is possible?

This newtonking.com link helped in a similar situation. It extends the DefaultContractResolver class. To make it work I had to replace

protected override IList<JsonProperty> CreateProperties(JsonObjectContract contract)

with

protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)