Serialize only interface properties to JSON with Json.net

The method I use,

public class InterfaceContractResolver : DefaultContractResolver
{
    private readonly Type _InterfaceType;
    public InterfaceContractResolver (Type InterfaceType)
    {
        _InterfaceType = InterfaceType;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        //IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);
        IList<JsonProperty> properties = base.CreateProperties(_InterfaceType, memberSerialization);
        return properties;
    }
}

// To serialize do this:
var settings = new JsonSerializerSettings() {
     ContractResolver = new InterfaceContractResolver (typeof(IThing))
};
string json = JsonConvert.SerializeObject(theObjToSerialize, settings);
                 
                            

Improved version with nested interfaces + support for xsd.exe objects

Yet another variation here. The code came from http://www.tomdupont.net/2015/09/how-to-only-serialize-interface.html with the following improvements over other answers here

• Handles hierarchy, so if you have an Interface2[] within an Interface1 then it will get serialized.

• I was trying to serialize a WCF proxy object and the resultant JSON came up as {}. Turned out all properties were set to Ignore=true so I had to add a loop to set them all to not being ignored.

  public class InterfaceContractResolver : DefaultContractResolver
  {
      private readonly Type[] _interfaceTypes;
  
      private readonly ConcurrentDictionary<Type, Type> _typeToSerializeMap;
  
      public InterfaceContractResolver(params Type[] interfaceTypes)
      {
          _interfaceTypes = interfaceTypes;
  
          _typeToSerializeMap = new ConcurrentDictionary<Type, Type>();
      }
  
      protected override IList<JsonProperty> CreateProperties(
          Type type,
          MemberSerialization memberSerialization)
      {
          var typeToSerialize = _typeToSerializeMap.GetOrAdd(
              type,
              t => _interfaceTypes.FirstOrDefault(
                  it => it.IsAssignableFrom(t)) ?? t);
  
          var props = base.CreateProperties(typeToSerialize, memberSerialization);
  
          // mark all props as not ignored
          foreach (var prop in props)
          {
              prop.Ignored = false;
          }
  
          return props;
      }
  }
  

Inspired by @user3161686, here's a small modification to InterfaceContractResolver:

public class InterfaceContractResolver<TInterface> : DefaultContractResolver where TInterface : class
{
    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        IList<JsonProperty> properties = base.CreateProperties(typeof(TInterface), memberSerialization);
        return properties;
    }
}

An alternative to [JsonIgnore] are the [DataContract] and [DataMember] attributes. If you class is tagged with [DataContract] the serializer will only process properties tagged with the [DataMember] attribute (JsonIgnore is an "opt-out" model while DataContract is "op-in").

[DataContract]
public class Thing : IThing
{
    [DataMember]
    public int Id { get; set; }

    public string Name { get; set; }
}

The limitation of both approaches is that they must be implemented in the class, you cannot add them to the interface definition.

You can add the [JsonIgnore] annotation to ignore an attribute.

I'd like to share what we ended up doing when confronted with this task. Given the OP's interface and class...

public interface IThing
{
    string Name { get; set; }
}

public class Thing : IThing
{
   public int Id { get; set; }
   public string Name { get; set; }
}

...we created a class that is the direct implementation of the interface...

public class DirectThing : IThing
{
   public string Name { get; set; }
}

Then simply serialized our Thing instance, deserialized it as a DirectThing, then Serialized it as a DirectThing:

var thing = new Thing();
JsonConvert.SerializeObject(
    JsonConvert.DeserializeObject<DirectThing>(JsonConvert.SerializeObject(thing)));

This approach can work with a long interface inheritance chain...you just need to make a direct class (DirectThing in this example) at the level of interest. No need to worry about reflection or attributes.

From a maintenance perspective, the DirectThing class is easy to maintain if you add members to IThing because the compiler will give errors if you haven't also put them in DirectThing. However, if you remove a member X from IThing and put it in Thing instead, then you'll have to remember to remove it from DirectThing or else X would be in the end result.

From a performance perspective there are three (de)serialization operations happening here instead of one, so depending on your situation you might like to evaluate the performance difference of reflector/attribute-based solutions versus this solution. In my case I was just doing this on a small scale, so I wasn't concerned about potential losses of some micro/milliseconds.

Hope that helps someone!

in addition to the answer given by @monrow you can use the default [DataContract] and [DataMember] have a look at this

http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size.aspx

Finally I got when it will not work... If you want to have inside another complex object it will not be properly serialized.

So I have made version which will extract only data stored in specific assembly and for types which have the same base interface.

So it is made as .Net Core JsonContractResolver.

In addition to data extraction it solves:
a) camelCase conversion before sending data to client
b) uses top most interface from allowed scope (by assembly) c) fixes order of fields: field from most base class will be listed first and nested object will meet this rule as well.

public class OutputJsonResolver : DefaultContractResolver
{
    #region Static Members
    private static readonly object syncTargets = new object();
    private static readonly Dictionary<Type, IList<JsonProperty>> Targets = new Dictionary<Type, IList<JsonProperty>>();

    private static readonly Assembly CommonAssembly = typeof(ICommon).Assembly;
    #endregion

    #region Override Members
    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        if (type.Assembly != OutputJsonResolver.CommonAssembly)
            return base.CreateProperties(type, memberSerialization);

        IList<JsonProperty> properties;
        if (OutputJsonResolver.Targets.TryGetValue(type, out properties) == false)
        {
            lock (OutputJsonResolver.syncTargets)
            {
                if (OutputJsonResolver.Targets.ContainsKey(type) == false)
                {
                    properties = this.CreateCustomProperties(type, memberSerialization);

                    OutputJsonResolver.Targets[type] = properties;
                }
            }
        }

        return properties;
    }
    protected override string ResolvePropertyName(string propertyName)
    {
        return propertyName.ToCase(Casing.Camel);
    }
    #endregion

    #region Assistants
    private IList<JsonProperty> CreateCustomProperties(Type type, MemberSerialization memberSerialization)
    {
        // Hierarchy
        IReadOnlyList<Type> types = this.GetTypes(type);

        // Head
        Type head = types.OrderByDescending(item => item.GetInterfaces().Length).FirstOrDefault();

        // Sources
        IList<JsonProperty> sources = base.CreateProperties(head, memberSerialization);

        // Targets
        IList<JsonProperty> targets = new List<JsonProperty>(sources.Count);

        // Repository
        IReadOnlyDistribution<Type, JsonProperty> repository = sources.ToDistribution(item => item.DeclaringType);

        foreach (Type current in types.Reverse())
        {
            IReadOnlyPage<JsonProperty> page;
            if (repository.TryGetValue(current, out page) == true)
                targets.AddRange(page);
        }

        return targets;
    }
    private IReadOnlyList<Type> GetTypes(Type type)
    {
        List<Type> types = new List<Type>();

        if (type.IsInterface == true)
            types.Add(type);

        types.AddRange(type.GetInterfaces());

        return types;
    }
    #endregion
}

Yet another answer based on existing one.

The tiny problem with @rasx approach is that when the serialized type contains a field of another compound type that doesn't implement the interface, you get an exception.

The reason is that the CreateProperties is called for each serialized type, including the actual serialized object type and the types of all its properties.

A workaround is to check if the type examined in the CreateProperties is in fact a type implementing the interface or any other type.

public class InterfaceContractResolver<TInterface> : DefaultContractResolver where TInterface : class
{
    protected override IList<JsonProperty> CreateProperties( Type type, MemberSerialization memberSerialization )
    {
        if ( typeof( TInterface ).IsAssignableFrom( type ) )
        {
            IList<JsonProperty> properties = base.CreateProperties(typeof(TInterface), memberSerialization);
            return properties;
        }
        else
        {
            return base.CreateProperties( type, memberSerialization );
        }
    }
}

Take a look at previously failing example that works now:

public interface IFoo
{
    string Bar { get; set; }

    Child Child { get; set; }
}

// this is the serialized type, it implements the interface
public class Foo : IFoo
{
    public string Bar { get; set; }
    public string Qux { get; set; }
    public Child Child { get; set; }
}

// this is a child type, doesn't implement the interface
public class Child
{
    public string Name { get; set; }
}

This works now

var foo = new Foo()
{
    Bar = "bar",
    Qux = "qux",
    Child = new Child()
    {
        Name = "child"
    }
};

// To serialize do this:
var settings = new JsonSerializerSettings()
{
    ContractResolver = new InterfaceContractResolver<IFoo>()
};

var s_foo = JsonConvert.SerializeObject(foo, settings);
var s_full = JsonConvert.SerializeObject(foo);

var foo_full = JsonConvert.DeserializeObject<Foo>(s_full);
var foo_foo = JsonConvert.DeserializeObject<Foo>(s_full, settings);

Console.WriteLine( foo_full );
Console.WriteLine( foo_foo );