| public DefineProperty ( string name, System attributes, System returnType, System parameterTypes ) : System.Reflection.Emit.PropertyBuilder | ||
| name | string | |
| attributes | System | |
| returnType | System | |
| parameterTypes | System | |
| Результат | System.Reflection.Emit.PropertyBuilder | |
private static FieldBuilder CréeAttributs(TypeBuilder constructeurDeType, DataColumn colonne)
{
FieldBuilder champBldr = null;
PropertyBuilder constructeurPropriété;
#region Création de l'attribut
champBldr = constructeurDeType.DefineField(colonne.ColumnName.ToLower(), colonne.DataType, FieldAttributes.Private);
#endregion
#region Création de la Propriété associée
constructeurPropriété = constructeurDeType.DefineProperty(colonne.ColumnName, System.Reflection.PropertyAttributes.HasDefault, colonne.DataType, null);
// Choix des attributs
MethodAttributes attrGetSet = MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.HideBySig;
#region Définition du "getter".
MethodBuilder constructeurGet = constructeurDeType.DefineMethod("get_" + colonne.ColumnName, attrGetSet, colonne.DataType, Type.EmptyTypes);
ILGenerator champGetIL = constructeurGet.GetILGenerator();
champGetIL.Emit(OpCodes.Ldarg_0);
champGetIL.Emit(OpCodes.Ldfld, champBldr);
champGetIL.Emit(OpCodes.Ret);
#endregion
#region Définition du "setter".
MethodBuilder constructeurSet = constructeurDeType.DefineMethod("set_" + colonne.ColumnName, attrGetSet, null, new Type[] { colonne.DataType });
ILGenerator champSetIL = constructeurSet.GetILGenerator();
champSetIL.Emit(OpCodes.Ldarg_0);
champSetIL.Emit(OpCodes.Ldarg_1);
champSetIL.Emit(OpCodes.Stfld, champBldr);
champSetIL.Emit(OpCodes.Ret);
#endregion
#region Association des accesseurs à la propriété
constructeurPropriété.SetGetMethod(constructeurGet);
constructeurPropriété.SetSetMethod(constructeurSet);
#endregion
#endregion
return champBldr;
}
private static void CreateProperty(System.Reflection.Emit.TypeBuilder tb, string propertyName, Type propertyType)
{
FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
ILGenerator getIl = getPropMthdBldr.GetILGenerator();
getIl.Emit(OpCodes.Ldarg_0);
getIl.Emit(OpCodes.Ldfld, fieldBuilder);
getIl.Emit(OpCodes.Ret);
MethodBuilder setPropMthdBldr =
tb.DefineMethod("set_" + propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
null, new[] { propertyType });
ILGenerator setIl = setPropMthdBldr.GetILGenerator();
Label modifyProperty = setIl.DefineLabel();
Label exitSet = setIl.DefineLabel();
setIl.MarkLabel(modifyProperty);
setIl.Emit(OpCodes.Ldarg_0);
setIl.Emit(OpCodes.Ldarg_1);
setIl.Emit(OpCodes.Stfld, fieldBuilder);
setIl.Emit(OpCodes.Nop);
setIl.MarkLabel(exitSet);
setIl.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getPropMthdBldr);
propertyBuilder.SetSetMethod(setPropMthdBldr);
}
private static void BuildStringProperty(TypeBuilder typeBuilder, string property)
{
//implement properties from interface
FieldBuilder fieldBuilder = typeBuilder.DefineField(property.ToLower(), typeof(string), FieldAttributes.Private);
PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(property, PropertyAttributes.HasDefault, typeof(string), null);
const MethodAttributes getSetAttributes = MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig | MethodAttributes.Virtual;
//define 'get' accessor
MethodBuilder getPropertyBuilder = typeBuilder.DefineMethod("get_" + property, getSetAttributes, typeof(string),
Type.EmptyTypes);
//create IL code for get
ILGenerator genusGetIL = getPropertyBuilder.GetILGenerator();
genusGetIL.Emit(OpCodes.Ldarg_0);
genusGetIL.Emit(OpCodes.Ldfld, fieldBuilder);
genusGetIL.Emit(OpCodes.Ret);
//define 'set' accessor
MethodBuilder setPropertyBuilder = typeBuilder.DefineMethod("set_" + property, getSetAttributes, null,
new[] { typeof(String) });
//create IL code for set
ILGenerator genusSetIL = setPropertyBuilder.GetILGenerator();
genusSetIL.Emit(OpCodes.Ldarg_0);
genusSetIL.Emit(OpCodes.Ldarg_1);
genusSetIL.Emit(OpCodes.Stfld, fieldBuilder);
genusSetIL.Emit(OpCodes.Ret);
//map get and set to property 'methods'
propertyBuilder.SetGetMethod(getPropertyBuilder);
propertyBuilder.SetSetMethod(setPropertyBuilder);
}
internal static void CreateReadOnlyLazyProperty(TypeBuilder tb, PropertyInfo property, ILGenerator ctor, bool isInterfaceImplementation = true)
{
var propertyName = property.Name;
var propertyType = property.PropertyType;
//backing field
var lazyType = typeof(Lazy<>).MakeGenericType(propertyType);
var fb = tb.DefineField("_backing_" + propertyName, lazyType, FieldAttributes.Private);
//property
var pb = tb.DefineProperty(propertyName, PropertyAttributes.None, propertyType, null);
//getter
var getterAttributes = isInterfaceImplementation ? InterfaceImplementationAttributes : OverrideAttributes;
var getMethod = tb.DefineMethod("get_" + propertyName, getterAttributes, propertyType, Type.EmptyTypes);
var getIL = getMethod.GetILGenerator();
getIL.DeclareLocal(propertyType);
getIL.Emit(OpCodes.Nop);
getIL.Emit(OpCodes.Ldarg_0);
getIL.Emit(OpCodes.Ldfld, fb);
getIL.EmitCall(OpCodes.Callvirt, lazyType.GetProperty("Value").GetGetMethod(), null);
getIL.Emit(OpCodes.Stloc_0);
getIL.Emit(OpCodes.Nop); //originally a br.s to the next line
getIL.Emit(OpCodes.Ldloc_0);
getIL.Emit(OpCodes.Ret);
//combine getter and property
pb.SetGetMethod(getMethod);
//initialize Lazy<T> in .ctor
ctor.Emit(OpCodes.Ldarg_0);
ctor.Emit(OpCodes.Newobj, lazyType.GetConstructor(Type.EmptyTypes));
ctor.Emit(OpCodes.Stfld, fb);
}
/// <summary>
/// CreateProperty
/// </summary>
/// <param name="pi"></param>
/// <param name="methods"></param>
/// <param name="typeBuilder"></param>
/// <param name="privateSetters"></param>
private static FieldBuilder CreateProperty(this PropertyInfo pi, ICollection <MethodInfo> methods, System.Reflection.Emit.TypeBuilder typeBuilder, bool privateSetters)
{
// Create underlying field; all properties have a field of the same type
var backingField = typeBuilder.DefineField($"<{pi.Name}>k_BackingField", pi.PropertyType, FieldAttributes.Private);
// Attribute:
// [CompilerGenerated]
var compilerGeneratedAttr = typeof(CompilerGeneratedAttribute).GetConstructor(Type.EmptyTypes);
if (compilerGeneratedAttr != null)
{
// ReSharper disable once InconsistentNaming
var fieldCABuilder = new CustomAttributeBuilder(compilerGeneratedAttr, new object[] { });
backingField.SetCustomAttribute(fieldCABuilder);
}
// The last argument of DefineProperty is null, because the
// property has no parameters. (If you don't specify null, you must
// specify an array of Type objects. For a parameterless property,
// use an array with no elements: new Type[] {})
var propBldr = typeBuilder.DefineProperty(pi.Name, PropertyAttributes.HasDefault, CallingConventions.HasThis, pi.PropertyType, Type.EmptyTypes);
var container = new BuilderData {
_typeBuilder = typeBuilder, _fieldBuilder = backingField, _propertyBuilder = propBldr
};
// Disregard exceptions so that the custom defined properties can be used with the same algorithms even though their backing methods have not yet been defined.
MethodInfo getter = null, setter = null;
try {
getter = pi.GetGetMethod();
setter = pi.GetSetMethod();
} catch (Exception) {
// ignored
}
var jmpTable = new Dictionary <Instr, KeyValuePair <MethodInfo, PropertyType> > {
{ Instr.Getter, new KeyValuePair <MethodInfo, PropertyType>(getter, GetProperty) }, { Instr.Setter, new KeyValuePair <MethodInfo, PropertyType>(setter, SetProperty) }
};
foreach (var z in jmpTable)
{
if (z.Key == Instr.Setter && privateSetters)
{
container._methodAttributes = MethodAttributes.Private | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual;
}
// If there is a getter in the interface, create a getter in the new type
if (pi.ReflectedType != null)
{
if (z.Value.Key != null)
{
methods.Remove(z.Value.Key);
}
}
z.Value.Value(z.Value.Key, container);
}
return(backingField);
}
private static void BuildProperty(TypeBuilder typeBuilder, string name, Type type)
{
FieldBuilder field = typeBuilder.DefineField("m" + name, type, FieldAttributes.Private);
PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(name, PropertyAttributes.None, type, null);
MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual;
MethodBuilder getter = typeBuilder.DefineMethod("get_" + name, getSetAttr, type, Type.EmptyTypes);
ILGenerator getIL = getter.GetILGenerator();
getIL.Emit(OpCodes.Ldarg_0);
getIL.Emit(OpCodes.Ldfld, field);
getIL.Emit(OpCodes.Ret);
MethodBuilder setter = typeBuilder.DefineMethod("set_" + name, getSetAttr, null, new Type[] { type });
ILGenerator setIL = setter.GetILGenerator();
setIL.Emit(OpCodes.Ldarg_0);
setIL.Emit(OpCodes.Ldarg_1);
setIL.Emit(OpCodes.Stfld, field);
setIL.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getter);
propertyBuilder.SetSetMethod(setter);
}
/// <summary>
/// 动态创建类的属性
/// </summary>
/// <param name="tb">承载该属性的类型</param>
/// <param name="properityName">属性名，首字母应大写</param>
/// <param name="properityType">属性数据类型</param>
public static FieldBuilder createProperty(TypeBuilder tb, string propertyName, Type propertyType)
{
//定义属性对应的私有字段
FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
//定义属性
PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
//定义与属性相关的get方法
MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
propertyType,
Type.EmptyTypes);
ILGenerator getIL = getPropMthdBldr.GetILGenerator();//获取il 生成器
getIL.Emit(OpCodes.Ldarg_0);
getIL.Emit(OpCodes.Ldfld, fieldBuilder);
getIL.Emit(OpCodes.Ret);
//定义与属性相关的set方法
MethodBuilder setPropMthdBldr = tb.DefineMethod("set_" + propertyName,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
null, new Type[] { propertyType });
ILGenerator setIL = setPropMthdBldr.GetILGenerator();
/*
* OpCodes.Ldarg_0:Ldarg是加载方法参数的意思。这里Ldarg_0事实上是对当前对象的引用即this。
* 因为类的实例方法（非静态方法）在调用时，this 是会作为第一个参数传入的。
*/
setIL.Emit(OpCodes.Ldarg_0);
setIL.Emit(OpCodes.Ldarg_1);//OpCodes.Ldarg_1:加载参数列表的第一个参数了。
setIL.Emit(OpCodes.Stfld, fieldBuilder);//OpCodes.Stfld:用新值替换在对象引用或指针的字段中存储的值。
setIL.Emit(OpCodes.Ret);
//把get/set方法和属性联系起来
propertyBuilder.SetGetMethod(getPropMthdBldr);
propertyBuilder.SetSetMethod(setPropMthdBldr);
return fieldBuilder;
}
public override void Extend(Type baseType, TypeBuilder typeBuilder)
{
//build field
FieldBuilder field = typeBuilder.DefineField(FieldName, Type, FieldAttributes.Private);
//define property
PropertyBuilder property = typeBuilder.DefineProperty(Name, PropertyAttributes.None, Type, null);
//build setter
MethodBuilder setter = typeBuilder.DefineMethod("set_" + Name, MethodAttributes.Public | MethodAttributes.Virtual, null, new Type[] { Type });
ILGenerator setterILG = setter.GetILGenerator();
setterILG.Emit(OpCodes.Ldarg_0);
setterILG.Emit(OpCodes.Ldarg_1);
setterILG.Emit(OpCodes.Stfld, field);
setterILG.Emit(OpCodes.Ret);
property.SetSetMethod(setter);
//build getter
MethodBuilder getter = typeBuilder.DefineMethod("get_" + Name, MethodAttributes.Public | MethodAttributes.Virtual, Type, Type.EmptyTypes);
ILGenerator getterILG = getter.GetILGenerator();
getterILG.Emit(OpCodes.Ldarg_0);
getterILG.Emit(OpCodes.Ldfld, field);
getterILG.Emit(OpCodes.Ret);
property.SetGetMethod(getter);
}
internal static PropertyBuilder DefineProperty(TypeBuilder typeBuilder,
string name, Type type)
{
return typeBuilder.DefineProperty(name,
PropertyAttributes.HasDefault,
type, null);
}
private static void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType)
{
FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName,
propertyType,
FieldAttributes.Private);
PropertyBuilder propertyBuilder =
tb.DefineProperty(
propertyName, System.Reflection.PropertyAttributes.HasDefault, propertyType, null);
MethodBuilder getPropMthdBldr =
tb.DefineMethod("get_" + propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
propertyType, Type.EmptyTypes);
ILGenerator getIL = getPropMthdBldr.GetILGenerator();
getIL.Emit(OpCodes.Ldarg_0);
getIL.Emit(OpCodes.Ldfld, fieldBuilder);
getIL.Emit(OpCodes.Ret);
MethodBuilder setPropMthdBldr =
tb.DefineMethod("set_" + propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
null, new Type[] { propertyType });
ILGenerator setIL = setPropMthdBldr.GetILGenerator();
setIL.Emit(OpCodes.Ldarg_0);
setIL.Emit(OpCodes.Ldarg_1);
setIL.Emit(OpCodes.Stfld, fieldBuilder);
setIL.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getPropMthdBldr);
propertyBuilder.SetSetMethod(setPropMthdBldr);
}
private void CreateProperty(TypeBuilder a_TypeBuilder, string a_PropertyName, Type a_PropertyType)
{
FieldBuilder fieldBuilder = a_TypeBuilder.DefineField("_" + a_PropertyName, a_PropertyType, FieldAttributes.Private);
PropertyBuilder propertyBuilder = a_TypeBuilder.DefineProperty(a_PropertyName, PropertyAttributes.HasDefault, a_PropertyType, null);
MethodBuilder getPropMthdBldr = a_TypeBuilder.DefineMethod("get_" + a_PropertyName,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
a_PropertyType, Type.EmptyTypes);
ILGenerator getIl = getPropMthdBldr.GetILGenerator();
// Load the current instance onto the stack
getIl.Emit(OpCodes.Ldarg_0);
// Loads the value of the field specified as parameter from the object on the stack
getIl.Emit(OpCodes.Ldfld, fieldBuilder);
// Returns the method and pushes the get value onto the caller's stack
getIl.Emit(OpCodes.Ret);
MethodBuilder setPropMthdBldr = a_TypeBuilder.DefineMethod("set_" + a_PropertyName,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
null, new[] { a_PropertyType });
ILGenerator setIl = setPropMthdBldr.GetILGenerator();
// Load the current instance onto the stack
setIl.Emit(OpCodes.Ldarg_0);
// Load the first argument, which is the assignment value onto the stack
setIl.Emit(OpCodes.Ldarg_1);
// Store the value currently on the stack in the field specified as parameter in the object on the stack
setIl.Emit(OpCodes.Stfld, fieldBuilder);
// Returns the setter
setIl.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getPropMthdBldr);
propertyBuilder.SetSetMethod(setPropMthdBldr);
}
private static void MakeProperty(TypeBuilder typeBuilder, string name, Type type)
{
var fieldBuilder = typeBuilder.DefineField("_" + name, type, FieldAttributes.Private);
var propertyBuilder = typeBuilder.DefineProperty(name, PropertyAttributes.None, CallingConventions.HasThis, type,
null);
var getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual;
var getter = typeBuilder.DefineMethod("get_" + name, getSetAttr, type, Type.EmptyTypes);
var getIL = getter.GetILGenerator();
getIL.Emit(OpCodes.Ldarg_0);
getIL.Emit(OpCodes.Ldfld, fieldBuilder);
getIL.Emit(OpCodes.Ret);
var setter = typeBuilder.DefineMethod("set_" + name, getSetAttr, null, new[] {type});
var setIL = setter.GetILGenerator();
setIL.Emit(OpCodes.Ldarg_0);
setIL.Emit(OpCodes.Ldarg_1);
setIL.Emit(OpCodes.Stfld, fieldBuilder);
setIL.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getter);
propertyBuilder.SetSetMethod(setter);
}
private static FieldInfo[] GenerateProperties(TypeBuilder tb, IDictionary<string, Type> properties)
{
const MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
FieldInfo[] fields = new FieldBuilder[properties.Count];
int i = 0;
foreach (string key in properties.Keys)
{
string name = key;
Type type = properties[key];
FieldBuilder fb = tb.DefineField("_" + key, type, FieldAttributes.Public);
PropertyBuilder pb = tb.DefineProperty(key, PropertyAttributes.HasDefault, type, null);
MethodBuilder mbGet = tb.DefineMethod("get_" + name, getSetAttr, type, Type.EmptyTypes);
ILGenerator genGet = mbGet.GetILGenerator(8);
genGet.Emit(OpCodes.Ldarg_0);
genGet.Emit(OpCodes.Ldfld, fb);
genGet.Emit(OpCodes.Ret);
pb.SetGetMethod(mbGet);
MethodBuilder mbSet = tb.DefineMethod("set_" + name, getSetAttr, null, new Type[] { type });
ILGenerator genSet = mbSet.GetILGenerator(8);
genSet.Emit(OpCodes.Ldarg_0);
genSet.Emit(OpCodes.Ldarg_1);
genSet.Emit(OpCodes.Stfld, fb);
genSet.Emit(OpCodes.Ret);
pb.SetSetMethod(mbSet);
fields[i] = fb;
}
return fields;
}
private static void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType)
{
FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
ILGenerator getIl = getPropMthdBldr.GetILGenerator();
getIl.Emit(OpCodes.Ldarg_0);
getIl.Emit(OpCodes.Ldfld, fieldBuilder);
getIl.Emit(OpCodes.Ret);
MethodBuilder setPropMthdBldr =
tb.DefineMethod("set_" + propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
null, new[] { propertyType });
ILGenerator setIl = setPropMthdBldr.GetILGenerator();
Label modifyProperty = setIl.DefineLabel();
Label exitSet = setIl.DefineLabel();
setIl.MarkLabel(modifyProperty);
setIl.Emit(OpCodes.Ldarg_0);
setIl.Emit(OpCodes.Ldarg_1);
setIl.Emit(OpCodes.Stfld, fieldBuilder);
setIl.Emit(OpCodes.Nop);
setIl.MarkLabel(exitSet);
setIl.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getPropMthdBldr);
propertyBuilder.SetSetMethod(setPropMthdBldr);
}
private PropertyBuilder CreatePropertyProxyBuilder(TypeBuilder typeBuilder, PropertyInfo contractProperty)
{
var builder = typeBuilder.DefineProperty(contractProperty.Name, contractProperty.Attributes,
contractProperty.PropertyType, null);
return builder;
}
private void ImplementInterfaceProperties(Type interfaceOfTypeToCreate, System.Reflection.Emit.TypeBuilder typeBuilder)
{
typeBuilder.AddInterfaceImplementation(interfaceOfTypeToCreate);
foreach (var implementedInterfaceType in interfaceOfTypeToCreate.GetInterfaces())
{
ImplementInterfaceProperties(implementedInterfaceType, typeBuilder);
}
foreach (var pi in interfaceOfTypeToCreate.GetProperties())
{
var backingFieldBuilder = typeBuilder.DefineField($"{interfaceOfTypeToCreate.Name}._{ToCamelCase(pi.Name)}", pi.PropertyType, FieldAttributes.Private);
var accessorAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.Virtual | MethodAttributes.HideBySig;
var mbGetAccessor = typeBuilder.DefineMethod($"get_{pi.Name}", accessorAttributes, pi.PropertyType, Type.EmptyTypes);
var mbGetIL = mbGetAccessor.GetILGenerator();
mbGetIL.Emit(OpCodes.Ldarg_0);
mbGetIL.Emit(OpCodes.Ldfld, backingFieldBuilder);
mbGetIL.Emit(OpCodes.Ret);
var mbSetAccessor = typeBuilder.DefineMethod($"set_{pi.Name}", accessorAttributes, null, new[] { pi.PropertyType });
var mbSetIL = mbSetAccessor.GetILGenerator();
mbSetIL.Emit(OpCodes.Ldarg_0);
mbSetIL.Emit(OpCodes.Ldarg_1);
mbSetIL.Emit(OpCodes.Stfld, backingFieldBuilder);
mbSetIL.Emit(OpCodes.Ret);
var propertyBuilder = typeBuilder.DefineProperty(pi.Name, PropertyAttributes.HasDefault, pi.PropertyType, null);
propertyBuilder.SetGetMethod(mbGetAccessor);
propertyBuilder.SetSetMethod(mbSetAccessor);
}
}
private FieldInfo[] GenerateProperties(TypeBuilder tb, DynamicProperty[] properties)
{
FieldInfo[] array = new FieldBuilder[properties.Length];
for (int i = 0; i < properties.Length; i++)
{
DynamicProperty dynamicProperty = properties[i];
FieldBuilder fieldBuilder = tb.DefineField("_" + dynamicProperty.Name, dynamicProperty.Type, FieldAttributes.Private);
PropertyBuilder propertyBuilder = tb.DefineProperty(dynamicProperty.Name, PropertyAttributes.HasDefault, dynamicProperty.Type, null);
MethodBuilder methodBuilder = tb.DefineMethod("get_" + dynamicProperty.Name, MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.SpecialName, dynamicProperty.Type, Type.EmptyTypes);
ILGenerator iLGenerator = methodBuilder.GetILGenerator();
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
iLGenerator.Emit(OpCodes.Ret);
MethodBuilder methodBuilder2 = tb.DefineMethod("set_" + dynamicProperty.Name, MethodAttributes.FamANDAssem | MethodAttributes.Family | MethodAttributes.HideBySig | MethodAttributes.SpecialName, null, new Type[]
{
dynamicProperty.Type
});
ILGenerator iLGenerator2 = methodBuilder2.GetILGenerator();
iLGenerator2.Emit(OpCodes.Ldarg_0);
iLGenerator2.Emit(OpCodes.Ldarg_1);
iLGenerator2.Emit(OpCodes.Stfld, fieldBuilder);
iLGenerator2.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(methodBuilder);
propertyBuilder.SetSetMethod(methodBuilder2);
array[i] = fieldBuilder;
}
return array;
}
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 static void CreateProperty(TypeBuilder typeBuilder, string name, Type type)
{
var fieldBuilder = typeBuilder.DefineField("_" + name.ToLower(), type, FieldAttributes.Private);
var propertyBuilder = typeBuilder.DefineProperty(name, PropertyAttributes.HasDefault, type, null);
propertyBuilder.SetGetMethod(CreateGetMethod(typeBuilder, fieldBuilder, name, type));
propertyBuilder.SetSetMethod(CreateSetMethod(typeBuilder, fieldBuilder, name, type));
}
public static void DefineProperty(TypeBuilder typeBuilder, PropertyInfo propertyInfo,
MethodBuilder getMethodBuilder, MethodBuilder setMethodBuilder)
{
String propertyName = propertyInfo.DeclaringType.FullName + "." + propertyInfo.Name;
PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(propertyName, PropertyAttributes.None, propertyInfo.PropertyType, Type.EmptyTypes);
if (getMethodBuilder != null)
propertyBuilder.SetGetMethod(getMethodBuilder);
if (setMethodBuilder != null)
propertyBuilder.SetSetMethod(setMethodBuilder);
}
public void DefineProperty(TypeBuilder builder, Type type, string name)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("propertyName");
}
string fieldName = Char.ToLowerInvariant(name[0]) + name.Substring(1);
string propertyName = Char.ToUpperInvariant(name[0]) + name.Substring(1);
FieldBuilder fieldBuilder = builder.DefineField(
fieldName,
type,
FieldAttributes.Private);
PropertyBuilder propertyBuilder = builder.DefineProperty(
propertyName,
PropertyAttributes.HasDefault,
type,
null);
//Getter
MethodBuilder getMethodBuilder = builder.DefineMethod(
"get_" + propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
type,
Type.EmptyTypes);
ILGenerator getILGenerator = getMethodBuilder.GetILGenerator();
getILGenerator.Emit(OpCodes.Ldarg_0);
getILGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
getILGenerator.Emit(OpCodes.Ret);
//Setter
MethodBuilder setMethodBuilder = builder.DefineMethod(
"set_" + propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
null,
new Type[] { type });
ILGenerator setILGenerator = setMethodBuilder.GetILGenerator();
setILGenerator.Emit(OpCodes.Ldarg_0);
setILGenerator.Emit(OpCodes.Ldarg_1);
setILGenerator.Emit(OpCodes.Stfld, fieldBuilder);
setILGenerator.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getMethodBuilder);
propertyBuilder.SetSetMethod(setMethodBuilder);
}
private static void CreateProperty(System.Reflection.Emit.TypeBuilder tb, string propertyName, Type propertyType, bool required)
{
if (propertyType.IsByRef)
{
//avoids an exception in code below when by ref parameters are used
propertyType = propertyType.GetElementType();
}
FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName,
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
ILGenerator getIl = getPropMthdBldr.GetILGenerator();
getIl.Emit(OpCodes.Ldarg_0);
getIl.Emit(OpCodes.Ldfld, fieldBuilder);
getIl.Emit(OpCodes.Ret);
MethodBuilder setPropMthdBldr =
tb.DefineMethod("set_" + propertyName,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
null, new[] { propertyType });
ILGenerator setIl = setPropMthdBldr.GetILGenerator();
Label modifyProperty = setIl.DefineLabel();
Label exitSet = setIl.DefineLabel();
setIl.MarkLabel(modifyProperty);
setIl.Emit(OpCodes.Ldarg_0);
setIl.Emit(OpCodes.Ldarg_1);
setIl.Emit(OpCodes.Stfld, fieldBuilder);
setIl.Emit(OpCodes.Nop);
setIl.MarkLabel(exitSet);
setIl.Emit(OpCodes.Ret);
Type[] ctorParams = { };
ConstructorInfo contructorInfo = typeof(DataMemberAttribute).GetConstructor(ctorParams);
CustomAttributeBuilder customAttrBuilder = new CustomAttributeBuilder(contructorInfo, new object[] { });
//TODO: set IsRequired here ??
propertyBuilder.SetCustomAttribute(customAttrBuilder);
propertyBuilder.SetGetMethod(getPropMthdBldr);
propertyBuilder.SetSetMethod(setPropMthdBldr);
}
/// <summary>把lcpi参数里的属性加入到myTypeBuilder中。注意:该操作会将其它成员清除掉,其功能有待完善。</summary>
/// <param name="typeBuilder">类型构造器的实例。</param>
/// <param name="cpis">里面包含属性列表的信息。</param>
private static void AddPropertyToTypeBuilder(System.Reflection.Emit.TypeBuilder typeBuilder, List <CustPropertyInfo> cpis)
{
PropertyBuilder custNamePropBldr;
MethodBuilder custNameGetPropMthdBldr;
MethodBuilder custNameSetPropMthdBldr;
MethodAttributes getSetAttr;
ILGenerator custNameGetIL;
ILGenerator custNameSetIL;
// 属性Set和Get方法要一个专门的属性。这里设置为Public。
getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
// 添加属性到myTypeBuilder。
foreach (CustPropertyInfo cpi in cpis)
{
// 定义字段。
FieldBuilder customerNameBldr = typeBuilder.DefineField(cpi.FieldName, Type.GetType(cpi.Type), FieldAttributes.Private);
customerNameBldr.SetConstant("11111111");
// 定义属性。 最后一个参数为null,因为属性没有参数。
custNamePropBldr = typeBuilder.DefineProperty(cpi.PropertyName, PropertyAttributes.HasDefault, Type.GetType(cpi.Type), null);
custNamePropBldr.SetConstant("111111111");
// 定义Get方法。
custNameGetPropMthdBldr = typeBuilder.DefineMethod(cpi.GetPropertyMethodName, getSetAttr, Type.GetType(cpi.Type), Type.EmptyTypes);
custNameGetIL = custNameGetPropMthdBldr.GetILGenerator();
try
{
custNameGetIL.Emit(OpCodes.Ldarg_0);
//custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);
custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);
custNameGetIL.Emit(OpCodes.Ret);
}
catch
{
}
//定义Set方法。
custNameSetPropMthdBldr = typeBuilder.DefineMethod(cpi.SetPropertyMethodName, getSetAttr, null, new Type[] { Type.GetType(cpi.Type) });
custNameSetIL = custNameSetPropMthdBldr.GetILGenerator();
custNameSetIL.Emit(OpCodes.Ldarg_0);
custNameSetIL.Emit(OpCodes.Ldarg_1);
custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr);
custNameSetIL.Emit(OpCodes.Ret);
//custNamePropBldr.SetConstant("ceshi");
//把创建的两个方法(Get,Set)加入到PropertyBuilder中。
custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr);
custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr);
}
}
/// <summary>
/// Adds a new property o the runtime class
/// </summary>
/// <param name="typebuilder"></param>
/// <param name="propertyName">name of the property</param>
/// <param name="typeOfProperty">type of the property</param>
private static void AddProperty(TypeBuilder typebuilder, string propertyName, Type typeOfProperty)
{
// Generate a private field
FieldBuilder field = typebuilder.DefineField("_" + propertyName, typeOfProperty, FieldAttributes.Private);
// Generate a public property
PropertyBuilder property =
typebuilder.DefineProperty(propertyName,
PropertyAttributes.None,
typeOfProperty,
new Type[] { typeOfProperty });
// The property set and property get methods require a special set of attributes:
MethodAttributes GetSetAttr =
MethodAttributes.Public |
MethodAttributes.HideBySig;
// Define the "get" accessor method for current private field.
MethodBuilder currGetPropMthdBldr =
typebuilder.DefineMethod("get_value",
GetSetAttr,
typeOfProperty,
Type.EmptyTypes);
// Intermediate Language stuff...
ILGenerator currGetIL = currGetPropMthdBldr.GetILGenerator();
currGetIL.Emit(OpCodes.Ldarg_0);
currGetIL.Emit(OpCodes.Ldfld, field);
currGetIL.Emit(OpCodes.Ret);
// Define the "set" accessor method for current private field.
MethodBuilder currSetPropMthdBldr =
typebuilder.DefineMethod("set_value",
GetSetAttr,
null,
new Type[] { typeOfProperty });
// Again some Intermediate Language stuff...
ILGenerator currSetIL = currSetPropMthdBldr.GetILGenerator();
currSetIL.Emit(OpCodes.Ldarg_0);
currSetIL.Emit(OpCodes.Ldarg_1);
currSetIL.Emit(OpCodes.Stfld, field);
currSetIL.Emit(OpCodes.Ret);
// Last, we must map the two methods created above to our PropertyBuilder to
// their corresponding behaviors, "get" and "set" respectively.
property.SetGetMethod(currGetPropMthdBldr);
property.SetSetMethod(currSetPropMthdBldr);
}
/// <summary>
/// Create property with explicit implementation of getter and setter, with no method defined.
/// </summary>
private PropertyDefinition AddProperty(TypeDefinition declaringType,
string name,
TypeReference propertyType,
string explicitPrefix,
PropertyInfo overridedProp)
{
var proxyPropDef = declaringType.DefineProperty(explicitPrefix + name,
PropertyAttributes.None | PropertyAttributes.SpecialName,
propertyType,
null);
const MethodAttributes methodAttributes = MethodAttributes.Private
| MethodAttributes.HideBySig
| MethodAttributes.NewSlot
| MethodAttributes.Virtual
| MethodAttributes.Final
| MethodAttributes.SpecialName;
var overridedGetMethod = overridedProp.GetGetMethod();
if (overridedGetMethod != null)
{
var proxyPropGetter = declaringType.DefineMethod(
$"{explicitPrefix}get_{name}",
methodAttributes,
propertyType,
Type.EmptyTypes);
declaringType.DefineMethodOverride(proxyPropGetter, overridedGetMethod);
proxyPropDef.SetGetMethod(proxyPropGetter);
}
var overridedSetMethod = overridedProp.GetSetMethod();
if (overridedSetMethod != null)
{
var proxyPropSetter = declaringType.DefineMethod(
$"{explicitPrefix}set_{name}",
methodAttributes,
null,
new[] { propertyType });
proxyPropSetter.DefineParameter(0, ParameterAttributes.None, "value");
declaringType.DefineMethodOverride(proxyPropSetter, overridedSetMethod);
proxyPropDef.SetSetMethod(proxyPropSetter);
}
return(proxyPropDef);
}
private void AddProperty(TypeBuilder builder, string propertyName, Type propertyType)
{
string fieldName = String.Format("_{0}", propertyName);
Type type = propertyType;
if (type.IsValueType)
{
type = GetNullableType(type);
}
FieldBuilder fieldBuilder = builder.DefineField(fieldName, type, FieldAttributes.Private);
PropertyBuilder propertyBuilder =
builder.DefineProperty(propertyName, PropertyAttributes.None, type,
Type.EmptyTypes);
const MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig;
MethodBuilder getPropertyMethodBuilder =
builder.DefineMethod(
String.Format("get_{0}", propertyName),
getSetAttr,
type,
Type.EmptyTypes);
ILGenerator propertyNameGetIL = getPropertyMethodBuilder.GetILGenerator();
propertyNameGetIL.Emit(OpCodes.Ldarg_0);
propertyNameGetIL.Emit(OpCodes.Ldfld, fieldBuilder);
propertyNameGetIL.Emit(OpCodes.Ret);
MethodBuilder custNameSetPropMthdBldr =
builder.DefineMethod(
String.Format("set_{0}", propertyName),
getSetAttr,
null,
new[] {type});
ILGenerator propertyNameSetIL = custNameSetPropMthdBldr.GetILGenerator();
propertyNameSetIL.Emit(OpCodes.Ldarg_0);
propertyNameSetIL.Emit(OpCodes.Ldarg_1);
propertyNameSetIL.Emit(OpCodes.Stfld, fieldBuilder);
propertyNameSetIL.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getPropertyMethodBuilder);
propertyBuilder.SetSetMethod(custNameSetPropMthdBldr);
}
private static void AddProperty(TypeBuilder typeBuilder, Type baseType, string propertyName, Type propertyType)
{
var fieldBuilder = typeBuilder.DefineField(propertyName + Guid.NewGuid(),
propertyType,
FieldAttributes.Private);
var propertyBuilder = typeBuilder.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
// TODO: fix
//var customAttributeBuilder = new CustomAttributeBuilder(typeof (RequiredAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
//propertyBuilder.SetCustomAttribute(customAttributeBuilder);
const MethodAttributes getSetAttributes = MethodAttributes.Public
| MethodAttributes.SpecialName
| MethodAttributes.HideBySig;
var getPropertyValueMethod =
typeof (BusinessObject<>).MakeGenericType(baseType).GetMethod("GetProperty",
BindingFlags.NonPublic |
BindingFlags.Instance)
.MakeGenericMethod(propertyType);
var getMethodBuilder = typeBuilder.DefineMethod("get_" + propertyName, getSetAttributes, propertyType, Type.EmptyTypes);
ILGenerator getGenerator = getMethodBuilder.GetILGenerator();
getGenerator.Emit(OpCodes.Ldarg_0);
getGenerator.Emit(OpCodes.Ldstr, propertyName);
getGenerator.Emit(OpCodes.Ldarg_0);
getGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
getGenerator.Emit(OpCodes.Call, getPropertyValueMethod);
getGenerator.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getMethodBuilder);
var setPropertyValueMethod =
typeof (BusinessObject<>).MakeGenericType(baseType).GetMethod("SetProperty",
BindingFlags.NonPublic |
BindingFlags.Instance)
.MakeGenericMethod(propertyType);
var setMethodBuilder = typeBuilder.DefineMethod("set_" + propertyName, getSetAttributes, null, new[] { propertyType });
ILGenerator setGenerator = setMethodBuilder.GetILGenerator();
setGenerator.Emit(OpCodes.Ldarg_0);
setGenerator.Emit(OpCodes.Ldstr, propertyName);
setGenerator.Emit(OpCodes.Ldarg_0);
setGenerator.Emit(OpCodes.Ldflda, fieldBuilder);
setGenerator.Emit(OpCodes.Ldarg_1);
setGenerator.Emit(OpCodes.Call, setPropertyValueMethod);
setGenerator.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setMethodBuilder);
}
private static void CreateDecoratedProperty(TypeBuilder tb, PropertyInfo prop, Type decoratorType, string decoratedPropertyName, Type decoratedType)
{
var propertyName = prop.Name;
var propertyType = prop.PropertyType;
var propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.None, propertyType, null);
foreach (var builder in prop.GetCustomAttributesData().Select(GetAttributeCopy))
propertyBuilder.SetCustomAttribute(builder);
var getPropMthdBldr = tb.DefineMethod("get_" + propertyName,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType,
Type.EmptyTypes);
var getIl = getPropMthdBldr.GetILGenerator();
getIl.Emit(OpCodes.Ldarg_0);
getIl.Emit(OpCodes.Castclass, decoratorType);
getIl.Emit(OpCodes.Callvirt, decoratorType.GetProperty(decoratedPropertyName,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetGetMethod(true));
getIl.Emit(OpCodes.Callvirt, decoratedType.GetProperty(propertyName,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetGetMethod(true));
getIl.Emit(OpCodes.Ret);
var setPropMthdBldr = tb.DefineMethod("set_" + propertyName,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null,
new[] { propertyType });
propertyBuilder.SetGetMethod(getPropMthdBldr);
var setIl = setPropMthdBldr.GetILGenerator();
//var modifyProperty = setIl.DefineLabel();
//var exitSet = setIl.DefineLabel();
//setIl.MarkLabel(modifyProperty);
setIl.Emit(OpCodes.Ldarg_0);
//setIl.Emit(OpCodes.Castclass, decoratorType);
setIl.Emit(OpCodes.Callvirt, decoratorType.GetProperty(decoratedPropertyName,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetGetMethod(true));
setIl.Emit(OpCodes.Ldarg_1);
setIl.Emit(OpCodes.Callvirt, decoratedType.GetProperty(propertyName,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetSetMethod(true));
//setIl.Emit(OpCodes.Nop);
//setIl.MarkLabel(exitSet);
setIl.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setPropMthdBldr);
}
internal CodeProperty (CodeClass cls, string name, PropertyAttributes attributes, MethodAttributes methodAttributes, Type returnType, Type[] parameterTypes)
{
this.cls = cls;
this.typeBuilder = cls.TypeBuilder;
this.name = name;
this.attributes = attributes;
this.methodAttributes = methodAttributes;
this.returnType = returnType;
this.parameterTypes = parameterTypes;
PropertyBuilder pb = typeBuilder.DefineProperty (name, attributes, returnType, parameterTypes);
pb.SetGetMethod (typeBuilder.DefineMethod ("get_" + name, methodAttributes, CallingConventions.Standard, returnType, Type.EmptyTypes));
pb.SetSetMethod (typeBuilder.DefineMethod ("set_" + name, methodAttributes, CallingConventions.Standard, typeof (void), new Type [] {returnType}));
get_builder = new CodeBuilder (cls);
set_builder = new CodeBuilder (cls);
propertyInfo = pb;
}
/// <summary>
/// Creates the property.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="prop">The prop.</param>
public static void CreateProperty(TypeBuilder typeBuilder, PropertyInfo prop)
{
var fieldBuilder = typeBuilder.DefineField(
"field_" + prop.Name,
prop.PropertyType,
FieldAttributes.Private);
var propBuilder = typeBuilder.DefineProperty(
prop.Name,
prop.Attributes | PropertyAttributes.HasDefault,
prop.PropertyType,
null);
SetDataMemberAttribute(propBuilder);
CreateGetMethod(typeBuilder, prop, fieldBuilder, propBuilder);
CreateSetMethod(typeBuilder, prop, fieldBuilder, propBuilder);
}
private void CreateProperty(TypeBuilder typeBuilder, PropertyInfo interfaceProperty)
{
var propertyName = interfaceProperty.Name;
var field = typeBuilder.DefineField(
propertyName,
interfaceProperty.PropertyType,
FieldAttributes.Private);
var property = typeBuilder.DefineProperty(
propertyName,
PropertyAttributes.None,
interfaceProperty.PropertyType,
new[] { interfaceProperty.PropertyType });
var getMethodBuilder = typeBuilder.DefineMethod(
"get_value",
DuckMethodAttributes,
interfaceProperty.PropertyType,
Type.EmptyTypes);
var getGenerator = getMethodBuilder.GetILGenerator();
getGenerator.Emit(OpCodes.Ldarg_0);
getGenerator.Emit(OpCodes.Ldfld, field);
getGenerator.Emit(OpCodes.Ret);
var setMethodBuilder = typeBuilder.DefineMethod(
"set_value",
DuckMethodAttributes,
null,
new[] { interfaceProperty.PropertyType });
var setGenerator = setMethodBuilder.GetILGenerator();
setGenerator.Emit(OpCodes.Ldarg_0);
setGenerator.Emit(OpCodes.Ldarg_1);
setGenerator.Emit(OpCodes.Stfld, field);
setGenerator.Emit(OpCodes.Ret);
property.SetGetMethod(getMethodBuilder);
property.SetSetMethod(setMethodBuilder);
typeBuilder.DefineMethodOverride(getMethodBuilder, interfaceProperty.GetGetMethod());
typeBuilder.DefineMethodOverride(setMethodBuilder, interfaceProperty.GetSetMethod());
}
private static void CreateProperty(TypeBuilder typeBuilder, XomNodeAttribute attribute)
{
var attributeType = attribute.Type;
if (attributeType.IsValueType && !attribute.IsRequired)
attributeType = typeof (Nullable<>).MakeGenericType(attributeType);
var fieldBuilder = typeBuilder.DefineField("_" + attribute.Name, attributeType, FieldAttributes.Private);
var propertyBuilder = typeBuilder.DefineProperty(attribute.Name, PropertyAttributes.HasDefault,
attributeType, null);
var getPropMthdBldr = typeBuilder.DefineMethod("get_" + attribute.Name,
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig, attributeType, Type.EmptyTypes);
var getIl = getPropMthdBldr.GetILGenerator();
getIl.Emit(OpCodes.Ldarg_0);
getIl.Emit(OpCodes.Ldfld, fieldBuilder);
getIl.Emit(OpCodes.Ret);
MethodBuilder setPropMthdBldr =
typeBuilder.DefineMethod("set_" + attribute.Name,
MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig,
null, new[] { attributeType });
ILGenerator setIl = setPropMthdBldr.GetILGenerator();
Label modifyProperty = setIl.DefineLabel();
Label exitSet = setIl.DefineLabel();
setIl.MarkLabel(modifyProperty);
setIl.Emit(OpCodes.Ldarg_0);
setIl.Emit(OpCodes.Ldarg_1);
setIl.Emit(OpCodes.Stfld, fieldBuilder);
setIl.Emit(OpCodes.Nop);
setIl.MarkLabel(exitSet);
setIl.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getPropMthdBldr);
propertyBuilder.SetSetMethod(setPropMthdBldr);
}
/// <summary>
/// Adds a new property to the type builder, with getter and setter to a generated field.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="propertyType">Type of the property.</param>
public static void AddProperty(TypeBuilder typeBuilder, string propertyName, Type propertyType)
{
const MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.HideBySig;
FieldBuilder field = typeBuilder.DefineField("_" + propertyName, typeof(string), FieldAttributes.Private);
PropertyBuilder property = typeBuilder.DefineProperty(propertyName, PropertyAttributes.None, propertyType, new[] { propertyType });
MethodBuilder getMethodBuilder = typeBuilder.DefineMethod("get_value", getSetAttr, propertyType, Type.EmptyTypes);
ILGenerator getIl = getMethodBuilder.GetILGenerator();
getIl.Emit(OpCodes.Ldarg_0);
getIl.Emit(OpCodes.Ldfld, field);
getIl.Emit(OpCodes.Ret);
MethodBuilder setMethodBuilder = typeBuilder.DefineMethod("set_value", getSetAttr, null, new[] { propertyType });
ILGenerator setIl = setMethodBuilder.GetILGenerator();
setIl.Emit(OpCodes.Ldarg_0);
setIl.Emit(OpCodes.Ldarg_1);
setIl.Emit(OpCodes.Stfld, field);
setIl.Emit(OpCodes.Ret);
property.SetGetMethod(getMethodBuilder);
property.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 IConstructorArg Define(TypeBuilder tb)
{
FieldBuilder fieldBuilder = tb.DefineField("_" + Name, ParameterType, FieldAttributes.Private);
PropertyBuilder propertyBuilder = tb.DefineProperty(Name, PropertyAttributes.HasDefault, ParameterType, null);
MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + Name, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
ParameterType, Type.EmptyTypes);
ILGenerator getIl = getPropMthdBldr.GetILGenerator();
getIl.Emit(OpCodes.Ldarg_0);
getIl.Emit(OpCodes.Ldfld, fieldBuilder);
getIl.Emit(OpCodes.Ret);
var methodAttributes = MethodAttributes.Private |
MethodAttributes.SpecialName |
MethodAttributes.HideBySig;
MethodBuilder setPropMthdBldr =
tb.DefineMethod("set_" + Name,
methodAttributes,
null, new[] { ParameterType });
ILGenerator setIl = setPropMthdBldr.GetILGenerator();
Label modifyProperty = setIl.DefineLabel();
Label exitSet = setIl.DefineLabel();
setIl.MarkLabel(modifyProperty);
setIl.Emit(OpCodes.Ldarg_0);
setIl.Emit(OpCodes.Ldarg_1);
setIl.Emit(OpCodes.Stfld, fieldBuilder);
setIl.Emit(OpCodes.Nop);
setIl.MarkLabel(exitSet);
setIl.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getPropMthdBldr);
propertyBuilder.SetSetMethod(setPropMthdBldr);
return new InjectableConstructorArg(ParameterType, Name, getPropMthdBldr, setPropMthdBldr);
}
public static void Generate(
TypeBuilder typeBuilder,
PropertyMetadata propertyMetadata,
MethodBuilder getMethod,
MethodBuilder setMethod)
{
var property = typeBuilder.DefineProperty(
propertyMetadata.Name,
propertyMetadata.PropertyAttributes,
propertyMetadata.PropertyType,
propertyMetadata.IndexerTypes);
if (getMethod != null)
{
property.SetGetMethod(getMethod);
}
if (setMethod != null)
{
property.SetSetMethod(setMethod);
}
}
public static PropertyBuilder CreateProperty(TypeBuilder inputbuilder, string propertyname, Type propertytype)
{
PropertyBuilder propBuilder = inputbuilder.DefineProperty(propertyname, PropertyAttributes.None, propertytype, null);
FieldBuilder fieldBuilder = inputbuilder.DefineField(string.Format("<>dynamicfield_{0}", propertyname), propertytype, FieldAttributes.Private);
MethodBuilder setValue = inputbuilder.DefineMethod(string.Format("Set_{0}", propertyname), MethodAttributes.Public, typeof(void), new Type[] { propertytype });
MethodBuilder getValue = inputbuilder.DefineMethod(string.Format("Get_{0}", propertyname), MethodAttributes.Public, propertytype, null);
ILGenerator setMethodIL = setValue.GetILGenerator();
setMethodIL.Emit(OpCodes.Ldarg, 0);
setMethodIL.Emit(OpCodes.Ldarg, 1);
setMethodIL.Emit(OpCodes.Stfld, fieldBuilder);
setMethodIL.Emit(OpCodes.Ret);
propBuilder.SetSetMethod(setValue);
ILGenerator getMethodIL = getValue.GetILGenerator();
getMethodIL.Emit(OpCodes.Ldarg, 0);
getMethodIL.Emit(OpCodes.Ldfld, fieldBuilder);
getMethodIL.Emit(OpCodes.Ret);
propBuilder.SetGetMethod(getValue);
return propBuilder;
}
/// <summary>
/// Generate the declaration for the IgnoresAccessChecksToAttribute type.
/// This attribute will be both defined and used in the dynamic assembly.
/// Each usage identifies the name of the assembly containing non-public
/// types the dynamic assembly needs to access. Normally those types
/// would be inaccessible, but this attribute allows them to be visible.
/// It works like a reverse InternalsVisibleToAttribute.
/// This method returns the ConstructorInfo of the generated attribute.
/// </summary>
public static ConstructorInfo AddToModule(ModuleBuilder mb)
{
TypeBuilder attributeTypeBuilder =
mb.DefineType("System.Runtime.CompilerServices.IgnoresAccessChecksToAttribute",
TypeAttributes.Public | TypeAttributes.Class,
typeof(Attribute));
// Create backing field as:
// private string assemblyName;
FieldBuilder assemblyNameField =
attributeTypeBuilder.DefineField("assemblyName", typeof(string), FieldAttributes.Private);
// Create ctor as:
// public IgnoresAccessChecksToAttribute(string)
ConstructorBuilder constructorBuilder = attributeTypeBuilder.DefineConstructor(MethodAttributes.Public,
CallingConventions.HasThis,
new Type[] { assemblyNameField.FieldType });
ILGenerator il = constructorBuilder.GetILGenerator();
// Create ctor body as:
// this.assemblyName = {ctor parameter 0}
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg, 1);
il.Emit(OpCodes.Stfld, assemblyNameField);
// return
il.Emit(OpCodes.Ret);
// Define property as:
// public string AssemblyName {get { return this.assemblyName; } }
_ = attributeTypeBuilder.DefineProperty(
"AssemblyName",
PropertyAttributes.None,
CallingConventions.HasThis,
returnType: typeof(string),
parameterTypes: null);
MethodBuilder getterMethodBuilder = attributeTypeBuilder.DefineMethod(
"get_AssemblyName",
MethodAttributes.Public,
CallingConventions.HasThis,
returnType: typeof(string),
parameterTypes: null);
// Generate body:
// return this.assemblyName;
il = getterMethodBuilder.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, assemblyNameField);
il.Emit(OpCodes.Ret);
// Generate the AttributeUsage attribute for this attribute type:
// [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
TypeInfo attributeUsageTypeInfo = typeof(AttributeUsageAttribute).GetTypeInfo();
// Find the ctor that takes only AttributeTargets
ConstructorInfo attributeUsageConstructorInfo =
attributeUsageTypeInfo.DeclaredConstructors
.Single(c => c.GetParameters().Length == 1 &&
c.GetParameters()[0].ParameterType == typeof(AttributeTargets));
// Find the property to set AllowMultiple
PropertyInfo allowMultipleProperty =
attributeUsageTypeInfo.DeclaredProperties
.Single(f => string.Equals(f.Name, "AllowMultiple"));
// Create a builder to construct the instance via the ctor and property
CustomAttributeBuilder customAttributeBuilder =
new CustomAttributeBuilder(attributeUsageConstructorInfo,
new object[] { AttributeTargets.Assembly },
new PropertyInfo[] { allowMultipleProperty },
new object[] { true });
// Attach this attribute instance to the newly defined attribute type
attributeTypeBuilder.SetCustomAttribute(customAttributeBuilder);
// Make the TypeInfo real so the constructor can be used.
return(attributeTypeBuilder.CreateTypeInfo() !.DeclaredConstructors.Single());
}
/// <summary>
/// Compiles the type that is being built and returns its run-time Type.
/// If you want to create instances directly, see the GetConstructorDelegate.
/// </summary>
public Type Compile()
{
if (_compiledType == null)
{
_CheckThread();
_delegates = new Delegate[_methods.Count];
var methodBuilders = new Dictionary <string, MethodBuilder>();
int index = -1;
foreach (var method in _methods)
{
index++;
var methodBuilder = _Compile(method, index);
methodBuilders[method.Name] = methodBuilder;
}
foreach (var property in _properties.Values)
{
string name = property.Name;
var propertyBuilder = _type.DefineProperty(name, PropertyAttributes.None, property.PropertyType, Type.EmptyTypes);
propertyBuilder.SetGetMethod(methodBuilders["get_" + name]);
propertyBuilder.SetSetMethod(methodBuilders["set_" + name]);
}
foreach (var eventInfo in _events.Values)
{
string name = eventInfo.Name;
var eventBuilder = _type.DefineEvent(name, EventAttributes.None, eventInfo.Type);
string addName = "add_" + name;
string removeName = "remove_" + name;
var addMethod = methodBuilders[addName];
var removeMethod = methodBuilders[removeName];
eventBuilder.SetAddOnMethod(addMethod);
eventBuilder.SetRemoveOnMethod(removeMethod);
foreach (var interfaceType in _interfaceTypes)
{
var method = interfaceType.GetMethod(addName);
if (method != null)
{
_type.DefineMethodOverride(addMethod, method);
}
method = interfaceType.GetMethod(removeName);
if (method != null)
{
_type.DefineMethodOverride(removeMethod, method);
}
}
}
var compiledType = _type.CreateType();
var thisExpression = Expression.Parameter(compiledType, "this");
var fields = _fields.ToArray();
foreach (var fieldPair in fields)
{
var leftPair = fieldPair.Key;
var field = leftPair.Key;
var rightPair = fieldPair.Value;
string fieldName = rightPair.Value;
var expression = Expression.MakeMemberAccess(thisExpression, compiledType.GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic));
_fields[leftPair] = new KeyValuePair <MemberExpression, string>(expression, fieldName);
}
index = -1;
foreach (var method in _methods)
{
index++;
if (method._respectVisibility)
{
continue;
}
if (!method.IsStatic)
{
var firstParameter = method._parameters.Keys.First();
method._parameters[firstParameter] = thisExpression;
}
var compiledMethod = method._Compile(null, null);
_delegates[index] = compiledMethod;
}
var delegatesField = compiledType.GetField(".delegates", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
delegatesField.SetValue(null, _delegates);
_compiledType = compiledType;
}
return(_compiledType);
}
public static PropertyBuilder DefineProperty(this TypeBuilder tb, string name, PropertyAttributes attributes, CallingConventions callingConvention, GenericTypeParameterBuilder returnType, Type[] parameterTypes)
{
return(tb.DefineProperty(name, attributes, callingConvention, returnType.AsType(), parameterTypes));
}