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 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/67920658/serializing-properties-with-same-name

​

    public class A

    {

        [JsonProperty("id")]

        public string Id { get { return "A:ID"; } } // Fixed compilation

​

        [JsonProperty("CompKey")]

        public string CompKey { get; set; }

    }

​

    public class B : A

    {

        [JsonProperty("id")]

        public new string Id { get { return "B:ID"; } } // Fixed compilation

​

        [JsonProperty("name")]

        public string Name { get; set; }

    }

​

namespace V1

{

    public class DatabaseEntryResolver : DefaultContractResolver

    {

        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)

        {

            var property = base.CreateProperty(member, memberSerialization);

            if (member.ReflectedType == typeof(B)) // Use (typeof(A).IsAssignableFrom(member.ReflectedType)) if you want this to apply to all subclasses of A

            {

                // Make A.Id supersede B.Id

                if (member.Name == nameof(A.Id) && member.DeclaringType != typeof(A))

                    property.Ignored = true;

            }

            return property;

        }

    }

}

​

namespace V2

{

    public class DatabaseEntryResolver : V1.DatabaseEntryResolver

    {

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

        {

            var properties = base.CreateProperties(type, memberSerialization);

            if (type == typeof(B)) // Use typeof(A).IsAssignableFrom(type)) if you want to only serialize the Id property of A and all its subclasses

            {

                // Remove everything except Id.  You could also Ignore everything except Id.

                properties = properties.Where(p => p.UnderlyingName == nameof(A.Id)).ToList();

            }

            return properties;

        }

    }

}

​

namespace V3

{

    public class DatabaseEntryResolver : DefaultContractResolver

    {

        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)

        {

            var property = base.CreateProperty(member, memberSerialization);

            if (typeof(A).IsAssignableFrom(member.ReflectedType)) // Use (typeof(A).IsAssignableFrom(member.ReflectedType)) if you want this to apply to all subclasses of A

            {

                // Make A.Id supersede B.Id

                if (member.Name == nameof(A.Id) && member.DeclaringType != typeof(A))

                    property.Ignored = true;

            }

            return property;

        }

​

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

        {

            var properties = base.CreateProperties(type, memberSerialization);

            if (typeof(A).IsAssignableFrom(type)) // Use typeof(A).IsAssignableFrom(type)) if you want to only serialize the Id property of A and all its subclasses

            {

                // Remove everything except Id.  You could also Ignore everything except Id.

                properties = properties.Where(p => p.UnderlyingName == nameof(A.Id)).ToList();

            }

            return properties;

        }

    }

}

​

namespace RyanFalzon

{

    //https://stackoverflow.com/a/67928177/3744182

    public class DatabaseEntryResolver : DefaultContractResolver

    {

        protected override List<MemberInfo> GetSerializableMembers(Type objectType)

        {

            return base.GetSerializableMembers(objectType).Where(member => member.DeclaringType == typeof(A)).ToList(); // Fixed compilation

        }

​

        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)

        {

            var property = base.CreateProperty(member, memberSerialization);

            property.ShouldSerialize = instance => property.DeclaringType == typeof(A);

            return property;

        }

    }   

}

​

    class TestClass

    {

        public static void Test()

        {

            Test<V1.DatabaseEntryResolver>();

            Test<V2.DatabaseEntryResolver>();

            Test<V3.DatabaseEntryResolver>();

            Test<RyanFalzon.DatabaseEntryResolver>();

        }

        public static void Test<DatabaseEntryResolver>() where DatabaseEntryResolver : DefaultContractResolver, new()

        {

            Console.WriteLine("\nTesting {0}", typeof(DatabaseEntryResolver).FullName);

            var resolver = new DatabaseEntryResolver();

            resolver.ResolveContract(typeof(B));

            var settings = new JsonSerializerSettings

            {

                ContractResolver = resolver,

            };

            var jsonA = JsonConvert.SerializeObject(new A(), Formatting.Indented, settings);

            Console.WriteLine("JSON for {0}", nameof(A));

            Console.WriteLine(jsonA);

​

            var jsonB = JsonConvert.SerializeObject(new B(), Formatting.Indented, settings);

            Console.WriteLine("JSON for {0}", nameof(B));

            Console.WriteLine(jsonB);

            Assert.IsTrue(!jsonB.Contains("B:ID"));

            Assert.IsTrue(jsonB.Contains("A:ID"));

            Assert.IsTrue(jsonA.Contains("A:ID"));

        }   

    }

​

    public static partial class JsonExtensions

    {

        public static string ToDebugString(this MemberInfo property)

        {

            return property == null ? "" : string.Format("{{{0} (for {1} Declared in {2}, reflected in {3}{4})}}", property, property.Name, property.DeclaringType.Name, property.ReflectedType.Name);

        }

​

        public static string ToDebugString(this JsonProperty property)

        {

            return property == null ? "" : string.Format("{{{0} (for {1} Declared in {2}{5})}}", property, property.UnderlyingName, property.DeclaringType.Name, property.Ignored ? " (Ignored)" : "");

        }

        public static string ToDebugString(this (MemberInfo member, JsonProperty property) pair)

        {

            return pair.property == null ? "" : string.Format("{{{0} (for {1} Declared in {2}, Reflected from {3}{4})}}", pair.property, pair.member.Name, pair.member.ReflectedType, pair.member.DeclaringType, pair.property.Ignored ? " (Ignored)" : "");

        }

    }

​

    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

            {

                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;

        }

    }

​