using System;

using System.Text.Json;

using System.Reflection;

using System.Linq;

using System.Collections.Generic;

using System.Runtime.CompilerServices;

​

//https://stackoverflow.com/questions/62059046/how-to-serialize-interface-default-property

​

namespace ConsoleApp

{

    public interface INotification

    {

        Severity Severity { get; set; }

        string Message { get; set; }

​

        public string SeverityName 

        {

            get

            {

                //var t = System.Environment.StackTrace;

                //t.Dump();

                return Severity.ToString().ToLower();

            }

        }

    }

​

    public enum Severity

    {

        Info,

        Warning,

        Error,

    }

​

    public class Notification : INotification

    {

        public Severity Severity { get; set; }

        public string Message { get; set; }

    }

​

    public class NotificationWithOverride : INotification

    {

        public Severity Severity { get; set; }

        public string Message { get; set; }

        // No way to call "base" to get the default implementation.

        // https://stackoverflow.com/a/59387883

        // https://stackoverflow.com/a/59748670

        // https://github.com/dotnet/csharplang/blob/master/meetings/2019/LDM-2019-04-29.md#default-interface-implementations-and-base-calls

        public string SeverityName => Severity.ToString().ToLower();

    }

    public class NotificationWithOverrideAndBaseCall : INotification

    {

        static Func<INotification, string> GetBaseSeverity = 

            (Func<INotification, string>)

                Delegate.CreateDelegate(typeof(Func<INotification, string>), null, typeof(INotification).GetProperty(nameof(INotification.SeverityName)).GetGetMethod());

        public Severity Severity { get; set; }

        public string Message { get; set; }

        // No way to call "base" to get the default implementation.

        // https://stackoverflow.com/a/59387883

        // https://stackoverflow.com/a/59748670

        // https://github.com/dotnet/csharplang/blob/master/meetings/2019/LDM-2019-04-29.md#default-interface-implementations-and-base-calls

        public string SeverityName => GetBaseSeverity(this);

    }

​

    public static class TypeExtension

    {

        //https://stackoverflow.com/questions/299515/reflection-to-identify-extension-methods

        //https://stackoverflow.com/a/8793755

        //https://stackoverflow.com/users/965953/wolfgang-stelzhammer

        /// <summary>

        /// This Methode extends the System.Type-type to get all extended methods. It searches hereby in all assemblies which are known by the current AppDomain.

        /// </summary>

        /// <remarks>

        /// Insired by Jon Skeet from his answer on http://stackoverflow.com/questions/299515/c-sharp-reflection-to-identify-extension-methods

        /// </remarks>

        /// <returns>returns MethodInfo[] with the extended Method</returns>

​

        public static MethodInfo[] GetExtensionMethods(this Type t, Assembly assembly = null)

        {

            //https://stackoverflow.com/questions/299515/reflection-to-identify-extension-methods

            var assemblies = assembly == null ? AppDomain.CurrentDomain.GetAssemblies() : new [] { assembly };

            var query = from a in assemblies

                from type in a.GetTypes()

                where type.IsSealed && !type.IsGenericType && !type.IsNested

                from method in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)

                where method.IsDefined(typeof(ExtensionAttribute), false)

                where method.GetParameters()[0].ParameterType == t

                select method;

            return query.ToArray<MethodInfo>();

        }

​

        /// <summary>

        /// Extends the System.Type-type to search for a given extended MethodeName.

        /// </summary>

        /// <param name="MethodeName">Name of the Methode</param>

        /// <returns>the found Methode or null</returns>

        public static MethodInfo GetExtensionMethod(this Type t, string MethodeName, Assembly assembly = null)

        {

            var mi = from methode in t.GetExtensionMethods(assembly)

                where methode.Name == MethodeName

                select methode;

            if (mi.Count<MethodInfo>() <= 0)

                return null;

            else

                return mi.First<MethodInfo>();

        }

    }   

​

    class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("\nProperties of {0}: [{1}]", typeof(INotification), string.Join(", ", typeof(INotification).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Select(p => p.Name)));

            Console.WriteLine("Methods of {0}: [{1}]", typeof(INotification), string.Join(", ", typeof(INotification).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Select(p => p.Name)));

            Console.WriteLine("Extension methods of {0}: [{1}]", nameof(INotification.SeverityName), string.Join(", ", typeof(INotification).GetExtensionMethods(typeof(INotification).Assembly).Select(m => m.Name)));

            Console.WriteLine("{0}.{1} method type name: {2}", nameof(INotification), nameof(INotification.SeverityName), typeof(INotification).GetProperty(nameof(INotification.SeverityName)).GetGetMethod().GetType().FullName);

            Test<Notification>();

            Test<NotificationWithOverride>();

            Test<NotificationWithOverrideAndBaseCall>();

        }

​

        static void TestNonGeneric()

        {           

            var notification = new Notification

            {

                Message = "Message",

                Severity = Severity.Info

            };

​

            notification.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Select(p => p.Name).ToArray().Dump();

            Console.WriteLine(((INotification)notification).SeverityName);

            var jsonText = JsonSerializer.Serialize(notification);

            Console.WriteLine(jsonText);

        }

        static void Test<TNotification>() where TNotification : INotification, new()

        {

            Console.WriteLine("\nTesting {0}:", typeof(TNotification));

            var notification = new TNotification

            {

                Message = "Message",

                Severity = Severity.Info

            };

​

            Console.WriteLine("Properties of {0}: {1}", typeof(TNotification), string.Join(", ", notification.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Select(p => p.Name)));

            Console.WriteLine("Methods of {0}: {1}", typeof(TNotification), string.Join(", ", notification.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Select(p => p.Name)));

            ShowInterfaceMapping(typeof(INotification), typeof(TNotification));

            Console.WriteLine("{0} = {1}", nameof(INotification.SeverityName), notification.SeverityName);

            var jsonText = JsonSerializer.Serialize(notification);

            Console.WriteLine(jsonText);

            Console.WriteLine("Result from Json.NET:");

            Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(notification));

        }

        private static void ShowInterfaceMapping(Type intType, Type implType)

        {

            // Code from 

            // https://docs.microsoft.com/en-us/dotnet/api/system.type.getinterfacemap?view=netcore-3.1#examples

            InterfaceMapping map = implType.GetInterfaceMap(intType);

            Console.WriteLine("Mapping of {0} to {1}: ", map.InterfaceType, map.TargetType);

            for (int ctr = 0; ctr < map.InterfaceMethods.Length; ctr++) {

                MethodInfo im = map.InterfaceMethods[ctr];

                MethodInfo tm = map.TargetMethods[ctr];

                Console.WriteLine("   {0} --> {1} ({2})", im.Name,tm.Name, tm.ReflectedType);

            }

            Console.WriteLine();

        }

    }

}

​