private static MethodBuilder GetFieldSetMethod(Type instanceType, TypeBuilder typeBuilder,
PropertyInfo iProperty, FieldInfo field, FieldInfo instanceField)
{
var method = typeBuilder.DefineMethod("set_" + iProperty.Name,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.Final |
MethodAttributes.HideBySig | MethodAttributes.Virtual,
typeof(void),
new[] { iProperty.PropertyType });
var il = method.GetILGenerator();
var isPublicInstance = instanceType.IsPublic || instanceType.IsNestedPublic;
if ((field.Attributes & FieldAttributes.InitOnly) != 0)
{
il.Emit(OpCodes.Newobj, typeof(DuckTypeFieldIsReadonlyException).GetConstructor(Type.EmptyTypes) !);
il.Emit(OpCodes.Throw);
return(method);
}
// Load instance
if (!isPublicInstance || !field.IsPublic)
{
if (field.IsStatic)
{
il.Emit(OpCodes.Ldnull);
}
else
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, instanceField);
}
}
else if (!field.IsStatic)
{
ILHelpers.LoadInstance(il, instanceField, instanceType);
}
// Check if a duck type object
var iPropTypeInterface = iProperty.PropertyType;
if (iPropTypeInterface.IsGenericType)
{
iPropTypeInterface = iPropTypeInterface.GetGenericTypeDefinition();
}
if (iProperty.PropertyType != field.FieldType && !iProperty.PropertyType.IsValueType && !iProperty.PropertyType.IsAssignableFrom(field.FieldType))
{
if (field.IsStatic)
{
var innerField = DynamicFields.GetOrAdd(new VTuple <string, TypeBuilder>("_dtStatic" + iProperty.Name, typeBuilder), tuple =>
tuple.Item2.DefineField(tuple.Item1, typeof(DuckType), FieldAttributes.Private | FieldAttributes.Static));
il.Emit(OpCodes.Ldsflda, innerField);
}
else
{
var innerField = DynamicFields.GetOrAdd(new VTuple <string, TypeBuilder>("_dt" + iProperty.Name, typeBuilder), tuple =>
tuple.Item2.DefineField(tuple.Item1, typeof(DuckType), FieldAttributes.Private));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldflda, innerField);
}
// Load value
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Castclass, typeof(DuckType));
il.EmitCall(OpCodes.Call, SetInnerDuckTypeMethodInfo, null);
}
else
{
// Load value
il.Emit(OpCodes.Ldarg_1);
}
// Call method
if (isPublicInstance && field.IsPublic)
{
var fieldRootType = Util.GetRootType(field.FieldType);
var iPropRootType = Util.GetRootType(iProperty.PropertyType);
ILHelpers.TypeConversion(il, iPropRootType, fieldRootType);
il.Emit(field.IsStatic ? OpCodes.Stsfld : OpCodes.Stfld, field);
}
else
{
var dynValueType = typeof(object);
if (field.FieldType.IsPublic || field.FieldType.IsNestedPublic)
{
dynValueType = field.FieldType;
}
var iPropRootType = Util.GetRootType(iProperty.PropertyType);
ILHelpers.TypeConversion(il, iPropRootType, dynValueType);
var dynParameters = new[] { typeof(object), dynValueType };
var dynMethod = new DynamicMethod($"_setField+{field.DeclaringType!.Name}.{field.Name}", typeof(void), dynParameters, typeof(EmitAccessors).Module);
EmitAccessors.CreateSetAccessor(dynMethod.GetILGenerator(), field, dynParameters[0], dynParameters[1]);
var handle = GetRuntimeHandle(dynMethod);
il.Emit(OpCodes.Ldc_I8, (long)handle.GetFunctionPointer());
il.Emit(OpCodes.Conv_I);
il.EmitCalli(OpCodes.Calli, dynMethod.CallingConvention, typeof(void), dynParameters, null);
DynamicMethods.Add(dynMethod);
}
il.Emit(OpCodes.Ret);
return(method);
}
private static MethodBuilder GetPropertySetMethod(Type instanceType, TypeBuilder typeBuilder,
PropertyInfo iProperty, PropertyInfo prop, FieldInfo instanceField)
{
var parameterTypes = GetPropertyParameterTypes(iProperty, true);
var method = typeBuilder.DefineMethod("set_" + iProperty.Name,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.Final |
MethodAttributes.HideBySig | MethodAttributes.Virtual,
typeof(void),
parameterTypes);
var il = method.GetILGenerator();
if (!prop.CanWrite)
{
il.Emit(OpCodes.Newobj, typeof(DuckTypePropertyCantBeWrittenException).GetConstructor(Type.EmptyTypes) !);
il.Emit(OpCodes.Throw);
return(method);
}
var propMethod = prop.SetMethod;
var publicInstance = instanceType.IsPublic || instanceType.IsNestedPublic;
// Load instance
if (!propMethod.IsStatic)
{
ILHelpers.LoadInstance(il, instanceField, instanceType);
}
// Check if a duck type object
var iPropTypeInterface = iProperty.PropertyType;
if (iPropTypeInterface.IsGenericType)
{
iPropTypeInterface = iPropTypeInterface.GetGenericTypeDefinition();
}
if (iProperty.PropertyType != prop.PropertyType && parameterTypes.Length == 1 &&
!iProperty.PropertyType.IsValueType && !iProperty.PropertyType.IsAssignableFrom(prop.PropertyType))
{
if (propMethod.IsStatic)
{
var innerField = DynamicFields.GetOrAdd(new VTuple <string, TypeBuilder>("_dtStatic" + iProperty.Name, typeBuilder), tuple =>
tuple.Item2.DefineField(tuple.Item1, typeof(DuckType), FieldAttributes.Private | FieldAttributes.Static));
il.Emit(OpCodes.Ldsflda, innerField);
}
else
{
var innerField = DynamicFields.GetOrAdd(new VTuple <string, TypeBuilder>("_dt" + iProperty.Name, typeBuilder), tuple =>
tuple.Item2.DefineField(tuple.Item1, typeof(DuckType), FieldAttributes.Private));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldflda, innerField);
}
// Load value
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Castclass, typeof(DuckType));
il.EmitCall(OpCodes.Call, SetInnerDuckTypeMethodInfo, null);
}
else
{
if (!publicInstance && propMethod.IsStatic)
{
il.Emit(OpCodes.Ldnull);
}
// Load values
// If we have index parameters we need to pass it
var propTypes = GetPropertyParameterTypes(prop, true);
for (var i = 0; i < parameterTypes.Length; i++)
{
ILHelpers.WriteLoadArgument(i, il, propMethod.IsStatic);
var iPropRootType = Util.GetRootType(parameterTypes[i]);
var propRootType = propTypes[i].IsPublic || propTypes[i].IsNestedPublic ? Util.GetRootType(propTypes[i]) : typeof(object);
ILHelpers.TypeConversion(il, iPropRootType, propRootType);
}
}
if (publicInstance)
{
// Call method
if (propMethod.IsPublic)
{
il.EmitCall(propMethod.IsStatic ? OpCodes.Call : OpCodes.Callvirt, propMethod, null);
}
else
{
il.Emit(OpCodes.Ldc_I8, (long)propMethod.MethodHandle.GetFunctionPointer());
il.Emit(OpCodes.Conv_I);
il.EmitCalli(OpCodes.Calli, propMethod.CallingConvention,
propMethod.ReturnType,
propMethod.GetParameters().Select(p => p.ParameterType).ToArray(),
null);
}
}
else
{
var dynValueType = typeof(object);
if (prop.PropertyType.IsPublic || prop.PropertyType.IsNestedPublic)
{
dynValueType = prop.PropertyType;
}
var dynParameters = new[] { typeof(object), dynValueType };
var dynMethod = new DynamicMethod("setDyn_" + prop.Name, typeof(void), dynParameters, typeof(EmitAccessors).Module);
EmitAccessors.CreateSetAccessor(dynMethod.GetILGenerator(), prop, dynParameters[0], dynParameters[1]);
var handle = GetRuntimeHandle(dynMethod);
il.Emit(OpCodes.Ldc_I8, (long)handle.GetFunctionPointer());
il.Emit(OpCodes.Conv_I);
il.EmitCalli(OpCodes.Calli, dynMethod.CallingConvention, dynMethod.ReturnType, dynParameters, null);
DynamicMethods.Add(dynMethod);
}
il.Emit(OpCodes.Ret);
return(method);
}
