CSharp · Console
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.Runtime.Serialization;
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/64474856/c-sharp-using-newtonsoft-json-defaultcontractresolver-ivalueprovider-to-replace
public class JsonTester
{
public void Test()
{
var d = new Outer();
var json = JsonConvert.SerializeObject(d, new JsonSerializerSettings()
{
ContractResolver = new JsonContractResolver()
});
}
}
public interface IVariant
{
object Data { get; }
string TypeName { get; set; }
}
public interface IVariantData
{
}
[DataContract]
public class Variant<TEnum, TData> : IVariant where TEnum : struct where TData : class, IVariantData, new()
{
[DataMember]
public TData Data { get; }
public string TypeName { get; set; }
object IVariant.Data => Data;
public Variant()
{
Data = new TData();
}
}
[DataContract]
public sealed class VariantHolder
{
[DataContract]
public class Joystick
{
[DataMember]
public string Test { get; set; } = "Test";
}
[DataContract]
public class Button
{
[DataMember]
public string Test2 { get; set; } = "Test2";
}
[DataContract]
public sealed class AimΞVariant : Variant<AimΞVariant.VariantEnum, AimΞVariant.VariantData>
{
public AimΞVariant()
{
TypeName = "Button";
}
public enum VariantEnum : byte
{
Joystick,
Button
}
[DataContract]
public sealed class VariantData : IVariantData
{
[DataMember]
Joystick _Joystick = new Joystick();
[DataMember]
Button _Button = new Button();
public Button Button => _Button;
public Joystick Joystick => _Joystick;
}
}
[DataMember]
AimΞVariant Aim = new AimΞVariant();
}
[DataContract]
public sealed class Outer
{
[DataMember]
VariantHolder Data = new VariantHolder();
}
public class JsonContractResolver : DefaultContractResolver
{
public JsonContractResolver()
{
}
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
return base.CreateProperty(member, memberSerialization);
}
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
var list = type.GetProperties().Where(x => x.GetCustomAttributes().Any(a => a.GetType() == typeof(DataMemberAttribute))).Select(p =>
{
var member = p.GetCustomAttribute<DataMemberAttribute>();
return new JsonProperty()
{
PropertyName = p.Name,
PropertyType = p.PropertyType,
Readable = true,
Writable = true,
ValueProvider = CreateMemberValueProvider(p),
DefaultValueHandling = DefaultValueHandling.Include
};
}).Concat(
type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).Where(x => x.GetCustomAttributes().Any(a => a.GetType() == typeof(DataMemberAttribute))).Select(p =>
{
var member = p.GetCustomAttribute<DataMemberAttribute>();
return new JsonProperty()
{
PropertyName = p.Name,
PropertyType = p.FieldType,
Readable = true,
Writable = true,
ValueProvider = CreateMemberValueProvider(p),
DefaultValueHandling = DefaultValueHandling.Include
};
})).ToList();
return list;
}
protected override IValueProvider CreateMemberValueProvider(MemberInfo member)
{
Type type = member.MemberType == MemberTypes.Property ? ((PropertyInfo)member).PropertyType : ((FieldInfo)member).FieldType;
if (typeof(IVariant).IsAssignableFrom(type))
{
return new IVariantValueProvider(member, type);
}
return base.CreateMemberValueProvider(member);
}
}
internal class IVariantValueProvider : IValueProvider
{
private MemberInfo member;
private Type type;
public IVariantValueProvider(MemberInfo member, Type type)
{
this.member = member;
this.type = type;
}
public object GetValue(object target)
{
IVariant variant;
switch (member)
{
case PropertyInfo p:
variant = (IVariant)p.GetValue(target);
break;
case FieldInfo f:
variant = (IVariant)f.GetValue(target);
break;
default:
throw new InvalidCastException();
}
var dataType = variant.TypeName;
var property = variant.Data.GetType().GetProperty(dataType);
var value = property.GetValue(variant.Data);
return value;
}
public void SetValue(object target, object value)
{
throw new NotImplementedException();
}
}
// Fixed - removed extra }
//}
class TestClass
{
public static void Test()
{
new JsonTester().Test();
}
}
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.CodeBase.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;
}
}