1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
#if !UNITY_WSA
#if !NET_STANDARD_2_0
using System;
using MessagePack.Formatters;
using MessagePack.Internal;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;
namespace MessagePack.Resolvers
{
/// <summary>
/// EnumResolver by dynamic code generation, serialized underlying type.
/// </summary>
public sealed class DynamicEnumResolver : IFormatterResolver
{
public static readonly DynamicEnumResolver Instance = new DynamicEnumResolver();
const string ModuleName = "MessagePack.Resolvers.DynamicEnumResolver";
static readonly DynamicAssembly assembly;
static int nameSequence = 0;
DynamicEnumResolver()
{
}
static DynamicEnumResolver()
{
assembly = new DynamicAssembly(ModuleName);
}
#if NETFRAMEWORK
public AssemblyBuilder Save()
{
return assembly.Save();
}
#endif
public IMessagePackFormatter<T> GetFormatter<T>()
{
return FormatterCache<T>.formatter;
}
static class FormatterCache<T>
{
public static readonly IMessagePackFormatter<T> formatter;
static FormatterCache()
{
var ti = typeof(T).GetTypeInfo();
if (ti.IsNullable())
{
// build underlying type and use wrapped formatter.
ti = ti.GenericTypeArguments[0].GetTypeInfo();
if (!ti.IsEnum)
{
return;
}
var innerFormatter = DynamicEnumResolver.Instance.GetFormatterDynamic(ti.AsType());
if (innerFormatter == null)
{
return;
}
formatter = (IMessagePackFormatter<T>)Activator.CreateInstance(typeof(StaticNullableFormatter<>).MakeGenericType(ti.AsType()), new object[] { innerFormatter });
return;
}
else if (!ti.IsEnum)
{
return;
}
var formatterTypeInfo = BuildType(typeof(T));
formatter = (IMessagePackFormatter<T>)Activator.CreateInstance(formatterTypeInfo.AsType());
}
}
static TypeInfo BuildType(Type enumType)
{
var underlyingType = Enum.GetUnderlyingType(enumType);
var formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(enumType);
var typeBuilder = assembly.DefineType("MessagePack.Formatters." + enumType.FullName.Replace(".", "_") + "Formatter" + Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType });
// int Serialize(ref byte[] bytes, int offset, T value, IFormatterResolver formatterResolver);
{
var method = typeBuilder.DefineMethod("Serialize", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual,
typeof(int),
new Type[] { typeof(byte[]).MakeByRefType(), typeof(int), enumType, typeof(IFormatterResolver) });
var il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldarg_3);
il.Emit(OpCodes.Call, typeof(MessagePackBinary).GetRuntimeMethod("Write" + underlyingType.Name, new[] { typeof(byte[]).MakeByRefType(), typeof(int), underlyingType }));
il.Emit(OpCodes.Ret);
}
// T Deserialize(ref ReadOnlySequence<byte> byteSequence, IFormatterResolver formatterResolver);
{
var method = typeBuilder.DefineMethod("Deserialize", MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual,
enumType,
new Type[] { typeof(byte[]), typeof(int), typeof(IFormatterResolver), typeof(int).MakeByRefType() });
var il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldarg_S, (byte)4);
il.Emit(OpCodes.Call, typeof(MessagePackBinary).GetRuntimeMethod("Read" + underlyingType.Name, new[] { typeof(byte[]), typeof(int), typeof(int).MakeByRefType() }));
il.Emit(OpCodes.Ret);
}
return typeBuilder.CreateTypeInfo();
}
}
}
#endif
#endif
|
