using System;

using System.Linq;

using System.Reflection;

using System.Collections.Generic;

using Newtonsoft.Json;

using Newtonsoft.Json.Serialization;

public class Program

{

    public static void Main(string[] args)

    {

        List<Foo> list = new List<Foo>

        {

            new Foo

            {

                Id = 1,

                Bool = true,

                BoolSpecified = true,

                Date = DateTime.UtcNow,

                DateSpecified = true,

                Decimal = 3.14M,

                DecimalSpecified = true,

                Enum = VagueLocation.Eveywhere,

                EnumSpecified = true,

                Int = 5678,

                IntSpecified = true,

                String = "bada boom bada bing",

                StringSpecified = true,

            },

            new Foo

            {

                Id = 2

            }

        };

​

        JsonSerializerSettings settings = new JsonSerializerSettings

        {

            ContractResolver = new CustomResolver(),

            Formatting = Formatting.Indented

        };

​

        Console.WriteLine("----- Serialize -----");

        string json = JsonConvert.SerializeObject(list, settings);

        Console.WriteLine(json);

        Console.WriteLine();

​

        Console.WriteLine("----- Deserialize -----");

        list = JsonConvert.DeserializeObject<List<Foo>>(json, settings);

        foreach (Foo foo in list)

        {

            DumpFoo(foo);

        }

    }

​

    private static void DumpFoo(Foo foo)

    {

        foreach (PropertyInfo pi in typeof(Foo).GetProperties())

        {

            Console.WriteLine(pi.Name + ": " + pi.GetValue(foo));

        }

        Console.WriteLine();

    }

}

​

class Foo

{

    public int Id { get; set; }

    public int Int { get; set; }

    public bool IntSpecified { get; set; }

    public bool Bool { get; set; }

    public bool BoolSpecified { get; set; }

    public decimal Decimal { get; set; }

    public bool DecimalSpecified { get; set; }

    public DateTime Date { get; set; }

    public bool DateSpecified { get; set; }

    public string String { get; set; }

    public bool StringSpecified { get; set; }

    public VagueLocation Enum { get; set; }

    public bool EnumSpecified { get; set; }

}

​

enum VagueLocation { Nowhere, Here, There, Eveywhere };

​

public class CustomResolver : DefaultContractResolver

{

    const string IndicatorKeyword = "Specified";

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

    {

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

        Dictionary<string, JsonProperty> dict = props.ToDictionary(p => p.UnderlyingName);

        foreach (JsonProperty prop in props)

        {

            string name = prop.UnderlyingName;

            if (name.Length > IndicatorKeyword.Length && name.EndsWith(IndicatorKeyword))

            {

                // We have an indicator property; ignore it for serialization purposes

                prop.Ignored = true;

                // Find the corresponding target property, e.g. "XyzSpecified" => "Xyz"

                string targetName = name.Substring(0, name.Length - IndicatorKeyword.Length);

                JsonProperty coProp = null;

                if (dict.TryGetValue(targetName, out coProp))

                {

                    // Create a value provider for the property pointing to the

                    // "real" target and indicator properties from the containing type

                    PropertyInfo realTarget = type.GetProperty(targetName);

                    PropertyInfo realIndicator = type.GetProperty(name);

                    coProp.ValueProvider = new CustomValueProvider(realTarget, realIndicator);

                }

            }

        }

        return props;

    }

    class CustomValueProvider : IValueProvider

    {

        PropertyInfo targetProperty;

        PropertyInfo indicatorProperty;

        public CustomValueProvider(PropertyInfo targetProperty, PropertyInfo indicatorProperty)

        {

            this.targetProperty = targetProperty;

            this.indicatorProperty = indicatorProperty;

        }

        // GetValue is called by Json.Net during serialization.

        // The target parameter has the object from which to read the value;

        // the return value is what gets written to the JSON

        public object GetValue(object target)

        {

            bool isSpecified = (bool)indicatorProperty.GetValue(target);

            return isSpecified ? targetProperty.GetValue(target) : null;

        }

        // SetValue gets called by Json.Net during deserialization.

        // The value parameter has the value read from the JSON;

        // target is the object on which to set the value.

        public void SetValue(object target, object value)

        {

            bool isSpecified = value != null;

            indicatorProperty.SetValue(target, isSpecified);

            if (isSpecified) targetProperty.SetValue(target, value);

        }

    }

}

​