static FormatterCache()
{
Type t = typeof(T);
BssomFormatterAttribute attr = t.GetCustomAttribute <BssomFormatterAttribute>();
if (attr == null)
{
return;
}
Type formatterType = attr.FormatterType;
if (formatterType.IsGenericType && !formatterType.IsConstructedGenericType)
{
formatterType = formatterType.MakeGenericType(t.GetGenericArguments());
}
if (formatterType != t)
{
throw BssomSerializationTypeFormatterException.AttributeFormatterTypeMismatch(formatterType, t);
}
if (attr.Arguments == null)
{
Formatter = (IBssomFormatter <T>)Activator.CreateInstance(formatterType);
}
else
{
Formatter = (IBssomFormatter <T>)Activator.CreateInstance(formatterType, attr.Arguments);
}
}
public static void VerifyTypeIsPublic(Type type)
{
if (!(type.IsPublic || type.IsNestedPublic))
{
throw BssomSerializationTypeFormatterException.BuildNoPublicDynamicType(type);
}
}
private static Func <Decimal, DecimalBinaryBits> Build()
{
ParameterExpression de = Expression.Parameter(typeof(Decimal));
Expression low, mid, high, flags;
try
{
//FRAMEWORK
low = Expression.Field(de, typeof(Decimal).GetField("lo", BindingFlags.Instance | BindingFlags.NonPublic));
mid = Expression.Field(de, typeof(Decimal).GetField("mid", BindingFlags.Instance | BindingFlags.NonPublic));
high = Expression.Field(de, typeof(Decimal).GetField("hi", BindingFlags.Instance | BindingFlags.NonPublic));
flags = Expression.Field(de, typeof(Decimal).GetField("flags", BindingFlags.Instance | BindingFlags.NonPublic));
}
catch
{
try
{
low = Expression.Convert(Expression.Field(de, typeof(Decimal).GetField("Low", BindingFlags.Instance | BindingFlags.NonPublic)), typeof(int));
mid = Expression.Convert(Expression.Field(de, typeof(Decimal).GetField("Mid", BindingFlags.Instance | BindingFlags.NonPublic)), typeof(int));
high = Expression.Convert(Expression.Field(de, typeof(Decimal).GetField("High", BindingFlags.Instance | BindingFlags.NonPublic)), typeof(int));
flags = Expression.Field(de, typeof(Decimal).GetField("_flags", BindingFlags.Instance | BindingFlags.NonPublic));
}
catch (Exception ex)
{
throw BssomSerializationTypeFormatterException.TypeFormatterError(typeof(decimal), ex.Message);
}
}
NewExpression body = Expression.New(typeof(DecimalBinaryBits).GetConstructor(new Type[] { typeof(int), typeof(int), typeof(int), typeof(int) }), low, mid, high, flags);
return(Expression.Lambda <Func <Decimal, DecimalBinaryBits> >(body, de).Compile());
}
static FormatterCache()
{
Type t = typeof(T);
if (Array1ResolverGetFormatterHelper.TryGetFormatter(t, out IBssomFormatter formatter))
{
Formatter = (IBssomFormatter <T>)formatter;
return;
}
if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ArraySegment <>))
{
Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(ArraySegmentFormatter <>).MakeGenericType(t.GetGenericArguments()));
return;
}
if (TypeIsArray(t, out int rank, out Type elementType))
{
if (rank == 1)
{
Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(OneDimensionalArrayFormatter <>).MakeGenericType(elementType));
}
else if (rank == 2)
{
Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(TwoDimensionalArrayFormatter <>).MakeGenericType(elementType));
}
else if (rank == 3)
{
Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(ThreeDimensionalArrayFormatter <>).MakeGenericType(elementType));
}
else if (rank == 4)
{
Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(FourDimensionalArrayFormatter <>).MakeGenericType(elementType));
}
else
{
throw BssomSerializationTypeFormatterException.UnsupportedType(t);
}
return;
}
if (TypeIsCollection(t,
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList))
{
TypeInfo buildType;
if (t.IsInterface)
{
buildType = ICollectionFormatterTypeBuilder.BuildICollectionInterfaceType(DynamicAssembly, t, itemType);
}
else
{
buildType = ICollectionFormatterTypeBuilder.BuildICollectionImplementationType(DynamicAssembly, t, constructor, itemType, isImplGenerIList, IsImplIList, isImplGenerICollec, isImplIReadOnlyList);
}
Formatter = (IBssomFormatter <T>)Activator.CreateInstance(buildType);
}
}
public static IBssMapKeyResolver GetAndVertiyBssMapKeyResolver(Type keyType)
{
if (!TryGetBssMapKeyResolver(keyType, out IBssMapKeyResolver mapKeyConvertor))
{
return(BssomSerializationTypeFormatterException.BssomMapKeyUnsupportedType <IBssMapKeyResolver>(keyType));
}
return(mapKeyConvertor);
}
static IBssMapKeyStaticResolverCache()
{
if (BssMapKeyResolverProvider.TryGetBssMapKeyResolver(typeof(T), out IBssMapKeyResolver convertor))
{
Instance = (IBssMapKeyResolver <T>)convertor;
}
else
{
BssomSerializationTypeFormatterException.BssomMapKeyUnsupportedType(typeof(T));
}
}
public static void VertyBssMapKeyType(object key)
{
if (key == null)
{
ThrowArgumentNullException(key);
}
Type keyType = key.GetType();
if (!TryGetBssMapKeyResolver(keyType, out IBssMapKeyResolver mapKeyConvertor))
{
BssomSerializationTypeFormatterException.BssomMapKeyUnsupportedType <IBssMapKeyResolver>(keyType);
}
}
private static void SerializeMemberInfosOrderByKeyIndex(this ObjectSerializationInfo serializationInfo, Type type)
{
if (serializationInfo.SerializeMemberInfos.Length > 0)
{
serializationInfo.SerializeMemberInfos = serializationInfo.SerializeMemberInfos.OrderBy(e => e.KeyIndex).ToArray();
SerializeMemberInfo[] serializeMemberInfos = serializationInfo.SerializeMemberInfos;
for (int i = 0; i < serializeMemberInfos.Length; i++)
{
var mem = serializeMemberInfos[i];
if (!mem.KeyIndexHasValue)
{
throw BssomSerializationTypeFormatterException.Array3MembersMustDefindKeyAttribute(type, mem.Name);
}
if (i != 0 && mem.KeyIndex == serializeMemberInfos[i - 1].KeyIndex)
{
throw BssomSerializationTypeFormatterException.Array3KeyAttributeValueRepeated(type);
}
}
}
}
public static Type CreateType(Type interfaceType)
{
try
{
TypeBuilder typeBuilder = ImpAssembly.DefineInterfaceImpType(interfaceType);
List <MemberInfo> allMembers = interfaceType.GetAllInterfaceMembers();
List <MethodInfo> propertyInfos = new List <MethodInfo>();
foreach (PropertyInfo prop in allMembers.OfType <PropertyInfo>())
{
Type propType = prop.PropertyType;
PropertyBuilder propBuilder = typeBuilder.DefineProperty(prop.Name, prop.Attributes, propType, Type.EmptyTypes);
MethodInfo iGetter = prop.GetMethod;
MethodInfo iSetter = prop.SetMethod;
if (iGetter != null)
{
propertyInfos.Add(iGetter);
}
if (iSetter != null)
{
propertyInfos.Add(iSetter);
}
if (prop.Name == "Item")
{
if (iGetter != null)
{
MethodAttributes accessor = iGetter.Attributes;
accessor &= ~MethodAttributes.Abstract;
MethodBuilder methBuilder = typeBuilder.DefineMethod(iGetter.Name, accessor, iGetter.ReturnType, iGetter.GetParameters().Select(e => e.ParameterType).ToArray());
ILGenerator il = methBuilder.GetILGenerator();
il.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructors()[0]);
il.Emit(OpCodes.Throw);
propBuilder.SetGetMethod(methBuilder);
}
if (iSetter != null)
{
MethodAttributes accessor = iSetter.Attributes;
accessor &= ~MethodAttributes.Abstract;
MethodBuilder methBuilder = typeBuilder.DefineMethod(iSetter.Name, accessor, iSetter.ReturnType, iSetter.GetParameters().Select(e => e.ParameterType).ToArray());
ILGenerator il = methBuilder.GetILGenerator();
il.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructors()[0]);
il.Emit(OpCodes.Throw);
propBuilder.SetSetMethod(methBuilder);
}
continue;
}
Func <FieldInfo> getBackingField;
{
FieldInfo backingField = null;
getBackingField =
() =>
{
if (backingField == null)
{
backingField = typeBuilder.DefineField("_" + prop.Name + "_" + Guid.NewGuid(), propType, FieldAttributes.Private);
}
return(backingField);
};
}
if (iGetter != null)
{
MethodAttributes accessor = iGetter.Attributes;
accessor &= ~MethodAttributes.Abstract;
MethodBuilder methBuilder = typeBuilder.DefineMethod(iGetter.Name, accessor, propType, Type.EmptyTypes);
ILGenerator il = methBuilder.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, getBackingField());
il.Emit(OpCodes.Ret);
propBuilder.SetGetMethod(methBuilder);
}
if (iGetter != null || iSetter != null)
{
MethodAttributes accessor = iSetter != null ? iSetter.Attributes : MethodAttributes.Private;
string name = iSetter != null ? iSetter.Name : "set_" + prop.Name;
accessor &= ~MethodAttributes.Abstract;
MethodBuilder methBuilder = typeBuilder.DefineMethod(name, accessor, typeof(void), new[] { propType });
ILGenerator il = methBuilder.GetILGenerator();
if (iGetter != null)
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, getBackingField());
il.Emit(OpCodes.Ret);
}
else
{
il.Emit(OpCodes.Ret);
}
propBuilder.SetSetMethod(methBuilder);
}
}
foreach (MethodInfo method in allMembers.OfType <MethodInfo>().Except(propertyInfos))
{
MethodBuilder methBuilder = typeBuilder.DefineMethod(method.Name, MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, method.ReturnType, method.GetParameters().Select(e => e.ParameterType).ToArray());
if (method.IsGenericMethod)
{
methBuilder.DefineGenericParameters(method.GetGenericArguments().Select(e => e.Name).ToArray());
}
ILGenerator il = methBuilder.GetILGenerator();
il.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructors()[0]);
il.Emit(OpCodes.Throw);
typeBuilder.DefineMethodOverride(methBuilder, method);
}
return(typeBuilder.CreateTypeInfo());
}
catch
{
throw BssomSerializationTypeFormatterException.UnsupportedType(interfaceType);
}
}
