// private ParameterInfo[] indexParameters;
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, String name, PropertyAttributes attributes,
Type propertyType)
{
this.parentTypeEmitter = parentTypeEmitter;
builder = parentTypeEmitter.TypeBuilder.DefineProperty(name, attributes, propertyType, new Type[0]);
}
public PropertyEmitter(TypeBuilder owner, string name, Type propertyType, FieldBuilder propertyChangedField) {
this.owner = owner;
this.propertyChangedField = propertyChangedField;
fieldBuilder = owner.DefineField(String.Format("<{0}>", name), propertyType, FieldAttributes.Private);
getterBuilder = owner.DefineMethod(String.Format("get_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, propertyType, Type.EmptyTypes);
ILGenerator getterIl = getterBuilder.GetILGenerator();
getterIl.Emit(OpCodes.Ldarg_0);
getterIl.Emit(OpCodes.Ldfld, fieldBuilder);
getterIl.Emit(OpCodes.Ret);
setterBuilder = owner.DefineMethod(String.Format("set_{0}", name), MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.HideBySig|MethodAttributes.SpecialName, typeof(void), new[] {propertyType});
ILGenerator setterIl = setterBuilder.GetILGenerator();
setterIl.Emit(OpCodes.Ldarg_0);
setterIl.Emit(OpCodes.Ldarg_1);
setterIl.Emit(OpCodes.Stfld, fieldBuilder);
if (propertyChangedField != null) {
setterIl.Emit(OpCodes.Ldarg_0);
setterIl.Emit(OpCodes.Dup);
setterIl.Emit(OpCodes.Ldfld, propertyChangedField);
setterIl.Emit(OpCodes.Ldstr, name);
setterIl.Emit(OpCodes.Call, proxyBase_NotifyPropertyChanged);
}
setterIl.Emit(OpCodes.Ret);
propertyBuilder = owner.DefineProperty(name, PropertyAttributes.None, propertyType, null);
propertyBuilder.SetGetMethod(getterBuilder);
propertyBuilder.SetSetMethod(setterBuilder);
}
// private ParameterInfo[] indexParameters;
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes,
Type propertyType, Type[] arguments)
{
this.parentTypeEmitter = parentTypeEmitter;
// DYNPROXY-73 - AmbiguousMatchException for properties
// This is a workaround for a framework limitation in CLR 2.0
// This limitation was removed in CLR 2.0 SP1, but we don't want to
// tie ourselves to that version. This perform the lookup for the new overload
// dynamically, so we have a nice fallback on vanilla CLR 2.0
if (TypeBuilderMethods.DefineProperty == null || true) // TODO
{
DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty;
builder = oldDefineProperty(name, attributes, propertyType, arguments);
}
else
{
var newDefinedProperty = (DefineProperty_Clr_2_0_SP1)
Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1),
parentTypeEmitter.TypeBuilder,
TypeBuilderMethods.DefineProperty);
builder = newDefinedProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, arguments, null, null);
}
}
static MethodBuilder CreateNewInstanceGetter(TypeBuilder typeBuilder, PropertyBuilder property,
ConstructorInfo constructor, MethodAttributes accessRights)
{
var getterMethod = CodeGenerationUtils.GetterMethodFor(typeBuilder, property, accessRights);
CodeGenerationUtils.ReturnNewInstanceILInstructions(constructor, getterMethod);
return getterMethod;
}
internal static MethodBuilder GetterMethodFor(TypeBuilder typeBuilder,
PropertyBuilder property, MethodAttributes access)
{
var getterMethod = typeBuilder.DefineMethod("get_" + property.Name,
access, property.PropertyType, null);
property.SetGetMethod(getterMethod);
return getterMethod;
}
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes,
Type propertyType, Type[] arguments)
{
this.parentTypeEmitter = parentTypeEmitter;
builder = parentTypeEmitter.TypeBuilder.DefineProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, arguments, null, null);
}
void LockSignature()
{
if (pb == null)
{
indexParameters.Lock();
pb = owner.TypeBuilder.DefineProperty(interfaceType == null ? name : interfaceType.FullName + "." + name, PropertyAttributes.None, type, indexParameters.TypeArray);
owner.RegisterForCompletion(this);
}
}
private void BuildSetter(TypeBuilder typeBuilder, PropertyInfo contractProperty, PropertyBuilder builder)
{
var setMethod = contractProperty.GetSetMethod();
if (null != setMethod)
{
var setMethodBuilder = new ProxyMethodImplementationStrategy().BuildMethodProxy(typeBuilder, setMethod);
builder.SetSetMethod(setMethodBuilder);
}
}
private void AddGetter(System.Reflection.Emit.TypeBuilder typeBuilder, FieldBuilder fieldBuilder, PropertyBuilder propertyBuilder)
{
MethodBuilder propertyGetter = typeBuilder.DefineMethod("get_" + _propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
_propertyType, Type.EmptyTypes);
var ilGenerator = propertyGetter.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
ilGenerator.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(propertyGetter);
}
/// <summary>
/// Creates the get method.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="prop">The prop.</param>
/// <param name="fieldBuilder">The field builder.</param>
/// <param name="propBuilder">The prop builder.</param>
private static void CreateGetMethod(TypeBuilder typeBuilder, PropertyInfo prop, FieldInfo fieldBuilder, PropertyBuilder propBuilder)
{
var getMethodBuilder = typeBuilder.DefineMethod(
"get_" + prop.Name,
GetSetAttributes,
prop.PropertyType,
Type.EmptyTypes);
var getIl = getMethodBuilder.GetILGenerator();
getIl.Emit(OpCodes.Ldarg_0);
getIl.Emit(OpCodes.Ldfld, fieldBuilder);
getIl.Emit(OpCodes.Ret);
propBuilder.SetGetMethod(getMethodBuilder);
}
private void AddSetter(System.Reflection.Emit.TypeBuilder typeBuilder, FieldBuilder fieldBuilder, PropertyBuilder propertyBuilder)
{
MethodBuilder propertySetter = typeBuilder.DefineMethod("set_" + _propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
null, new Type[] { _propertyType });
var propertySetterIl = propertySetter.GetILGenerator();
propertySetterIl.Emit(OpCodes.Ldarg_0);
propertySetterIl.Emit(OpCodes.Ldarg_1);
propertySetterIl.Emit(OpCodes.Stfld, fieldBuilder);
propertySetterIl.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(propertySetter);
}
protected virtual void OnGeneratePropertyMethods(
PropertyInfo targetProp,
PropertyDefinition proxyProp,
TypeReference proxyBaseType,
TypeReference proxyTargetType,
TypeReference rootProxyTargetType)
{
if (this.onGeneratePropertyMethodsFunc == null)
{
throw new InvalidOperationException(
"Either onGenerateMethodsFunc must be provided in argument, or OnGenerateMethods must be overrided");
}
this.onGeneratePropertyMethodsFunc(targetProp, proxyProp, proxyBaseType, proxyTargetType);
}
private void AddGetter(System.Reflection.Emit.TypeBuilder typeBuilder, PropertyBuilder propertyBuilder)
{
MethodBuilder propertyGetter = typeBuilder.DefineMethod("get_" + _propertyInfo.Name,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
_propertyInfo.PropertyType, Type.EmptyTypes);
var ilGenerator = propertyGetter.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldfld, _aggregate);
MethodInfo getter = _propertyInfo.GetAccessors().First(accessor => accessor.ReturnType != typeof (void));
ilGenerator.Emit(OpCodes.Callvirt, getter);
ilGenerator.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(propertyGetter);
}
private void AddSetter(System.Reflection.Emit.TypeBuilder typeBuilder, PropertyBuilder propertyBuilder)
{
MethodBuilder propertySetter = typeBuilder.DefineMethod("set_" + _propertyInfo.Name,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
null, new Type[] { _propertyInfo.PropertyType });
var propertySetterIl = propertySetter.GetILGenerator();
propertySetterIl.Emit(OpCodes.Ldarg_0);
propertySetterIl.Emit(OpCodes.Ldfld, _aggregate);
propertySetterIl.Emit(OpCodes.Ldarg_1);
MethodInfo setter = _propertyInfo.GetAccessors().First(accessor => accessor.ReturnType == typeof(void));
propertySetterIl.Emit(OpCodes.Callvirt, setter);
propertySetterIl.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(propertySetter);
}
/// <summary>
/// Creates the set method.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="prop">The prop.</param>
/// <param name="fieldBuilder">The field builder.</param>
/// <param name="propBuilder">The prop builder.</param>
private static void CreateSetMethod(TypeBuilder typeBuilder, PropertyInfo prop, FieldInfo fieldBuilder, PropertyBuilder propBuilder)
{
var setMethodBuilder = typeBuilder.DefineMethod(
"set_" + prop.Name,
GetSetAttributes,
null,
new[] { prop.PropertyType });
var setIl = setMethodBuilder.GetILGenerator();
setIl.Emit(OpCodes.Ldarg_0);
setIl.Emit(OpCodes.Ldarg_1);
setIl.Emit(OpCodes.Stfld, fieldBuilder);
setIl.Emit(OpCodes.Ret);
propBuilder.SetSetMethod(setMethodBuilder);
}
/// <summary>
/// Creates the getter.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="propertyBuilder">The property builder.</param>
/// <param name="column">The column.</param>
private static void CreateGetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, SLDataColumn column)
{
var getMethodBuilder = typeBuilder.DefineMethod(
"get_" + column.ColumnName,
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName,
CallingConventions.HasThis,
column.DataType, Type.EmptyTypes);
var getMethodIL = getMethodBuilder.GetILGenerator();
getMethodIL.Emit(OpCodes.Ldarg_0);
getMethodIL.Emit(OpCodes.Ldstr, column.ColumnName);
getMethodIL.Emit(OpCodes.Callvirt, GetValueMethod.MakeGenericMethod(column.DataType));
getMethodIL.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getMethodBuilder);
}
private static void CreateGetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, IPropertyInfo propertyInfo)
{
MethodBuilder getMethodBuilder = typeBuilder.DefineMethod(
"get_" + propertyInfo.PropertyName,
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName,
CallingConventions.HasThis,
propertyInfo.PropertyType, Type.EmptyTypes);
ILGenerator getMethodIL = getMethodBuilder.GetILGenerator();
getMethodIL.Emit(OpCodes.Ldarg_0);
getMethodIL.Emit(OpCodes.Ldstr, propertyInfo.PropertyName);
getMethodIL.Emit(OpCodes.Callvirt, GetValueMethod.MakeGenericMethod(propertyInfo.PropertyType));
getMethodIL.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getMethodBuilder);
}
private static void CreateSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, DataColumn column)
{
var setMethodBuilder = typeBuilder.DefineMethod(
"set_" + column.ColumnName,
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName,
CallingConventions.HasThis,
null, new[] { column.DataType });
var setMethodIL = setMethodBuilder.GetILGenerator();
setMethodIL.Emit(OpCodes.Ldarg_0);
setMethodIL.Emit(OpCodes.Ldstr, column.ColumnName);
setMethodIL.Emit(OpCodes.Ldarg_1);
setMethodIL.Emit(OpCodes.Callvirt, SetValueMethod.MakeGenericMethod(column.DataType));
setMethodIL.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setMethodBuilder);
}
private static void CreateSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, IPropertyInfo propertyInfo)
{
MethodBuilder setMethodBuilder = typeBuilder.DefineMethod(
"set_" + propertyInfo.PropertyName,
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName,
CallingConventions.HasThis,
null, new[] { propertyInfo.PropertyType });
ILGenerator setMethodIL = setMethodBuilder.GetILGenerator();
setMethodIL.Emit(OpCodes.Ldarg_0);
setMethodIL.Emit(OpCodes.Ldstr, propertyInfo.PropertyName);
setMethodIL.Emit(OpCodes.Ldarg_1);
setMethodIL.Emit(OpCodes.Callvirt, SetValueMethod.MakeGenericMethod(propertyInfo.PropertyType));
setMethodIL.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setMethodBuilder);
}
public static Type BuildPropertyObject(System.Collections.Generic.IEnumerable <System.Collections.Generic.KeyValuePair <string, Type> > obj)
{
string nameOfDLL = "magic.dll";
string nameOfAssembly = "magic_Assembly";
string nameOfModule = "magic_Module";
string nameOfType = "magic_Type";
System.Reflection.AssemblyName assemblyName = new System.Reflection.AssemblyName {
Name = nameOfAssembly
};
System.Reflection.Emit.AssemblyBuilder assemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(assemblyName, System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave);
System.Reflection.Emit.ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(nameOfModule, nameOfDLL);
System.Reflection.Emit.TypeBuilder typeBuilder = moduleBuilder.DefineType(nameOfType, System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Class);
foreach (var prop in obj)
{
string Name = prop.Key;
Type DataType = prop.Value;
System.Reflection.Emit.FieldBuilder field = typeBuilder.DefineField("_" + Name, DataType, System.Reflection.FieldAttributes.Private);
System.Reflection.Emit.PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(Name, System.Reflection.PropertyAttributes.SpecialName, DataType, null);
System.Reflection.MethodAttributes methodAttributes = System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.SpecialName;
System.Reflection.Emit.MethodBuilder methodBuilderGetter = typeBuilder.DefineMethod("get_" + Name, methodAttributes, DataType, new Type[] { });
System.Reflection.Emit.MethodBuilder methodBuilderSetter = typeBuilder.DefineMethod("set_" + Name, methodAttributes, typeof(void), new Type[] { DataType });
System.Reflection.Emit.ILGenerator ilGeneratorGetter = methodBuilderGetter.GetILGenerator();
ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ldfld, field);
ilGeneratorGetter.Emit(System.Reflection.Emit.OpCodes.Ret);
System.Reflection.Emit.ILGenerator ilGeneratorSetter = methodBuilderSetter.GetILGenerator();
ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Stfld, field);
ilGeneratorSetter.Emit(System.Reflection.Emit.OpCodes.Ret);
propertyBuilder.SetGetMethod(methodBuilderGetter);
propertyBuilder.SetSetMethod(methodBuilderSetter);
}
// Yes! you must do this, it should not be needed but it is!
Type dynamicType = typeBuilder.CreateType();
// Save to file
assemblyBuilder.Save(nameOfDLL);
return(dynamicType);
}
public static Type BuildDynamicTypeWithProperties(string classname, Dictionary <string, Type> properties)
{
AppDomain myDomain = Thread.GetDomain();
AssemblyName myAsmName = Assembly.GetExecutingAssembly().GetName();
AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndCollect);
ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(myAsmName.Name);
MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
TypeBuilder typebuilder = myModBuilder.DefineType(classname, TypeAttributes.Public);
foreach (var propertie in properties)
{
FieldBuilder fieldbuilder = typebuilder.DefineField(propertie.Key.ToLower(), propertie.Value, FieldAttributes.Private);
System.Reflection.Emit.PropertyBuilder getsetbuilder = typebuilder.DefineProperty(propertie.Key, PropertyAttributes.HasDefault, propertie.Value, null);
//Define the "get" accessor method
MethodBuilder getmethodbuilder = typebuilder.DefineMethod(string.Format("get_{0}", propertie.Key), getSetAttr, propertie.Value, Type.EmptyTypes);
ILGenerator getil = getmethodbuilder.GetILGenerator();
getil.Emit(OpCodes.Ldarg_0);
getil.Emit(OpCodes.Ldfld, fieldbuilder);
getil.Emit(OpCodes.Ret);
//Define the "set" accessor method
MethodBuilder setmethodbuilder = typebuilder.DefineMethod(string.Format("set_{0}", propertie.Key), getSetAttr, null, new Type[] { propertie.Value });
ILGenerator setil = setmethodbuilder.GetILGenerator();
setil.Emit(OpCodes.Ldarg_0);
setil.Emit(OpCodes.Ldarg_1);
setil.Emit(OpCodes.Stfld, fieldbuilder);
setil.Emit(OpCodes.Ret);
//Add get/set
getsetbuilder.SetGetMethod(getmethodbuilder);
getsetbuilder.SetSetMethod(setmethodbuilder);
}
return(typebuilder.CreateType());
}
// private ParameterInfo[] indexParameters;
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes,
Type propertyType, Type[] arguments)
{
this.parentTypeEmitter = parentTypeEmitter;
// DYNPROXY-73 - AmbiguousMatchException for properties
// This is a workaround for a framework limitation in CLR 2.0
// This limitation was removed in CLR 2.0 SP1, but we don't want to
// tie ourselves to that version. This perform the lookup for the new overload
// dynamically, so we have a nice fallback on vanilla CLR 2.0
// @mbrit - 2012-05-30 - it appears in WinRT, the old version works OK... new version is baffling...
#if !NETFX_CORE
bool isWinRt = false;
#else
bool isWinRt = true;
#endif
if (TypeBuilderMethods.DefineProperty == null || isWinRt)
{
DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty;
builder = oldDefineProperty(name, attributes, propertyType, arguments);
}
else
{
#if !NETFX_CORE
var newDefinedProperty = (DefineProperty_Clr_2_0_SP1)
Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1),
parentTypeEmitter.TypeBuilder,
TypeBuilderMethods.DefineProperty);
builder = newDefinedProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, arguments, null, null);
#endif
}
}
/// <summary>
/// Given a custom attribute and property builder, adds an instance of custom attribute
/// to the property builder
/// </summary>
void AddCustomAttributeToProperty(object customAttribute, PropertyBuilder propBuilder)
{
var customAttributeBuilder = BuildCustomAttribute(customAttribute);
if (customAttributeBuilder != null)
{
propBuilder.SetCustomAttribute(customAttributeBuilder);
}
}
protected override void OnGeneratePropertyMethods(PropertyInfo targetProp,
PropertyDefinition proxyProp,
TypeReference proxyBaseType,
TypeReference proxyTargetType,
TypeReference rootProxyTargetType)
{
var propWrapperTypeRef = this.propertyWrapperType.MakeGenericType(proxyTargetType, proxyProp.PropertyType);
var proxyType = (TypeDefinition)proxyProp.DeclaringType;
if (proxyType == null)
{
throw new InvalidOperationException($"{proxyProp} has no declaring type.");
}
var propWrapperCtor = propWrapperTypeRef.GetConstructor(typeof(string));
var propertyWrapperField = proxyType.DefineField("_pwrap_" + targetProp.Name,
propWrapperTypeRef,
FieldAttributes.Private | FieldAttributes.Static);
this.initPropertyWrapperIlAction.Add(il =>
{
il.Emit(OpCodes.Ldstr, targetProp.Name);
il.Emit(OpCodes.Newobj, propWrapperCtor);
il.Emit(OpCodes.Stsfld, propertyWrapperField);
});
/*
* var initPropertyWrappersMethod = GetInitPropertyWrappersMethod(proxyProp);
*
* var initIl = initPropertyWrappersMethod.Body.GetILProcessor();
* var lastInstruction = initPropertyWrappersMethod.Body.Instructions.Last();
* if (lastInstruction.OpCode != OpCodes.Ret)
* throw new InvalidOperationException("Expected to find ret instruction as last instruction");
*
* initIl.InsertBefore(lastInstruction, Instruction.Create(OpCodes.Ldstr, targetProp.Name));
* initIl.InsertBefore(lastInstruction, Instruction.Create(OpCodes.Newobj, propWrapperCtor));
* initIl.InsertBefore(lastInstruction, Instruction.Create(OpCodes.Stsfld, propertyWrapperField));
*/
var baseDef = proxyBaseType;
var proxyOnGetMethod = baseDef.GetGenericInstanceMethod("OnGet", proxyTargetType, proxyProp.PropertyType);
var proxyOnGetMethodInstance = proxyOnGetMethod.MakeGenericMethod(proxyTargetType, proxyProp.PropertyType);
var proxyOnSetMethod = baseDef.GetGenericInstanceMethod("OnSet", proxyTargetType, proxyProp.PropertyType);
var proxyOnSetMethodInstance = proxyOnSetMethod.MakeGenericMethod(proxyTargetType, proxyProp.PropertyType);
var getMethod = (MethodDefinition)proxyProp.GetGetMethod(true);
if (getMethod != null)
{
var getIl = getMethod.GetILGenerator();
getIl.Emit(OpCodes.Ldarg_0);
getIl.Emit(OpCodes.Ldsfld, propertyWrapperField);
getIl.Emit(OpCodes.Callvirt, proxyOnGetMethodInstance);
getIl.Emit(OpCodes.Ret);
}
var setMethod = (MethodDefinition)proxyProp.GetSetMethod(true);
if (setMethod != null)
{
var setIl = setMethod.GetILGenerator();
setIl.Emit(OpCodes.Ldarg_0);
setIl.Emit(OpCodes.Ldsfld, propertyWrapperField);
setIl.Emit(OpCodes.Ldarg_1);
setIl.Emit(OpCodes.Callvirt, proxyOnSetMethodInstance);
setIl.Emit(OpCodes.Ret);
}
}
private static void SetAttributes(PropertyBuilder propertyBuilder, MemberInfo memberInfo)
{
var customAttributeBuilders = PropertyAttributeBuilders
.GetOrAdd(
memberInfo,
p =>
{
var customAttributes = p.GetCustomAttributesData();
return CreateCustomAttributeBuilders(customAttributes).ToArray();
});
Contract.Assume(customAttributeBuilders != null);
foreach (var attribute in customAttributeBuilders)
{
propertyBuilder.SetCustomAttribute(attribute);
}
}
private static void DefineSetMethod(TypeBuilder newType, PropertyBuilder propertyBuilder, FieldInfo fieldBuilder, PropertyInfo property)
{
var setMethod = property.GetSetMethod();
if (setMethod == null) return;
var methodBuilder = newType.DefineMethod(setMethod.Name,
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual,
null,
new[] {property.PropertyType});
var ilg = methodBuilder.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldarg_1);
ilg.Emit(OpCodes.Stfld, fieldBuilder);
ilg.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(methodBuilder);
var methodInfo = methodBuilder.GetBaseDefinition();
newType.DefineMethodOverride(methodInfo, setMethod);
}
public PropertyLambda(ITypeLambda typeLambda, PropertyBuilder propertyBuilder)
{
this.TypeLambda = typeLambda;
this.propertyBuilder = propertyBuilder;
}
public bool EmitMember(
TypeBuilder typeBuilder, EdmMember member, PropertyBuilder propertyBuilder, PropertyInfo baseProperty,
BaseProxyImplementor baseImplementor)
{
if (_members.Contains(member))
{
var baseGetter = baseProperty.GetGetMethod(true);
const MethodAttributes getterAttributes =
MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual;
var getterAccess = baseGetter.Attributes & MethodAttributes.MemberAccessMask;
// Define field to store interceptor Func
// Signature of interceptor Func delegate is as follows:
//
// bool intercept(ProxyType proxy, PropertyType propertyValue)
//
// where
// PropertyType is the type of the Property, such as ICollection<Customer>,
// ProxyType is the type of the proxy object,
// propertyValue is the value returned from the proxied type's property getter.
var interceptorType = typeof(Func<,,>).MakeGenericType(typeBuilder, baseProperty.PropertyType, typeof(bool));
var interceptorInvoke = TypeBuilder.GetMethod(interceptorType, typeof(Func<,,>).GetMethod("Invoke"));
var interceptorField = typeBuilder.DefineField(
GetInterceptorFieldName(baseProperty.Name), interceptorType, FieldAttributes.Private | FieldAttributes.Static);
// Define a property getter override in the proxy type
var getterBuilder = typeBuilder.DefineMethod(
"get_" + baseProperty.Name, getterAccess | getterAttributes, baseProperty.PropertyType, Type.EmptyTypes);
var generator = getterBuilder.GetILGenerator();
// Emit instructions for the following call:
// T value = base.SomeProperty;
// if(this._interceptorForSomeProperty(this, value))
// { return value; }
// return base.SomeProperty;
// where _interceptorForSomeProperty represents the interceptor Func field.
var lableTrue = generator.DefineLabel();
generator.DeclareLocal(baseProperty.PropertyType); // T value
generator.Emit(OpCodes.Ldarg_0); // call base.SomeProperty
generator.Emit(OpCodes.Call, baseGetter); // call to base property getter
generator.Emit(OpCodes.Stloc_0); // value = result
generator.Emit(OpCodes.Ldarg_0); // load this
generator.Emit(OpCodes.Ldfld, interceptorField); // load this._interceptor
generator.Emit(OpCodes.Ldarg_0); // load this
generator.Emit(OpCodes.Ldloc_0); // load value
generator.Emit(OpCodes.Callvirt, interceptorInvoke); // call to interceptor delegate with (this, value)
generator.Emit(OpCodes.Brtrue_S, lableTrue); // if true, just return
generator.Emit(OpCodes.Ldarg_0); // else, call the base propertty getter again
generator.Emit(OpCodes.Call, baseGetter); // call to base property getter
generator.Emit(OpCodes.Ret);
generator.MarkLabel(lableTrue);
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getterBuilder);
baseImplementor.AddBasePropertyGetter(baseProperty);
return true;
}
return false;
}
private static void DefineGetMethod(TypeBuilder newType, PropertyBuilder propertyBuilder, FieldInfo fieldBuilder, PropertyInfo property)
{
var getMethod = property.GetGetMethod();
var methodBuilder = newType.DefineMethod(getMethod.Name,
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual,
property.PropertyType,
Type.EmptyTypes);
var ilg = methodBuilder.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldfld, fieldBuilder);
ilg.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(methodBuilder);
var methodInfo = methodBuilder.GetBaseDefinition();
newType.DefineMethodOverride(methodInfo, getMethod);
}
protected void DefineBuilders (MemberKind kind, ParametersCompiled parameters)
{
PropertyBuilder = Parent.TypeBuilder.DefineProperty (
GetFullName (MemberName), PropertyAttributes.None,
#if !BOOTSTRAP_BASIC // Requires trunk version mscorlib
IsStatic ? 0 : CallingConventions.HasThis,
#endif
MemberType.GetMetaInfo (), null, null,
parameters.GetMetaInfo (), null, null);
PropertySpec spec;
if (kind == MemberKind.Indexer)
spec = new IndexerSpec (Parent.Definition, this, MemberType, parameters, PropertyBuilder, ModFlags);
else
spec = new PropertySpec (kind, Parent.Definition, this, MemberType, PropertyBuilder, ModFlags);
if (Get != null) {
spec.Get = Get.Spec;
var method = Get.Spec.GetMetaInfo () as MethodBuilder;
if (method != null) {
PropertyBuilder.SetGetMethod (method);
Parent.MemberCache.AddMember (this, method.Name, Get.Spec);
}
} else {
CheckMissingAccessor (kind, parameters, true);
}
if (Set != null) {
spec.Set = Set.Spec;
var method = Set.Spec.GetMetaInfo () as MethodBuilder;
if (method != null) {
PropertyBuilder.SetSetMethod (method);
Parent.MemberCache.AddMember (this, method.Name, Set.Spec);
}
} else {
CheckMissingAccessor (kind, parameters, false);
}
Parent.MemberCache.AddMember (this, PropertyBuilder.Name, spec);
}
public PropertyBuilder DefineProperty (string name, PropertyAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)
{
check_name ("name", name);
if (parameterTypes != null)
foreach (Type param in parameterTypes)
if (param == null)
throw new ArgumentNullException ("parameterTypes");
check_not_created ();
PropertyBuilder res = new PropertyBuilder (this, name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
if (properties != null) {
Array.Resize (ref properties, properties.Length + 1);
properties [properties.Length - 1] = res;
} else {
properties = new PropertyBuilder [1] { res };
}
return res;
}
public void EmitAttribute (PropertyBuilder builder)
{
if (ResolveBuilder ())
builder.SetCustomAttribute (cab);
}
private static void EmitBaseSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty)
{
if (CanProxySetter(baseProperty))
{
var baseSetter = baseProperty.GetSetMethod(true);
const MethodAttributes methodAttributes =
MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual;
var methodAccess = baseSetter.Attributes & MethodAttributes.MemberAccessMask;
var setterBuilder = typeBuilder.DefineMethod(
"set_" + baseProperty.Name, methodAccess | methodAttributes, null, new[] { baseProperty.PropertyType });
var generator = setterBuilder.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Call, baseSetter);
generator.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setterBuilder);
}
}
private static void EmitBaseGetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty)
{
if (CanProxyGetter(baseProperty))
{
var baseGetter = baseProperty.GetGetMethod(true);
const MethodAttributes getterAttributes =
MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual;
var getterAccess = baseGetter.Attributes & MethodAttributes.MemberAccessMask;
// Define a property getter override in the proxy type
var getterBuilder = typeBuilder.DefineMethod(
"get_" + baseProperty.Name, getterAccess | getterAttributes, baseProperty.PropertyType, Type.EmptyTypes);
var gen = getterBuilder.GetILGenerator();
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Call, baseGetter);
gen.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getterBuilder);
}
}
