-Refactored naming strategy to be an abstract base class

Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net20.csproj

@@ -113,6 +113,7 @@
     <Compile Include="Serialization\ReferenceLoopHandlingTests.cs" />
     <Compile Include="Serialization\ReflectionAttributeProviderTests.cs" />
     <Compile Include="Serialization\ShouldSerializeTests.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategyTests.cs" />
     <Compile Include="Serialization\TraceWriterTests.cs" />
     <Compile Include="Serialization\WebApiIntegrationTests.cs" />
     <Compile Include="TestObjects\Aa.cs" />

Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net35.csproj

@@ -156,6 +156,7 @@
     <Compile Include="Serialization\ReferenceLoopHandlingTests.cs" />
     <Compile Include="Serialization\ReflectionAttributeProviderTests.cs" />
     <Compile Include="Serialization\ShouldSerializeTests.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategyTests.cs" />
     <Compile Include="Serialization\TraceWriterTests.cs" />
     <Compile Include="Serialization\WebApiIntegrationTests.cs" />
     <Compile Include="TestObjects\Aa.cs" />

Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net40.csproj

@@ -272,6 +272,7 @@
     <Compile Include="Serialization\ReferenceLoopHandlingTests.cs" />
     <Compile Include="Serialization\ReflectionAttributeProviderTests.cs" />
     <Compile Include="Serialization\ShouldSerializeTests.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategyTests.cs" />
     <Compile Include="Serialization\TraceWriterTests.cs" />
     <Compile Include="Serialization\WebApiIntegrationTests.cs" />
     <Compile Include="Serialization\JsonPropertyCollectionTests.cs" />

Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable.csproj

@@ -147,6 +147,7 @@
     <Compile Include="Serialization\ReferenceLoopHandlingTests.cs" />
     <Compile Include="Serialization\ReflectionAttributeProviderTests.cs" />
     <Compile Include="Serialization\ShouldSerializeTests.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategyTests.cs" />
     <Compile Include="Serialization\TraceWriterTests.cs" />
     <Compile Include="Serialization\WebApiIntegrationTests.cs" />
     <Compile Include="Serialization\JsonPropertyCollectionTests.cs" />

Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable40.csproj

@@ -151,6 +151,7 @@
     <Compile Include="Serialization\ReferenceLoopHandlingTests.cs" />
     <Compile Include="Serialization\ReflectionAttributeProviderTests.cs" />
     <Compile Include="Serialization\ShouldSerializeTests.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategyTests.cs" />
     <Compile Include="Serialization\TraceWriterTests.cs" />
     <Compile Include="Serialization\WebApiIntegrationTests.cs" />
     <Compile Include="Serialization\JsonPropertyCollectionTests.cs" />

Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj

@@ -262,6 +262,7 @@
     <Compile Include="Schema\JsonSchemaSpecTests.cs" />
     <Compile Include="Schema\JsonSchemaTests.cs" />
     <Compile Include="Schema\PerformanceTests.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategyTests.cs" />
     <Compile Include="Serialization\CamelCaseNamingStrategyTests.cs" />
     <Compile Include="Serialization\CamelCasePropertyNamesContractResolverTests.cs" />
     <Compile Include="Serialization\ConstructorHandlingTests.cs" />

Src/Newtonsoft.Json.Tests/Serialization/CamelCaseNamingStrategyTests.cs

@@ -174,7 +174,7 @@ namespace Newtonsoft.Json.Tests.Serialization
             {
                 NamingStrategy = new CamelCaseNamingStrategy
                 {
-                    CamelCaseDictionaryKeys = true
+                    ProcessDictionaryKeys = true
                 }
             };
 
@@ -233,7 +233,7 @@ namespace Newtonsoft.Json.Tests.Serialization
             {
                 NamingStrategy = new CamelCaseNamingStrategy
                 {
-                    CamelCaseDictionaryKeys = true
+                    ProcessDictionaryKeys = true
                 }
             };
 

Src/Newtonsoft.Json.Tests/Serialization/SnakeCaseNamingStrategyTests.cs

@@ -0,0 +1,327 @@
+#region License
+// Copyright (c) 2007 James Newton-King
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+#endregion
+
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json.Serialization;
+#if NETFX_CORE
+using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
+using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
+using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
+#elif DNXCORE50
+using Xunit;
+using Test = Xunit.FactAttribute;
+using Assert = Newtonsoft.Json.Tests.XUnitAssert;
+#else
+using NUnit.Framework;
+#endif
+using Newtonsoft.Json.Tests.TestObjects;
+using Newtonsoft.Json.Linq;
+using System.Reflection;
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Tests.Serialization
+{
+    [TestFixture]
+    public class SnakeCaseNamingStrategyTests : TestFixtureBase
+    {
+        [Test]
+        public void JsonConvertSerializerSettings()
+        {
+            Person person = new Person();
+            person.BirthDate = new DateTime(2000, 11, 20, 23, 55, 44, DateTimeKind.Utc);
+            person.LastModified = new DateTime(2000, 11, 20, 23, 55, 44, DateTimeKind.Utc);
+            person.Name = "Name!";
+
+            DefaultContractResolver contractResolver = new DefaultContractResolver
+            {
+                NamingStrategy = new SnakeCaseNamingStrategy()
+            };
+
+            string json = JsonConvert.SerializeObject(person, Formatting.Indented, new JsonSerializerSettings
+            {
+                ContractResolver = contractResolver
+            });
+
+            StringAssert.AreEqual(@"{
+  ""name"": ""Name!"",
+  ""birth_date"": ""2000-11-20T23:55:44Z"",
+  ""last_modified"": ""2000-11-20T23:55:44Z""
+}", json);
+
+            Person deserializedPerson = JsonConvert.DeserializeObject<Person>(json, new JsonSerializerSettings
+            {
+                ContractResolver = contractResolver
+            });
+
+            Assert.AreEqual(person.BirthDate, deserializedPerson.BirthDate);
+            Assert.AreEqual(person.LastModified, deserializedPerson.LastModified);
+            Assert.AreEqual(person.Name, deserializedPerson.Name);
+
+            json = JsonConvert.SerializeObject(person, Formatting.Indented);
+            StringAssert.AreEqual(@"{
+  ""Name"": ""Name!"",
+  ""BirthDate"": ""2000-11-20T23:55:44Z"",
+  ""LastModified"": ""2000-11-20T23:55:44Z""
+}", json);
+        }
+
+        [Test]
+        public void JTokenWriter_OverrideSpecifiedName()
+        {
+            JsonIgnoreAttributeOnClassTestClass ignoreAttributeOnClassTestClass = new JsonIgnoreAttributeOnClassTestClass();
+            ignoreAttributeOnClassTestClass.Field = int.MinValue;
+
+            DefaultContractResolver contractResolver = new DefaultContractResolver
+            {
+                NamingStrategy = new SnakeCaseNamingStrategy
+                {
+                    OverrideSpecifiedNames = true
+                }
+            };
+
+            JsonSerializer serializer = new JsonSerializer();
+            serializer.ContractResolver = contractResolver;
+
+            JTokenWriter writer = new JTokenWriter();
+
+            serializer.Serialize(writer, ignoreAttributeOnClassTestClass);
+
+            JObject o = (JObject)writer.Token;
+            JProperty p = o.Property("the_field");
+
+            Assert.IsNotNull(p);
+            Assert.AreEqual(int.MinValue, (int)p.Value);
+        }
+
+        [Test]
+        public void BlogPostExample()
+        {
+            Product product = new Product
+            {
+                ExpiryDate = new DateTime(2010, 12, 20, 18, 1, 0, DateTimeKind.Utc),
+                Name = "Widget",
+                Price = 9.99m,
+                Sizes = new[] { "Small", "Medium", "Large" }
+            };
+
+            DefaultContractResolver contractResolver = new DefaultContractResolver
+            {
+                NamingStrategy = new SnakeCaseNamingStrategy()
+            };
+
+            string json =
+                JsonConvert.SerializeObject(
+                    product,
+                    Formatting.Indented,
+                    new JsonSerializerSettings { ContractResolver = contractResolver }
+                    );
+
+            //{
+            //  "name": "Widget",
+            //  "expiryDate": "\/Date(1292868060000)\/",
+            //  "price": 9.99,
+            //  "sizes": [
+            //    "Small",
+            //    "Medium",
+            //    "Large"
+            //  ]
+            //}
+
+            StringAssert.AreEqual(@"{
+  ""name"": ""Widget"",
+  ""expiry_date"": ""2010-12-20T18:01:00Z"",
+  ""price"": 9.99,
+  ""sizes"": [
+    ""Small"",
+    ""Medium"",
+    ""Large""
+  ]
+}", json);
+        }
+
+#if !(NET35 || NET20 || PORTABLE40)
+        [Test]
+        public void DynamicSnakeCasePropertyNames()
+        {
+            dynamic o = new TestDynamicObject();
+            o.Text = "Text!";
+            o.Integer = int.MaxValue;
+
+            DefaultContractResolver contractResolver = new DefaultContractResolver
+            {
+                NamingStrategy = new SnakeCaseNamingStrategy
+                {
+                    ProcessDictionaryKeys = true
+                }
+            };
+
+            string json = JsonConvert.SerializeObject(o, Formatting.Indented,
+                new JsonSerializerSettings
+                {
+                    ContractResolver = contractResolver
+                });
+
+            StringAssert.AreEqual(@"{
+  ""explicit"": false,
+  ""text"": ""Text!"",
+  ""integer"": 2147483647,
+  ""int"": 0,
+  ""child_object"": null
+}", json);
+        }
+#endif
+
+        [Test]
+        public void DictionarySnakeCasePropertyNames_Disabled()
+        {
+            Dictionary<string, string> values = new Dictionary<string, string>
+            {
+                { "First", "Value1!" },
+                { "Second", "Value2!" }
+            };
+
+            DefaultContractResolver contractResolver = new DefaultContractResolver
+            {
+                NamingStrategy = new SnakeCaseNamingStrategy()
+            };
+
+            string json = JsonConvert.SerializeObject(values, Formatting.Indented,
+                new JsonSerializerSettings
+                {
+                    ContractResolver = contractResolver
+                });
+
+            StringAssert.AreEqual(@"{
+  ""First"": ""Value1!"",
+  ""Second"": ""Value2!""
+}", json);
+        }
+
+        [Test]
+        public void DictionarySnakeCasePropertyNames_Enabled()
+        {
+            Dictionary<string, string> values = new Dictionary<string, string>
+            {
+                { "First", "Value1!" },
+                { "Second", "Value2!" }
+            };
+
+            DefaultContractResolver contractResolver = new DefaultContractResolver
+            {
+                NamingStrategy = new SnakeCaseNamingStrategy
+                {
+                    ProcessDictionaryKeys = true
+                }
+            };
+
+            string json = JsonConvert.SerializeObject(values, Formatting.Indented,
+                new JsonSerializerSettings
+                {
+                    ContractResolver = contractResolver
+                });
+
+            StringAssert.AreEqual(@"{
+  ""first"": ""Value1!"",
+  ""second"": ""Value2!""
+}", json);
+        }
+
+        public class PropertyAttributeNamingStrategyTestClass
+        {
+            [JsonProperty]
+            public string HasNoAttributeNamingStrategy { get; set; }
+
+            [JsonProperty(NamingStrategyType = typeof(SnakeCaseNamingStrategy))]
+            public string HasAttributeNamingStrategy { get; set; }
+        }
+
+        [Test]
+        public void JsonPropertyAttribute_NamingStrategyType()
+        {
+            PropertyAttributeNamingStrategyTestClass c = new PropertyAttributeNamingStrategyTestClass
+            {
+                HasNoAttributeNamingStrategy = "Value1!",
+                HasAttributeNamingStrategy = "Value2!"
+            };
+
+            string json = JsonConvert.SerializeObject(c, Formatting.Indented);
+
+            StringAssert.AreEqual(@"{
+  ""HasNoAttributeNamingStrategy"": ""Value1!"",
+  ""has_attribute_naming_strategy"": ""Value2!""
+}", json);
+        }
+
+        [JsonObject(NamingStrategyType = typeof(SnakeCaseNamingStrategy))]
+        public class ContainerAttributeNamingStrategyTestClass
+        {
+            public string Prop1 { get; set; }
+            public string Prop2 { get; set; }
+            [JsonProperty(NamingStrategyType = typeof(DefaultNamingStrategy))]
+            public string HasAttributeNamingStrategy { get; set; }
+        }
+
+        [Test]
+        public void JsonObjectAttribute_NamingStrategyType()
+        {
+            ContainerAttributeNamingStrategyTestClass c = new ContainerAttributeNamingStrategyTestClass
+            {
+                Prop1 = "Value1!",
+                Prop2 = "Value2!"
+            };
+
+            string json = JsonConvert.SerializeObject(c, Formatting.Indented);
+
+            StringAssert.AreEqual(@"{
+  ""prop1"": ""Value1!"",
+  ""prop2"": ""Value2!"",
+  ""HasAttributeNamingStrategy"": null
+}", json);
+        }
+
+        [JsonDictionary(NamingStrategyType = typeof(SnakeCaseNamingStrategy), NamingStrategyParameters = new object[] { true, true })]
+        public class DictionaryAttributeNamingStrategyTestClass : Dictionary<string, string>
+        {
+        }
+
+        [Test]
+        public void JsonDictionaryAttribute_NamingStrategyType()
+        {
+            DictionaryAttributeNamingStrategyTestClass c = new DictionaryAttributeNamingStrategyTestClass
+            {
+                ["Key1"] = "Value1!",
+                ["Key2"] = "Value2!"
+            };
+
+            string json = JsonConvert.SerializeObject(c, Formatting.Indented);
+
+            StringAssert.AreEqual(@"{
+  ""key1"": ""Value1!"",
+  ""key2"": ""Value2!""
+}", json);
+        }
+    }
+}

Src/Newtonsoft.Json.Tests/Utilities/StringUtilsTests.cs

@@ -50,14 +50,45 @@ namespace Newtonsoft.Json.Tests.Utilities
             Assert.AreEqual("i", StringUtils.ToCamelCase("I"));
             Assert.AreEqual("", StringUtils.ToCamelCase(""));
             Assert.AreEqual(null, StringUtils.ToCamelCase(null));
-            Assert.AreEqual("iPhone", StringUtils.ToCamelCase("iPhone"));
             Assert.AreEqual("person", StringUtils.ToCamelCase("Person"));
+            Assert.AreEqual("iPhone", StringUtils.ToCamelCase("iPhone"));
             Assert.AreEqual("iPhone", StringUtils.ToCamelCase("IPhone"));
             Assert.AreEqual("i Phone", StringUtils.ToCamelCase("I Phone"));
+            Assert.AreEqual("i  Phone", StringUtils.ToCamelCase("I  Phone"));
             Assert.AreEqual(" IPhone", StringUtils.ToCamelCase(" IPhone"));
+            Assert.AreEqual(" IPhone ", StringUtils.ToCamelCase(" IPhone "));
             Assert.AreEqual("isCIA", StringUtils.ToCamelCase("IsCIA"));
             Assert.AreEqual("vmQ", StringUtils.ToCamelCase("VmQ"));
             Assert.AreEqual("xml2Json", StringUtils.ToCamelCase("Xml2Json"));
+            Assert.AreEqual("snAkEcAsE", StringUtils.ToCamelCase("SnAkEcAsE"));
+            Assert.AreEqual("snA__kEcAsE", StringUtils.ToCamelCase("SnA__kEcAsE"));
+            Assert.AreEqual("snA__ kEcAsE", StringUtils.ToCamelCase("SnA__ kEcAsE"));
+            Assert.AreEqual("already_snake_case_ ", StringUtils.ToCamelCase("already_snake_case_ "));
+        }
+
+        [Test]
+        public void ToSnakeCaseTest()
+        {
+            Assert.AreEqual("url_value", StringUtils.ToSnakeCase("URLValue"));
+            Assert.AreEqual("url", StringUtils.ToSnakeCase("URL"));
+            Assert.AreEqual("id", StringUtils.ToSnakeCase("ID"));
+            Assert.AreEqual("i", StringUtils.ToSnakeCase("I"));
+            Assert.AreEqual("", StringUtils.ToSnakeCase(""));
+            Assert.AreEqual(null, StringUtils.ToSnakeCase(null));
+            Assert.AreEqual("person", StringUtils.ToSnakeCase("Person"));
+            Assert.AreEqual("i_phone", StringUtils.ToSnakeCase("iPhone"));
+            Assert.AreEqual("i_phone", StringUtils.ToSnakeCase("IPhone"));
+            Assert.AreEqual("i_phone", StringUtils.ToSnakeCase("I Phone"));
+            Assert.AreEqual("i_phone", StringUtils.ToSnakeCase("I  Phone"));
+            Assert.AreEqual("i_phone", StringUtils.ToSnakeCase(" IPhone"));
+            Assert.AreEqual("i_phone", StringUtils.ToSnakeCase(" IPhone "));
+            Assert.AreEqual("is_cia", StringUtils.ToSnakeCase("IsCIA"));
+            Assert.AreEqual("vm_q", StringUtils.ToSnakeCase("VmQ"));
+            Assert.AreEqual("xml2_json", StringUtils.ToSnakeCase("Xml2Json"));
+            Assert.AreEqual("sn_ak_ec_as_e", StringUtils.ToSnakeCase("SnAkEcAsE"));
+            Assert.AreEqual("sn_a__k_ec_as_e", StringUtils.ToSnakeCase("SnA__kEcAsE"));
+            Assert.AreEqual("sn_a__k_ec_as_e", StringUtils.ToSnakeCase("SnA__ kEcAsE"));
+            Assert.AreEqual("already_snake_case_", StringUtils.ToSnakeCase("already_snake_case_ "));
         }
     }
 }

Src/Newtonsoft.Json/JsonContainerAttribute.cs

@@ -70,9 +70,9 @@ namespace Newtonsoft.Json
         public object[] ItemConverterParameters { get; set; }
 
         /// <summary>
-        /// Gets the <see cref="Type"/> of the <see cref="INamingStrategy"/>.
+        /// Gets the <see cref="Type"/> of the <see cref="Serialization.NamingStrategy"/>.
         /// </summary>
-        /// <value>The <see cref="Type"/> of the <see cref="INamingStrategy"/>.</value>
+        /// <value>The <see cref="Type"/> of the <see cref="Serialization.NamingStrategy"/>.</value>
         public Type NamingStrategyType
         {
             get { return _namingStrategyType; }
@@ -84,9 +84,9 @@ namespace Newtonsoft.Json
         }
 
         /// <summary>
-        /// The parameter list to use when constructing the <see cref="INamingStrategy"/> described by NamingStrategyType.  
+        /// The parameter list to use when constructing the <see cref="Serialization.NamingStrategy"/> described by NamingStrategyType.  
         /// If null, the default constructor is used.
-        /// When non-null, there must be a constructor defined in the <see cref="INamingStrategy"/> that exactly matches the number,
+        /// When non-null, there must be a constructor defined in the <see cref="Serialization.NamingStrategy"/> that exactly matches the number,
         /// order, and type of these parameters.
         /// </summary>
         /// <example>
@@ -102,7 +102,7 @@ namespace Newtonsoft.Json
             }
         }
 
-        internal INamingStrategy NamingStrategy { get; set; }
+        internal NamingStrategy NamingStrategy { get; set; }
 
         // yuck. can't set nullable properties on an attribute in C#
         // have to use this approach to get an unset default state

Src/Newtonsoft.Json/JsonPropertyAttribute.cs

@@ -66,15 +66,15 @@ namespace Newtonsoft.Json
         public object[] ItemConverterParameters { get; set; }
 
         /// <summary>
-        /// Gets the <see cref="Type"/> of the <see cref="INamingStrategy"/>.
+        /// Gets the <see cref="Type"/> of the <see cref="NamingStrategy"/>.
         /// </summary>
-        /// <value>The <see cref="Type"/> of the <see cref="INamingStrategy"/>.</value>
+        /// <value>The <see cref="Type"/> of the <see cref="NamingStrategy"/>.</value>
         public Type NamingStrategyType { get; set; }
 
         /// <summary>
-        /// The parameter list to use when constructing the <see cref="INamingStrategy"/> described by NamingStrategyType.  
+        /// The parameter list to use when constructing the <see cref="NamingStrategy"/> described by NamingStrategyType.  
         /// If null, the default constructor is used.
-        /// When non-null, there must be a constructor defined in the <see cref="INamingStrategy"/> that exactly matches the number,
+        /// When non-null, there must be a constructor defined in the <see cref="NamingStrategy"/> that exactly matches the number,
         /// order, and type of these parameters.
         /// </summary>
         /// <example>

Src/Newtonsoft.Json/Newtonsoft.Json.Net20.csproj

@@ -133,12 +133,13 @@
     <Compile Include="Serialization\DiagnosticsTraceWriter.cs" />
     <Compile Include="Serialization\ExpressionValueProvider.cs" />
     <Compile Include="Serialization\IAttributeProvider.cs" />
-    <Compile Include="Serialization\INamingStrategy.cs" />
     <Compile Include="Serialization\ITraceWriter.cs" />
     <Compile Include="Serialization\JsonContainerContract.cs" />
     <Compile Include="Serialization\JsonDynamicContract.cs" />
     <Compile Include="Serialization\MemoryTraceWriter.cs" />
+    <Compile Include="Serialization\NamingStrategy.cs" />
     <Compile Include="Serialization\ReflectionAttributeProvider.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategy.cs" />
     <Compile Include="Serialization\TraceJsonReader.cs" />
     <Compile Include="Serialization\TraceJsonWriter.cs" />
     <Compile Include="StringEscapeHandling.cs" />

Src/Newtonsoft.Json/Newtonsoft.Json.Net35.csproj

@@ -147,11 +147,12 @@
     <Compile Include="Serialization\DiagnosticsTraceWriter.cs" />
     <Compile Include="Serialization\ExpressionValueProvider.cs" />
     <Compile Include="Serialization\IAttributeProvider.cs" />
-    <Compile Include="Serialization\INamingStrategy.cs" />
     <Compile Include="Serialization\ITraceWriter.cs" />
     <Compile Include="Serialization\JsonContainerContract.cs" />
     <Compile Include="Serialization\MemoryTraceWriter.cs" />
+    <Compile Include="Serialization\NamingStrategy.cs" />
     <Compile Include="Serialization\ReflectionAttributeProvider.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategy.cs" />
     <Compile Include="Serialization\TraceJsonReader.cs" />
     <Compile Include="Serialization\TraceJsonWriter.cs" />
     <Compile Include="StringEscapeHandling.cs" />

Src/Newtonsoft.Json/Newtonsoft.Json.Net40.csproj

@@ -146,11 +146,12 @@
     <Compile Include="Serialization\DiagnosticsTraceWriter.cs" />
     <Compile Include="Serialization\ExpressionValueProvider.cs" />
     <Compile Include="Serialization\IAttributeProvider.cs" />
-    <Compile Include="Serialization\INamingStrategy.cs" />
     <Compile Include="Serialization\ITraceWriter.cs" />
     <Compile Include="Serialization\JsonContainerContract.cs" />
     <Compile Include="Serialization\MemoryTraceWriter.cs" />
+    <Compile Include="Serialization\NamingStrategy.cs" />
     <Compile Include="Serialization\ReflectionAttributeProvider.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategy.cs" />
     <Compile Include="Serialization\TraceJsonReader.cs" />
     <Compile Include="Serialization\TraceJsonWriter.cs" />
     <Compile Include="StringEscapeHandling.cs" />

Src/Newtonsoft.Json/Newtonsoft.Json.Portable.csproj

@@ -177,7 +177,6 @@
     <Compile Include="Serialization\ErrorEventArgs.cs" />
     <Compile Include="Serialization\IAttributeProvider.cs" />
     <Compile Include="Serialization\IContractResolver.cs" />
-    <Compile Include="Serialization\INamingStrategy.cs" />
     <Compile Include="Serialization\IReferenceResolver.cs" />
     <Compile Include="Serialization\ITraceWriter.cs" />
     <Compile Include="Serialization\IValueProvider.cs" />
@@ -200,10 +199,12 @@
     <Compile Include="Serialization\JsonStringContract.cs" />
     <Compile Include="Serialization\JsonTypeReflector.cs" />
     <Compile Include="Serialization\MemoryTraceWriter.cs" />
+    <Compile Include="Serialization\NamingStrategy.cs" />
     <Compile Include="Serialization\ObjectConstructor.cs" />
     <Compile Include="Serialization\OnErrorAttribute.cs" />
     <Compile Include="Serialization\ReflectionAttributeProvider.cs" />
     <Compile Include="Serialization\ReflectionValueProvider.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategy.cs" />
     <Compile Include="Serialization\TraceJsonReader.cs" />
     <Compile Include="Serialization\TraceJsonWriter.cs" />
     <Compile Include="StringEscapeHandling.cs" />

Src/Newtonsoft.Json/Newtonsoft.Json.Portable40.csproj

@@ -182,7 +182,6 @@
     <Compile Include="Serialization\ExpressionValueProvider.cs" />
     <Compile Include="Serialization\IAttributeProvider.cs" />
     <Compile Include="Serialization\IContractResolver.cs" />
-    <Compile Include="Serialization\INamingStrategy.cs" />
     <Compile Include="Serialization\IReferenceResolver.cs" />
     <Compile Include="Serialization\ITraceWriter.cs" />
     <Compile Include="Serialization\IValueProvider.cs" />
@@ -205,10 +204,12 @@
     <Compile Include="Serialization\JsonStringContract.cs" />
     <Compile Include="Serialization\JsonTypeReflector.cs" />
     <Compile Include="Serialization\MemoryTraceWriter.cs" />
+    <Compile Include="Serialization\NamingStrategy.cs" />
     <Compile Include="Serialization\ObjectConstructor.cs" />
     <Compile Include="Serialization\OnErrorAttribute.cs" />
     <Compile Include="Serialization\ReflectionAttributeProvider.cs" />
     <Compile Include="Serialization\ReflectionValueProvider.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategy.cs" />
     <Compile Include="Serialization\TraceJsonReader.cs" />
     <Compile Include="Serialization\TraceJsonWriter.cs" />
     <Compile Include="StringEscapeHandling.cs" />

Src/Newtonsoft.Json/Newtonsoft.Json.csproj

@@ -168,6 +168,7 @@
     <Compile Include="Schema\ValidationEventHandler.cs" />
     <Compile Include="SerializationBinder.cs" />
     <Compile Include="Serialization\CachedAttributeGetter.cs" />
+    <Compile Include="Serialization\SnakeCaseNamingStrategy.cs" />
     <Compile Include="Serialization\CamelCaseNamingStrategy.cs" />
     <Compile Include="Serialization\CamelCasePropertyNamesContractResolver.cs" />
     <Compile Include="Serialization\DefaultContractResolver.cs" />
@@ -181,7 +182,7 @@
     <Compile Include="Serialization\ExpressionValueProvider.cs" />
     <Compile Include="Serialization\IAttributeProvider.cs" />
     <Compile Include="Serialization\IContractResolver.cs" />
-    <Compile Include="Serialization\INamingStrategy.cs" />
+    <Compile Include="Serialization\NamingStrategy.cs" />
     <Compile Include="Serialization\IReferenceResolver.cs" />
     <Compile Include="Serialization\ITraceWriter.cs" />
     <Compile Include="Serialization\IValueProvider.cs" />

Src/Newtonsoft.Json/Serialization/CamelCaseNamingStrategy.cs

@@ -5,34 +5,21 @@ namespace Newtonsoft.Json.Serialization
     /// <summary>
     /// A camel case naming strategy.
     /// </summary>
-    public class CamelCaseNamingStrategy : INamingStrategy
+    public class CamelCaseNamingStrategy : NamingStrategy
     {
-        /// <summary>
-        /// A flag indicating whether dictionary keys should be camel cased.
-        /// Defaults to <c>false</c>.
-        /// </summary>
-        public bool CamelCaseDictionaryKeys { get; set; }
-
-        /// <summary>
-        /// A flag indicating whether explicitly specified property names,
-        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>, should be camel cased.
-        /// Defaults to <c>false</c>.
-        /// </summary>
-        public bool OverrideSpecifiedNames { get; set; }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="CamelCaseNamingStrategy"/> class.
         /// </summary>
-        /// <param name="camelCaseDictionaryKeys">
-        /// A flag indicating whether dictionary keys should be camel cased.
+        /// <param name="processDictionaryKeys">
+        /// A flag indicating whether dictionary keys should be processed.
         /// </param>
         /// <param name="overrideSpecifiedNames">
-        /// A flag indicating whether explicitly specified property names,
-        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>, should be camel cased.
+        /// A flag indicating whether explicitly specified property names should be processed,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>.
         /// </param>
-        public CamelCaseNamingStrategy(bool camelCaseDictionaryKeys, bool overrideSpecifiedNames)
+        public CamelCaseNamingStrategy(bool processDictionaryKeys, bool overrideSpecifiedNames)
         {
-            CamelCaseDictionaryKeys = camelCaseDictionaryKeys;
+            ProcessDictionaryKeys = processDictionaryKeys;
             OverrideSpecifiedNames = overrideSpecifiedNames;
         }
 
@@ -44,34 +31,13 @@ namespace Newtonsoft.Json.Serialization
         }
 
         /// <summary>
-        /// Gets the serialized name for a given property name.
+        /// Resolves the specified property name.
         /// </summary>
-        /// <param name="s">The initial property name.</param>
-        /// <param name="hasSpecifiedName">A flag indicating whether the property has had a name explicitly specfied.</param>
-        /// <returns>A property name.</returns>
-        public string GetPropertyName(string s, bool hasSpecifiedName)
+        /// <param name="name">The property name to resolve.</param>
+        /// <returns>The resolved property name.</returns>
+        protected override string ResolvePropertyName(string name)
         {
-            if (hasSpecifiedName && !OverrideSpecifiedNames)
-            {
-                return s;
-            }
-
-            return StringUtils.ToCamelCase(s);
-        }
-
-        /// <summary>
-        /// Gets the serialized key for a given dictionary key.
-        /// </summary>
-        /// <param name="s">The initial dictionary key.</param>
-        /// <returns>A dictionary key.</returns>
-        public string GetDictionaryKey(string s)
-        {
-            if (!CamelCaseDictionaryKeys)
-            {
-                return s;
-            }
-
-            return StringUtils.ToCamelCase(s);
+            return StringUtils.ToCamelCase(name);
         }
     }
 }

Src/Newtonsoft.Json/Serialization/CamelCasePropertyNamesContractResolver.cs

@@ -43,7 +43,7 @@ namespace Newtonsoft.Json.Serialization
         {
             NamingStrategy = new CamelCaseNamingStrategy
             {
-                CamelCaseDictionaryKeys = true,
+                ProcessDictionaryKeys = true,
                 OverrideSpecifiedNames = true
             };
         }

Src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs

@@ -188,7 +188,7 @@ namespace Newtonsoft.Json.Serialization
         /// Gets or sets the naming strategy used to resolve how property names and dictionary keys are serialized.
         /// </summary>
         /// <value>The naming strategy used to resolve how property names and dictionary keys are serialized.</value>
-        public INamingStrategy NamingStrategy { get; set; }
+        public NamingStrategy NamingStrategy { get; set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DefaultContractResolver"/> class.
@@ -947,7 +947,7 @@ namespace Newtonsoft.Json.Serialization
             JsonContainerAttribute containerAttribute = JsonTypeReflector.GetAttribute<JsonContainerAttribute>(objectType);
             if (containerAttribute?.NamingStrategyType != null)
             {
-                INamingStrategy namingStrategy = JsonTypeReflector.GetContainerNamingStrategy(containerAttribute);
+                NamingStrategy namingStrategy = JsonTypeReflector.GetContainerNamingStrategy(containerAttribute);
                 contract.DictionaryKeyResolver = s => namingStrategy.GetDictionaryKey(s);
             }
             else
@@ -1084,7 +1084,7 @@ namespace Newtonsoft.Json.Serialization
             JsonContainerAttribute containerAttribute = JsonTypeReflector.GetAttribute<JsonContainerAttribute>(objectType);
             if (containerAttribute?.NamingStrategyType != null)
             {
-                INamingStrategy namingStrategy = JsonTypeReflector.GetContainerNamingStrategy(containerAttribute);
+                NamingStrategy namingStrategy = JsonTypeReflector.GetContainerNamingStrategy(containerAttribute);
                 contract.PropertyNameResolver = s => namingStrategy.GetDictionaryKey(s);
             }
             else
@@ -1433,7 +1433,7 @@ namespace Newtonsoft.Json.Serialization
 
             JsonContainerAttribute containerAttribute = JsonTypeReflector.GetAttribute<JsonContainerAttribute>(declaringType);
 
-            INamingStrategy namingStrategy;
+            NamingStrategy namingStrategy;
             if (propertyAttribute?.NamingStrategyType != null)
             {
                 namingStrategy = JsonTypeReflector.CreateNamingStrategyInstance(propertyAttribute.NamingStrategyType, propertyAttribute.NamingStrategyParameters);

Src/Newtonsoft.Json/Serialization/DefaultNamingStrategy.cs

@@ -3,27 +3,16 @@
     /// <summary>
     /// The default naming strategy. Property names and dictionary keys are unchanged.
     /// </summary>
-    public class DefaultNamingStrategy : INamingStrategy
+    public class DefaultNamingStrategy : NamingStrategy
     {
         /// <summary>
-        /// Gets the serialized name for a given property name.
+        /// Resolves the specified property name.
         /// </summary>
-        /// <param name="s">The initial property name.</param>
-        /// <param name="hasSpecifiedName">A flag indicating whether the property has had a name explicitly specfied.</param>
-        /// <returns>A property name.</returns>
-        public string GetPropertyName(string s, bool hasSpecifiedName)
+        /// <param name="name">The property name to resolve.</param>
+        /// <returns>The resolved property name.</returns>
+        protected override string ResolvePropertyName(string name)
         {
-            return s;
-        }
-
-        /// <summary>
-        /// Gets the serialized key for a given dictionary key.
-        /// </summary>
-        /// <param name="s">The initial dictionary key.</param>
-        /// <returns>A dictionary key.</returns>
-        public string GetDictionaryKey(string s)
-        {
-            return s;
+            return name;
         }
     }
 }

Src/Newtonsoft.Json/Serialization/INamingStrategy.cs

@@ -1,23 +0,0 @@
-namespace Newtonsoft.Json.Serialization
-{
-    /// <summary>
-    /// An interface for resolving how property names and dictionary keys are serialized.
-    /// </summary>
-    public interface INamingStrategy
-    {
-        /// <summary>
-        /// Gets the serialized name for a given property name.
-        /// </summary>
-        /// <param name="s">The initial property name.</param>
-        /// <param name="hasSpecifiedName">A flag indicating whether the property has had a name explicitly specfied.</param>
-        /// <returns>A property name.</returns>
-        string GetPropertyName(string s, bool hasSpecifiedName);
-
-        /// <summary>
-        /// Gets the serialized key for a given dictionary key.
-        /// </summary>
-        /// <param name="s">The initial dictionary key.</param>
-        /// <returns>A dictionary key.</returns>
-        string GetDictionaryKey(string s);
-    }
-}

Src/Newtonsoft.Json/Serialization/JsonTypeReflector.cs

@@ -184,13 +184,13 @@ namespace Newtonsoft.Json.Serialization
             return (JsonConverter)converterCreator(converterArgs);
         }
 
-        public static INamingStrategy CreateNamingStrategyInstance(Type namingStrategyType, object[] converterArgs)
+        public static NamingStrategy CreateNamingStrategyInstance(Type namingStrategyType, object[] converterArgs)
         {
             Func<object[], object> converterCreator = CreatorCache.Get(namingStrategyType);
-            return (INamingStrategy)converterCreator(converterArgs);
+            return (NamingStrategy)converterCreator(converterArgs);
         }
 
-        public static INamingStrategy GetContainerNamingStrategy(JsonContainerAttribute containerAttribute)
+        public static NamingStrategy GetContainerNamingStrategy(JsonContainerAttribute containerAttribute)
         {
             if (containerAttribute.NamingStrategy == null)
             {

Src/Newtonsoft.Json/Serialization/NamingStrategy.cs

@@ -0,0 +1,59 @@
+namespace Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// A base class for resolving how property names and dictionary keys are serialized.
+    /// </summary>
+    public abstract class NamingStrategy
+    {
+        /// <summary>
+        /// A flag indicating whether dictionary keys should be processed.
+        /// Defaults to <c>false</c>.
+        /// </summary>
+        public bool ProcessDictionaryKeys { get; set; }
+
+        /// <summary>
+        /// A flag indicating whether explicitly specified property names,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>, should be processed.
+        /// Defaults to <c>false</c>.
+        /// </summary>
+        public bool OverrideSpecifiedNames { get; set; }
+
+        /// <summary>
+        /// Gets the serialized name for a given property name.
+        /// </summary>
+        /// <param name="name">The initial property name.</param>
+        /// <param name="hasSpecifiedName">A flag indicating whether the property has had a name explicitly specfied.</param>
+        /// <returns>A property name.</returns>
+        public virtual string GetPropertyName(string name, bool hasSpecifiedName)
+        {
+            if (hasSpecifiedName && !OverrideSpecifiedNames)
+            {
+                return name;
+            }
+
+            return ResolvePropertyName(name);
+        }
+
+        /// <summary>
+        /// Gets the serialized key for a given dictionary key.
+        /// </summary>
+        /// <param name="key">The initial dictionary key.</param>
+        /// <returns>A dictionary key.</returns>
+        public virtual string GetDictionaryKey(string key)
+        {
+            if (!ProcessDictionaryKeys)
+            {
+                return key;
+            }
+
+            return ResolvePropertyName(key);
+        }
+
+        /// <summary>
+        /// Resolves the specified property name.
+        /// </summary>
+        /// <param name="name">The property name to resolve.</param>
+        /// <returns>The resolved property name.</returns>
+        protected abstract string ResolvePropertyName(string name);
+    }
+}

Src/Newtonsoft.Json/Serialization/SnakeCaseNamingStrategy.cs

@@ -0,0 +1,43 @@
+using Newtonsoft.Json.Utilities;
+
+namespace Newtonsoft.Json.Serialization
+{
+    /// <summary>
+    /// A snake case naming strategy.
+    /// </summary>
+    public class SnakeCaseNamingStrategy : NamingStrategy
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SnakeCaseNamingStrategy"/> class.
+        /// </summary>
+        /// <param name="processDictionaryKeys">
+        /// A flag indicating whether dictionary keys should be processed.
+        /// </param>
+        /// <param name="overrideSpecifiedNames">
+        /// A flag indicating whether explicitly specified property names should be processed,
+        /// e.g. a property name customized with a <see cref="JsonPropertyAttribute"/>.
+        /// </param>
+        public SnakeCaseNamingStrategy(bool processDictionaryKeys, bool overrideSpecifiedNames)
+        {
+            ProcessDictionaryKeys = processDictionaryKeys;
+            OverrideSpecifiedNames = overrideSpecifiedNames;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SnakeCaseNamingStrategy"/> class.
+        /// </summary>
+        public SnakeCaseNamingStrategy()
+        {
+        }
+
+        /// <summary>
+        /// Resolves the specified property name.
+        /// </summary>
+        /// <param name="name">The property name to resolve.</param>
+        /// <returns>The resolved property name.</returns>
+        protected override string ResolvePropertyName(string name)
+        {
+            return StringUtils.ToSnakeCase(name);
+        }
+    }
+}

Src/Newtonsoft.Json/Utilities/StringUtils.cs

@@ -190,16 +190,92 @@ namespace Newtonsoft.Json.Utilities
                     break;
                 }
 
+                char c;
 #if !(DOTNET || PORTABLE)
-                chars[i] = char.ToLower(chars[i], CultureInfo.InvariantCulture);
+                c = char.ToLower(chars[i], CultureInfo.InvariantCulture);
 #else
-                chars[i] = char.ToLowerInvariant(chars[i]);
+                c = char.ToLowerInvariant(chars[i]);
 #endif
+                chars[i] = c;
             }
 
             return new string(chars);
         }
 
+        internal enum SnakeCaseState
+        {
+            Start,
+            Lower,
+            Upper,
+            NewWord
+        }
+
+        public static string ToSnakeCase(string s)
+        {
+            if (string.IsNullOrEmpty(s))
+            {
+                return s;
+            }
+
+            StringBuilder sb = new StringBuilder();
+            SnakeCaseState state = SnakeCaseState.Start;
+
+            for (int i = 0; i < s.Length; i++)
+            {
+                if (s[i] == ' ')
+                {
+                    if (state != SnakeCaseState.Start)
+                    {
+                        state = SnakeCaseState.NewWord;
+                    }
+                }
+                else if (char.IsUpper(s[i]))
+                {
+                    switch (state)
+                    {
+                    case SnakeCaseState.Upper:
+                        bool hasNext = (i + 1 < s.Length);
+                        if (i > 0 && hasNext && !char.IsUpper(s[i + 1]))
+                        {
+                            sb.Append('_');
+                        }
+                        break;
+                    case SnakeCaseState.Lower:
+                    case SnakeCaseState.NewWord:
+                        sb.Append('_');
+                        break;
+                    }
+
+                    char c;
+#if !(DOTNET || PORTABLE)
+                    c = char.ToLower(s[i], CultureInfo.InvariantCulture);
+#else
+                    c = char.ToLowerInvariant(s[i]);
+#endif
+                    sb.Append(c);
+
+                    state = SnakeCaseState.Upper;
+                }
+                else if (s[i] == '_')
+                {
+                    sb.Append('_');
+                    state = SnakeCaseState.Start;
+                }
+                else
+                {
+                    if (state == SnakeCaseState.NewWord)
+                    {
+                        sb.Append('_');
+                    }
+
+                    sb.Append(s[i]);
+                    state = SnakeCaseState.Lower;
+                }
+            }
+
+            return sb.ToString();
+        }
+
         public static bool IsHighSurrogate(char c)
         {
 #if !(PORTABLE40 || PORTABLE)