[Fork] [Fork] [Fork] [Fork] C# Class To Javascript Object

CSharp · Console

/Program.cs

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
{
		// Kludge to make classes that override SeverityName be able to access the default implementation.
		// 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 interface INotification
    {
        Severity Severity { get; set; }
        string Message { get; set; }

		static string MakeDefaultSeverityName<TNotification>(TNotification notification) where TNotification : INotification => notification?.Severity.ToString().ToLower();
		
        public string SeverityName => MakeDefaultSeverityName(this);
    }

    public class Notification : INotification
    {
        public Severity Severity { get; set; }
        public string Message { get; set; }
    }

    public class NotificationWithOverride : Notification
    {
		public string SeverityName => INotification.MakeDefaultSeverityName(this);
    }
	
    public enum Severity
    {
        Info,
        Warning,
        Error,
    }
	
    class Program
    {
        static void Main(string[] args)
        {
			ShowPropertiesAndMethods<INotification>();
			
			Test<Notification>();
			Test<NotificationWithOverride>();
        }

		static void Test<TNotification>() where TNotification : INotification, new()
		{
			Console.WriteLine("\nTesting {0}:", typeof(TNotification));
            var notification = new TNotification
            {
                Message = "Message",
                Severity = Severity.Info
            };

			ShowPropertiesAndMethods<TNotification>();
			ShowInterfaceMapping(typeof(INotification), typeof(TNotification));
			Console.WriteLine("{0} = {1}", nameof(INotification.SeverityName), notification.SeverityName);
			
            var jsonText = JsonSerializer.Serialize(notification);
			Console.WriteLine("Serialization result from System.Text.Json:");
            Console.WriteLine(jsonText);
			Console.WriteLine("Serialization result from Json.NET:");
			Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(notification));
		}
		
		private static void ShowPropertiesAndMethods<TNotification>()
		{
			Console.WriteLine("Properties of {0}: {1}", typeof(TNotification).Name, string.Join(", ", typeof(TNotification).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Select(p => p.Name)));
			Console.WriteLine("Methods of {0}: {1}", typeof(TNotification).Name, string.Join(", ", typeof(TNotification).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Select(p => p.Name)));
		}
		
		private static void ShowInterfaceMapping(Type intType, Type implType)
		{
			// Code adapted 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} (Reflected type {2})", im.Name,tm.Name, tm.ReflectedType);
			}
		}
    }
}
;