Skip to content

Instantly share code, notes, and snippets.

@trailmax

trailmax/IgnorableSerializerContractResolver.cs

Created March 4, 2014 23:18
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save trailmax/9357825 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save trailmax/9357825 to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. trailmax created this gist Mar 4, 2014.
    57 changes: 57 additions & 0 deletions IgnorableSerializerContractResolver.cs
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,57 @@
    /// <summary>
    /// Special JsonConvert resolver that allows you to ignore properties. See http://stackoverflow.com/a/13588192/1037948
    /// </summary>
    public class IgnorableSerializerContractResolver : DefaultContractResolver {
    protected readonly Dictionary<Type, HashSet<string>> Ignores;

    public IgnorableSerializerContractResolver() {
    this.Ignores = new Dictionary<Type, HashSet<string>>();
    }

    /// <summary>
    /// Explicitly ignore the given property(s) for the given type
    /// </summary>
    /// <param name="type"></param>
    /// <param name="propertyName">one or more properties to ignore. Leave empty to ignore the type entirely.</param>
    public void Ignore(Type type, params string[] propertyName) {
    // start bucket if DNE
    if (!this.Ignores.ContainsKey(type)) this.Ignores[type] = new HashSet<string>();

    foreach (var prop in propertyName) {
    this.Ignores[type].Add(prop);
    }
    }

    /// <summary>
    /// Is the given property for the given type ignored?
    /// </summary>
    /// <param name="type"></param>
    /// <param name="propertyName"></param>
    /// <returns></returns>
    public bool IsIgnored(Type type, string propertyName) {
    if (!this.Ignores.ContainsKey(type)) return false;

    // if no properties provided, ignore the type entirely
    if (this.Ignores[type].Count == 0) return true;

    return this.Ignores[type].Contains(propertyName);
    }

    /// <summary>
    /// The decision logic goes here
    /// </summary>
    /// <param name="member"></param>
    /// <param name="memberSerialization"></param>
    /// <returns></returns>
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) {
    JsonProperty property = base.CreateProperty(member, memberSerialization);

    if (this.IsIgnored(property.DeclaringType, property.PropertyName)
    // need to check basetype as well for EF -- @per comment by user576838
    || this.IsIgnored(property.DeclaringType.BaseType, property.PropertyName)) {
    property.ShouldSerialize = instance => { return false; };
    }

    return property;
    }
    }