NewtonSoft json Contract Resolver with MVC 4.0 Web Api not producing the output as expected

Question

I am trying to create a conditional ContractResolver so that I can control the serialization differently depending on the web request/controller action.

For example in my User Controller I want to serialize all properties of my User but some of the related objects I might only serialize the primitive types. But if I went to my company controller I want to serialize all the properties of the company but maybe only the primitive ones of the user (because of this I don't want to use dataannotations or shouldserialize functions.

So looking at the custom ContractResolver page i created my own. http://james.newtonking.com/projects/json/help/index.html?topic=html/ContractResolver.htm

It looks like this

public class IgnoreListContractResolver : DefaultContractResolver
{
    private readonly Dictionary<string, List<string>> IgnoreList;

    public IgnoreListContractResolver(Dictionary<string, List<string>> i)
    {
        IgnoreList = i;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        List<JsonProperty> properties = base.CreateProperties(type, memberSerialization).ToList();

        if(IgnoreList.ContainsKey(type.Name))
        {
            properties.RemoveAll(x => IgnoreList[type.Name].Contains(x.PropertyName));                
        }
        return properties;
    }
}

And then in my web api controller action for GetUsers i do this

public dynamic GetUsers()
{
    List<User> Users = db.Users.ToList();
    List<string> RoleList = new List<string>();
    RoleList.Add("UsersInRole");
    List<string> CompanyList = new List<string>();
    CompanyList.Add("CompanyAccesses");
    CompanyList.Add("ArchivedMemberships");
    CompanyList.Add("AddCodes");

    Dictionary<string, List<string>> IgnoreList = new Dictionary<string, List<string>>();
    IgnoreList.Add("Role", RoleList);
    IgnoreList.Add("Company", CompanyList);
    GlobalConfiguration
            .Configuration
            .Formatters.JsonFormatter
            .SerializerSettings
            .ContractResolver = new IgnoreListContractResolver(IgnoreList);

    return new { List = Users, Status = "Success" };
}

So when debugging this I see my contract resolver run and it returns the correct properties but the Json returned to the browser still contains entries for the properties I removed from the list.

Any ideas what I am missing or how I can step into the Json serialization step in webapi controllers.

*UPDATE** I should add that this is in an MVC4 project that has both MVC controllers and webapi controllers. The User, Company, and Role objects are objects (created by code first) that get loaded from EF5. The controller in question is a web api controller. Not sure why this matters but I tried this in a clean WebApi project (and without EF5) instead of an MVC project and it worked as expected. Does that help identify where the problem might be?

Thanks

*UPDATE 2** In the same MVC4 project I created an extension method for the Object class which is called ToJson. It uses Newtonsoft.Json.JsonSerializer to serialize my entities. Its this simple.

public static string ToJson(this object o, Dictionary<string, List<string>> IgnoreList)
{
    JsonSerializer js = JsonSerializer.Create(new Newtonsoft.Json.JsonSerializerSettings()
    {
        Formatting = Formatting.Indented,
        DateTimeZoneHandling = DateTimeZoneHandling.Utc,
        ContractResolver = new IgnoreListContractResolver(IgnoreList),
        ReferenceLoopHandling = ReferenceLoopHandling.Ignore  
    });

    js.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());

    var jw = new StringWriter();
    js.Serialize(jw, o);
    return jw.ToString();

}

And then in an MVC action i create a json string like this.

model.jsonUserList = db.Users.ToList().ToJson(IgnoreList);

Where the ignore list is created exactly like my previous post. Again I see the contract resolver run and correctly limit the properties list but the output json string still contains everything (including the properties I removed from the list). Does this help? I must be doing something wrong and now it seems like it isn't the MVC or web api framework. Could this have anything to do with EF interactions/ proxies /etc. Any ideas would be much appreciated.

Thanks

*UPDATE 3***

Process of elimination and a little more thorough debugging made me realize that EF 5 dynamic proxies were messing up my serialization and ContractResolver check for the type name match. So here is my updated IgnoreListContractResolver. At this point I am just looking for opinions on better ways or if I am doing something terrible. I know this is jumping through a lot of hoops just to use my EF objects directly instead of DTOs but in the end I am finding this solution is really flexible.

public class IgnoreListContractResolver : CamelCasePropertyNamesContractResolver
{
    private readonly Dictionary<string, List<string>> IgnoreList;

    public IgnoreListContractResolver(Dictionary<string, List<string>> i)
    {
        IgnoreList = i;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        List<JsonProperty> properties = base.CreateProperties(type, memberSerialization).ToList();

        string typename = type.Name;
        if(type.FullName.Contains("System.Data.Entity.DynamicProxies.")) {
            typename = type.FullName.Replace("System.Data.Entity.DynamicProxies.", "");
            typename = typename.Remove(typename.IndexOf('_'));
        }

        if (IgnoreList.ContainsKey(typename))
        {
            //remove anything in the ignore list and ignore case because we are using camel case for json
            properties.RemoveAll(x => IgnoreList[typename].Contains(x.PropertyName, StringComparer.CurrentCultureIgnoreCase));
        }
        return properties;
    }
}

I had to change back to using the DefaultContractResolver because the CamelCasePropertyNamesContractResolver caches the properties per type and since the entire purpose of this was be able to change the properties based on the input parameter that didn't work. I was able to override the ResolvePropertyName function to return camelcase so my json/javascript worked correctly. — Sean
– Sean, Commented Feb 6, 2013 at 7:12
Did you ever come to a resolution on this? We just discovered this same issue. Still investigating but when we build from 4.5 r4 source we don't have this problem. — David Kassa
– David Kassa, Commented May 14, 2014 at 18:50

fero · Accepted Answer · 2013-02-04 08:51:03Z

1

I think it might help if you used Type instead of string for the ignore list's key type. So you can avoid naming issues (multiple types with the same name in different namespaces) and you can make use of inheritance. I'm not familiar with EF5 and the proxies, but I guess that the proxy classes derive from your entity classes. So you can check Type.IsAssignableFrom() instead of just checking whether typename is a key in the ignore list.

private readonly Dictionary<Type, List<string>> IgnoreList;

protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
    List<JsonProperty> properties = base.CreateProperties(type, memberSerialization).ToList();

    // look for the first dictionary entry whose key is a superclass of "type"
    Type key = IgnoreList.Keys.FirstOrDefault(k => k.IsAssignableFrom(type));

    if (key != null)
    {
        //remove anything in the ignore list and ignore case because we are using camel case for json
        properties.RemoveAll(x => IgnoreList[key].Contains(x.PropertyName, StringComparer.CurrentCultureIgnoreCase));
    }
    return properties;
}

Then the ignore list must be created like this (I also used the short syntax for creating the list and dictionary):

var CompanyList = new List<string> {
    "CompanyAccesses",
    "ArchivedMemberships",
    "AddCodes"
};

var IgnoreList = new Dictionary<Type, List<string>> {
    // I just replaced "Company" with typeof(Company) here:
    { typeof(Company), CompanyList }
};

Be aware that, if you use my code above, adding typeof(object) as the first key to the ignore list will cause this entry to be matched every time, and none of your other entries will ever be used! This happens because a variable of type object is assignable from every other type.

answered Feb 4, 2013 at 8:51

fero

6,2292 gold badges36 silver badges56 bronze badges

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

1 Comment

Sean Over a year ago

I like your update as I never liked the string matching I had for determining the key. I made one more change which was to use the PropertyUtil helper class from here ivanz.com/2009/12/04/… so that I didn't have to create the strings for the property names myself.

Collectives™ on Stack Overflow

NewtonSoft json Contract Resolver with MVC 4.0 Web Api not producing the output as expected

1 Answer 1

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related