using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using Newtonsoft.Json;

using Newtonsoft.Json.Serialization;

public class Program

{

    public static void Main()

    {

        var test = new MyTestObject();

        var settings = new JsonSerializerSettings();

        settings.ContractResolver = new CustomResolver();

        settings.Formatting = Formatting.Indented;

        var json = JsonConvert.SerializeObject(test, settings);

        Console.WriteLine(json);

    }

}

​

class MyTestObject

{

    [SerializeOnly("TestValue1")]

    [SerializeOnly("TestValue3")]

    public ComplexTestObject Property1 { get; set; }

    [SerializeOnly("TestValue2")]

    public ComplexTestObject Property2 { get; set; }

    public MyTestObject()

    {

        Property1 = new ComplexTestObject();

        Property2 = new ComplexTestObject();

    }

}

​

class ComplexTestObject

{

    public string TestValue1 { get; set; }

    public string TestValue2 { get; set; }

    public string TestValue3 { get; set; }

    public ComplexTestObject()

    {

        TestValue1 = "value1";

        TestValue2 = "value2";

        TestValue3 = "value3";

    }

}

​

class CustomResolver : DefaultContractResolver

{

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

    {

        IList<JsonProperty> props = base.CreateProperties(type, memberSerialization);

        foreach (JsonProperty prop in props)

        {

            if (!prop.PropertyType.IsPrimitive && prop.PropertyType != typeof(string))

            {

                PropertyInfo pi = type.GetProperty(prop.UnderlyingName);

                if (pi != null && pi.CanRead)

                {

                    var childPropertiesToSerialize = pi.GetCustomAttributes<SerializeOnly>()

                        .Select(att => att.PropertyName);

                    if (childPropertiesToSerialize.Any())

                    {

                        prop.Converter = new CustomConverter(childPropertiesToSerialize);

                    }

                }

            }

        }

        return props;

    }

}

​

class CustomConverter : JsonConverter

{

    private HashSet<string> propertiesToSerialize;

    public CustomConverter(IEnumerable<string> propertiesToSerialize)

    {

        this.propertiesToSerialize = new HashSet<string>(propertiesToSerialize);

    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

    {

        writer.WriteStartObject();

        foreach (PropertyInfo prop in value.GetType().GetProperties())

        {

            if (prop.CanRead && propertiesToSerialize.Contains(prop.Name))

            {

                writer.WritePropertyName(prop.Name);

                serializer.Serialize(writer, prop.GetValue(value));

            }

        }

        writer.WriteEndObject();

    }

    public override bool CanRead

    {

        get { return false; }

    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

    {

        throw new NotImplementedException();

    }

    public override bool CanConvert(Type objectType)

    {

        throw new NotImplementedException();

    }

}

​

[AttributeUsage(AttributeTargets.Property, AllowMultiple=true)]

class SerializeOnly : Attribute

{

    public SerializeOnly(string name)

    {

        PropertyName = name;

    }

    public string PropertyName { get; set; }

}

​