using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization.Formatters;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Reflection;

using System.Collections.ObjectModel;

using System.Diagnostics;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

//https://stackoverflow.com/questions/68718843/deserialize-json-with-dashes-kebab-case-in-property-names-in-c-sharp-using-new

​

    // Adapted from this answer https://stackoverflow.com/a/40599731/3744182

    // by https://stackoverflow.com/users/3744182/dbc

    // To https://stackoverflow.com/questions/40597532/json-net-custom-name-resolver-for-sub-properties

    // Handle recursion when applied to an object rather than to a property.

    public class AlternateContractResolverConverter : JsonConverter

    {

        [ThreadStatic]

        static Stack<Type> contractResolverTypeStack;

​

        static Stack<Type> ContractResolverTypeStack { get { return contractResolverTypeStack = (contractResolverTypeStack ?? new Stack<Type>()); } }

        readonly IContractResolver resolver;

​

        JsonSerializerSettings ExtractAndOverrideSettings(JsonSerializer serializer)

        {

            var settings = serializer.ExtractSettings();

            settings.ContractResolver = resolver;

            settings.CheckAdditionalContent = false;

            if (settings.PreserveReferencesHandling != PreserveReferencesHandling.None)

            {

                // Log an error throw an exception?

                Debug.WriteLine(string.Format("PreserveReferencesHandling.{0} not supported", serializer.PreserveReferencesHandling));

            }

            return settings;

        }

​

        public AlternateContractResolverConverter(Type resolverType)

        {

            if (resolverType == null)

                throw new ArgumentNullException("resolverType");

            resolver = (IContractResolver)Activator.CreateInstance(resolverType);

            if (resolver == null)

                throw new ArgumentNullException(string.Format("Resolver type {0} not found", resolverType));

        }

​

        public override bool CanRead { get { return !ContractResolverTypeStack.TryPeek(out var resolverType) || resolverType != resolver.GetType(); } }

        public override bool CanWrite { get { return !ContractResolverTypeStack.TryPeek(out var resolverType) || resolverType != resolver.GetType(); } }

​

        public override bool CanConvert(Type objectType)

        {

            throw new NotImplementedException("This contract resolver is intended to be applied directly with [JsonConverter(typeof(AlternateContractResolverConverter), typeof(SomeContractResolver))] or [JsonProperty(ItemConverterType = typeof(AlternateContractResolverConverter), ItemConverterParameters = ...)]");

        }

​

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

        {

            using (ContractResolverTypeStack.PushUsing(resolver.GetType()))

                return JsonSerializer.CreateDefault(ExtractAndOverrideSettings(serializer)).Deserialize(reader, objectType);

        }

​

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

        {

            using (ContractResolverTypeStack.PushUsing(resolver.GetType()))

                JsonSerializer.CreateDefault(ExtractAndOverrideSettings(serializer)).Serialize(writer, value);

        }

    }

​

    internal static class JsonSerializerExtensions

    {

        public static JsonSerializerSettings ExtractSettings(this JsonSerializer serializer)

        {

            // There is no built-in API to extract the settings from a JsonSerializer back into JsonSerializerSettings,

            // so we have to fake it here.

            if (serializer == null)

                throw new ArgumentNullException("serializer");

            var settings = new JsonSerializerSettings

            {

                //Binder was obsoleted and replaced with SerializationBinder in Json.NET 10.0.1

                //Binder = serializer.Binder,

                SerializationBinder = serializer.SerializationBinder,

                CheckAdditionalContent = serializer.CheckAdditionalContent,

                ConstructorHandling = serializer.ConstructorHandling,

                ContractResolver = serializer.ContractResolver,

                Converters = serializer.Converters,

                Context = serializer.Context,

                Culture = serializer.Culture,

                DateFormatHandling = serializer.DateFormatHandling,

                DateFormatString = serializer.DateFormatString,

                DateParseHandling = serializer.DateParseHandling,

                DateTimeZoneHandling = serializer.DateTimeZoneHandling,

                DefaultValueHandling = serializer.DefaultValueHandling,

                EqualityComparer = serializer.EqualityComparer,

                // No Get access to the error event, so it cannot be copied.

                // Error = += serializer.Error

                FloatFormatHandling = serializer.FloatFormatHandling,

                FloatParseHandling = serializer.FloatParseHandling,

                Formatting = serializer.Formatting,

                MaxDepth = serializer.MaxDepth,

                MetadataPropertyHandling = serializer.MetadataPropertyHandling,

                MissingMemberHandling = serializer.MissingMemberHandling,

                NullValueHandling = serializer.NullValueHandling,

                ObjectCreationHandling = serializer.ObjectCreationHandling,

                ReferenceLoopHandling = serializer.ReferenceLoopHandling,

                // Copying the reference resolver doesn't work in the default case, since the

                // actual BidirectionalDictionary<string, object> mappings are held in the 

                // JsonSerializerInternalBase.

                // See https://github.com/JamesNK/Newtonsoft.Json/blob/master/Src/Newtonsoft.Json/Serialization/DefaultReferenceResolver.cs

                ReferenceResolverProvider = () => serializer.ReferenceResolver,

                PreserveReferencesHandling = serializer.PreserveReferencesHandling,

                StringEscapeHandling = serializer.StringEscapeHandling,

                TraceWriter = serializer.TraceWriter,

                //TypeNameAssemblyFormat was obsoleted and replaced with TypeNameAssemblyFormatHandling in Json.NET 10.0.1

                //TypeNameAssemblyFormat = serializer.TypeNameAssemblyFormat,

                TypeNameAssemblyFormatHandling = serializer.TypeNameAssemblyFormatHandling,

                TypeNameHandling = serializer.TypeNameHandling,

            };

            return settings;

        }

    }

​

    public static class StackExtensions

    {

        public struct PushValue<T> : IDisposable

        {

            readonly Stack<T> stack;

​

            public PushValue(T value, Stack<T> stack)

            {

                this.stack = stack;

                stack.Push(value);

            }

​

            // By using a disposable struct we avoid the overhead of allocating and freeing an instance of a finalizable class.

            public void Dispose()

            {

                if (stack != null)

                    stack.Pop();

            }

        }

​

        public static PushValue<T> PushUsing<T>(this Stack<T> stack, T value)

        {

            if (stack == null)

                throw new ArgumentNullException();

            return new PushValue<T>(value, stack);

        }

    }

​

// End of code adapted from https://stackoverflow.com/a/40599731/3744182

​

// Test case taken from https://dotnetfiddle.net/8T4osw

// By https://stackoverflow.com/users/973122/adam

​

    public class KebabCaseContractResolver : DefaultContractResolver

    {

        public KebabCaseContractResolver()

        {

            NamingStrategy = new KebabCaseNamingStrategy();

        }

    }

​

    [JsonConverter(typeof(AlternateContractResolverConverter), typeof(KebabCaseContractResolver))]

    public class Person

    {

        public Name FullName { get; set; }

    }

​

    public class Name

    {

        public string FirstName { get; set; }

        public string LastName { get; set; }

    }

​

// End of test case by https://stackoverflow.com/users/973122/adam

​

    class TestClass

    {

        public static void Test()

        {

            var person = new Person

            {

                FullName = new Name

                {

                    FirstName = "john",

                    LastName = "doe",

                },

            };

            var json = JsonConvert.SerializeObject(new { PersonContainerNotInKebabCase = person }, Formatting.Indented);

​

            Console.WriteLine(json);

        }   

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                Console.WriteLine(typeof(SnakeCaseNamingStrategy));

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​

#if false

`[JsonObject(NamingStrategyType = typeof(KebabCaseNamingStrategy))]` only applies to properties declared by that type.  It (apparently) doesn't apply to base class properties, and definitely doesn't recursively to properties of referenced objects in the serialization graph.

​

To change naming strategy for an object and all nested objects, see [JSON .NET Custom Name Resolver for Sub-Properties](https://stackoverflow.com/q/40597532/3744182).  You may need to create your own `KebabCaseContractResolver` to use the accepted answer as-is.  Or you could enhance it to add an second constructor for `AlternateContractResolverConverter` that takes a naming strategy type.  Does that answer your question sufficiently?

​

The correct usage would be `[JsonConverter(typeof(AlternateContractResolverConverter), typeof(KebabCaseContractResolver))]` not `[JsonConverter(typeof(KebabCaseContractResolver))]` because a contract resolver is not a converter.  But it turns out that `AlternateContractResolverConverter` had a bug or limitation making it not work when applied to a type instead of a property.  You can see a fixed version here: https://dotnetfiddle.net/Q8kDw2.  Does that answer your question?

#endif

​