using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;

​

​

namespace Question42092359

{

    // https://stackoverflow.com/questions/42092359/jsonserializersettings-to-change-case-of-property-name-but-not-name-of-property

    public class OverrideContractResolver : ContractResolverDecorator

    {

        readonly Dictionary<Type, IContractResolver> overrides;

​

        public OverrideContractResolver(IEnumerable<KeyValuePair<Type, IContractResolver>> overrides, IContractResolver baseResolver)

            : base(baseResolver)

        {

            if (overrides == null)

                throw new ArgumentNullException();

            this.overrides = overrides.ToDictionary(p => p.Key, p => p.Value);

        }

​

        public override JsonContract ResolveContract(Type type)

        {

            IContractResolver resolver;

            if (overrides.TryGetValue(type, out resolver))

                return resolver.ResolveContract(type);

            return base.ResolveContract(type);

        }

    }

​

    public class ContractResolverDecorator : IContractResolver

    {

        readonly IContractResolver baseResolver;

​

        public ContractResolverDecorator(IContractResolver baseResolver)

        {

            if (baseResolver == null)

                throw new ArgumentNullException();

            this.baseResolver = baseResolver;

        }

​

        #region IContractResolver Members

​

        public virtual JsonContract ResolveContract(Type type)

        {

            return baseResolver.ResolveContract(type);

        }

​

        #endregion

    }

​

    public class SomeOtherType

    {

        public string FooProperty { get; set; }

        public int BarProperty { get; set; }

    }

​

    public class CaseToChange

    {

        public string StringProperty { get; set; } //Change to camelCase

        public SomeOtherType OtherTypeProperty { get; set; } //Change name of this to camelCase but not property name of "SomeOtherType"

    }

​

    public class RootObject

    {

        public RootObject() { this.CaseToChangeList = new List<CaseToChange>(); }

        public List<CaseToChange> CaseToChangeList { get; set; }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var root = new RootObject { CaseToChangeList = { new CaseToChange { StringProperty = "string property", OtherTypeProperty = new SomeOtherType { BarProperty = 101, FooProperty = "foo" } } } };

​

            Test(root.CaseToChangeList.First());

​

            Test(root);

        }

​

        private static void Test<T>(T root)

        {

            var settings = new JsonSerializerSettings

            {

                ContractResolver =

                    new OverrideContractResolver(

                        new Dictionary<Type, IContractResolver> { { typeof(CaseToChange), new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver() } },

                        new Newtonsoft.Json.Serialization.DefaultContractResolver()),

            };

​

            Console.WriteLine(string.Format("Testing {0} ...", root.GetType()));

​

            var json = JsonConvert.SerializeObject(root, Formatting.Indented, settings);

​

            Console.WriteLine(json);

​

            Assert.IsTrue(json.Contains("stringProperty") && !json.Contains("StringProperty"));

            Assert.IsTrue(json.Contains("FooProperty") && !json.Contains("fooProperty"));

​

            Console.WriteLine(string.Format("{0} and descendants cased correctly.", root.GetType()));

        }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            if (value == false)

                throw new AssertionFailedException("failed");

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

}

​

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);

        Console.WriteLine("");

        Question42092359.TestClass.Test();

    }

}

​