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); } }