| public SetSetMethod ( System mdBuilder ) : void | ||
| mdBuilder | System | |
| return | void | |
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 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 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);
}
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());
}
/// <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);
}
private void EmitCollectionProperty(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty, NavigationProperty navProperty)
{
const MethodAttributes methodAttributes = MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual;
MethodInfo baseSetter = baseProperty.GetSetMethod(true); ;
MethodAttributes methodAccess = baseSetter.Attributes & MethodAttributes.MemberAccessMask;
string cannotSetException = System.Data.Entity.Strings.EntityProxyTypeInfo_CannotSetEntityCollectionProperty(propertyBuilder.Name, typeBuilder.Name);
MethodBuilder setterBuilder = typeBuilder.DefineMethod("set_" + baseProperty.Name, methodAccess | methodAttributes, null, new Type[] { baseProperty.PropertyType });
ILGenerator generator = setterBuilder.GetILGenerator();
Label instanceEqual = generator.DefineLabel();
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, _getRelationshipManager);
generator.Emit(OpCodes.Ldstr, navProperty.RelationshipType.FullName);
generator.Emit(OpCodes.Ldstr, navProperty.ToEndMember.Name);
generator.Emit(OpCodes.Callvirt, s_GetRelatedEnd);
generator.Emit(OpCodes.Beq_S, instanceEqual);
generator.Emit(OpCodes.Ldstr, cannotSetException);
generator.Emit(OpCodes.Newobj, s_InvalidOperationConstructor);
generator.Emit(OpCodes.Throw);
generator.MarkLabel(instanceEqual);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Call, baseProperty.GetSetMethod(true));
generator.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setterBuilder);
_collectionProperties.Add(new KeyValuePair<NavigationProperty, PropertyInfo>(navProperty, baseProperty));
}
private void EmitReferenceProperty(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty, NavigationProperty navProperty)
{
const MethodAttributes methodAttributes = MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual;
MethodInfo baseSetter = baseProperty.GetSetMethod(true); ;
MethodAttributes methodAccess = baseSetter.Attributes & MethodAttributes.MemberAccessMask;
MethodInfo specificGetRelatedReference = s_GetRelatedReference.MakeGenericMethod(baseProperty.PropertyType);
MethodInfo specificEntityReferenceSetValue = typeof(EntityReference<>).MakeGenericType(baseProperty.PropertyType).GetMethod("set_Value"); ;
MethodBuilder setterBuilder = typeBuilder.DefineMethod("set_" + baseProperty.Name, methodAccess | methodAttributes, null, new Type[] { baseProperty.PropertyType });
ILGenerator generator = setterBuilder.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Callvirt, _getRelationshipManager);
generator.Emit(OpCodes.Ldstr, navProperty.RelationshipType.FullName);
generator.Emit(OpCodes.Ldstr, navProperty.ToEndMember.Name);
generator.Emit(OpCodes.Callvirt, specificGetRelatedReference);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Callvirt, specificEntityReferenceSetValue);
generator.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setterBuilder);
_referenceProperties.Add(new KeyValuePair<NavigationProperty,PropertyInfo>(navProperty, baseProperty));
}
private void EmitScalarSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, PropertyInfo baseProperty, bool isKeyMember)
{
MethodInfo baseSetter = baseProperty.GetSetMethod(true);
const MethodAttributes methodAttributes = MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual;
MethodAttributes methodAccess = baseSetter.Attributes & MethodAttributes.MemberAccessMask;
MethodBuilder setterBuilder = typeBuilder.DefineMethod("set_" + baseProperty.Name, methodAccess | methodAttributes, null, new Type[] { baseProperty.PropertyType });
ILGenerator generator = setterBuilder.GetILGenerator();
Label endOfMethod = generator.DefineLabel();
// If the CLR property represents a key member of the Entity Type,
// ignore attempts to set the key value to the same value.
if (isKeyMember)
{
MethodInfo baseGetter = baseProperty.GetGetMethod(true);
if (baseGetter != null)
{
// if (base.[Property] != value)
// {
// // perform set operation
// }
Type propertyType = baseProperty.PropertyType;
if (propertyType == typeof(int) || // signed integer types
propertyType == typeof(short) ||
propertyType == typeof(Int64) ||
propertyType == typeof(bool) || // boolean
propertyType == typeof(byte) ||
propertyType == typeof(UInt32) ||
propertyType == typeof(UInt64)||
propertyType == typeof(float) ||
propertyType == typeof(double) ||
propertyType.IsEnum)
{
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, baseGetter);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Beq_S, endOfMethod);
}
else if (propertyType == typeof(byte[]))
{
// Byte arrays must be compared by value
generator.Emit(OpCodes.Ldsfld, _compareByteArraysField);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, baseGetter);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Callvirt, s_Func_object_object_bool_Invoke);
generator.Emit(OpCodes.Brtrue_S, endOfMethod);
}
else
{
// Get the specific type's inequality method if it exists
MethodInfo op_inequality = propertyType.GetMethod("op_Inequality", new Type[] { propertyType, propertyType });
if (op_inequality != null)
{
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, baseGetter);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Call, op_inequality);
generator.Emit(OpCodes.Brfalse_S, endOfMethod);
}
else
{
// Use object inequality
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Call, baseGetter);
if (propertyType.IsValueType)
{
generator.Emit(OpCodes.Box, propertyType);
}
generator.Emit(OpCodes.Ldarg_1);
if (propertyType.IsValueType)
{
generator.Emit(OpCodes.Box, propertyType);
}
generator.Emit(OpCodes.Call, s_ObjectEquals);
generator.Emit(OpCodes.Brtrue_S, endOfMethod);
}
}
}
}
// Creates code like this:
//
// try
// {
// MemberChanging(propertyName);
// base.Property_set(value);
// MemberChanged(propertyName);
// }
// finally
// {
// _resetFKSetterFlagField(this);
// }
//
// Note that the try/finally ensures that even if an exception causes
// the setting of the property to be aborted, we still clear the flag that
// indicates that we are in a property setter.
generator.BeginExceptionBlock();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldstr, baseProperty.Name);
generator.Emit(OpCodes.Call, _entityMemberChanging);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Call, baseSetter);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldstr, baseProperty.Name);
generator.Emit(OpCodes.Call, _entityMemberChanged);
generator.BeginFinallyBlock();
generator.Emit(OpCodes.Ldsfld, _resetFKSetterFlagField);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Callvirt, s_Action_Invoke);
generator.EndExceptionBlock();
generator.MarkLabel(endOfMethod);
generator.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setterBuilder);
}
/* Setter IL
IL_0000: ldarg.0
IL_0001: ldfld Ns.EntityBase::Record
IL_0006: ldc.i4.1
IL_0007: ldarg.1
IL_0008: callvirt instance void Ns.EntityRecord::SetValue(int32, object)
IL_000d: ret
*/
private MethodBuilder CreateSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, int memberIndex,
string name = null, bool asPublic = true)
{
var setterName = name ?? "set_" + propertyBuilder.Name;
var attrs = MethodAttributes.SpecialName | MethodAttributes.Virtual | MethodAttributes.HideBySig;
if (asPublic)
attrs |= MethodAttributes.Public;
else
attrs |= MethodAttributes.Private;
var propType = propertyBuilder.PropertyType;
var setter = typeBuilder.DefineMethod(setterName, attrs, null, new Type[] { propType });
var ilGen = setter.GetILGenerator();
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, _entityBase_Record);
ilGen.Emit(OpCodes.Ldc_I4, memberIndex);
ilGen.Emit(OpCodes.Ldarg_1);
if (propType.IsValueType || propType.IsEnum)
ilGen.Emit(OpCodes.Box, propType);
ilGen.Emit(OpCodes.Call, _entityRecord_SetValue);
ilGen.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setter);
return setter;
}
private static void SetAccessors(PropertyBuilder property, IEnumerable<RppMethodInfo> methods)
{
string propertyName = property.Name;
foreach (RppMethodInfo method in methods)
{
if (method.Name == RppMethodInfo.GetGetterAccessorName(propertyName))
{
property.SetGetMethod((MethodBuilder) method.Native);
}
else if (method.Name == RppMethodInfo.GetSetterAccessorName(propertyName))
{
property.SetSetMethod((MethodBuilder) method.Native);
}
}
}
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 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);
}
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 void DefinePropertySetter(Entity c, Entity p, TypeBuilder t, bool forward, string propname, Type rettype, Type retelemtype, bool functional, PropertyBuilder property)
{
if (!functional) return;
MethodBuilder method = t.DefineMethod("set_" + propname,
MethodAttributes.Public | MethodAttributes.SpecialName,
CallingConventions.HasThis,
null, new Type[] { rettype } );
property.SetSetMethod(method);
ILGenerator il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldstr, p.Uri);
il.Emit(OpCodes.Newobj, newentity);
il.Emit(OpCodes.Ldarg_1);
if (forward)
il.Emit(OpCodes.Ldc_I4_1);
else
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Call, anysetfuncvalue);
il.Emit(OpCodes.Ret);
}
/// <summary>
/// Creates the body of a property setter
/// </summary>
/// <param name="generatedTypeBuilder"></param>
/// <param name="p"></param>
/// <param name="property"></param>
/// <param name="setDecl"></param>
/// <param name="logicField"></param>
private void CreatePropertySetMethod(TypeBuilderHelper generatedTypeBuilder, PropertyInfo p,
PropertyBuilder property, MethodInfo setDecl, FieldInfo logicField)
{
//set getter name and parameter types
var name = setDecl == null ? "set_" + p.Name : setDecl.Name;
var parameterTypes = setDecl == null ? new[] { p.PropertyType }
: setDecl.GetParameters().Select(x => x.ParameterType).ToArray();
//set attributes on setter
var methodAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual;
//build setter method
var setBuilder = generatedTypeBuilder.DefineMethod(name, methodAttributes, null, parameterTypes);
//spit out IL
setBuilder
.Emitter
.ldarg_0
.ldfld(logicField)
.ldstr(p.Name)
.ldarg_1
.callvirt(Reflect<LogicBase>.GetMethod(x=> x.SetProperty(string.Empty, string.Empty)).MakeGenericMethod(p.PropertyType))
.nop
.ret();
//apply setter method to the property
property.SetSetMethod(setBuilder);
}
protected void DefineBuilders(MemberKind kind, ParametersCompiled parameters)
{
// FIXME - PropertyAttributes.HasDefault ?
PropertyBuilder = Parent.TypeBuilder.DefineProperty (
GetFullName (MemberName), PropertyAttributes.None, MemberType.GetMetaInfo (), parameters.GetMetaInfo ());
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);
spec.Get = Get.Spec;
spec.Set = Set.Spec;
if (!Get.IsDummy) {
PropertyBuilder.SetGetMethod (GetBuilder);
}
if (!Set.IsDummy) {
PropertyBuilder.SetSetMethod (SetBuilder);
}
Parent.MemberCache.AddMember (this, Get.IsDummy ? Get.Name : GetBuilder.Name, Get.Spec);
Parent.MemberCache.AddMember (this, Set.IsDummy ? Set.Name : SetBuilder.Name, Set.Spec);
Parent.MemberCache.AddMember (this, PropertyBuilder.Name, spec);
}
public MethodBuilder CreateSetMethod(TypeBuilder Class, PropertyBuilder Property, FieldBuilder Field, Boolean Public, System.Type ReturnType)
{
String methodName = "set_" + Property.Name;
MethodBuilder setMethod = Class.DefineMethod(methodName,
BasePropertyMethodAttr,
null,
new Type[] { ReturnType });
ILGenerator setIL = setMethod.GetILGenerator();
setIL.Emit(OpCodes.Ldarg_0);
setIL.Emit(OpCodes.Ldarg_1);
setIL.Emit(OpCodes.Stfld, Field);
setIL.Emit(OpCodes.Ret);
Property.SetSetMethod(setMethod);
return setMethod;
}
private static void EmitProperty(
PropertyInfo info,
string name,
string convertGet,
Type tGetReturnType,
string invokeGet,
Type[] indexParamTypes,
MethodInfo setMethod,
string invokeSet,
Type[] setParamTypes,
TypeBuilder typeBuilder,
MethodBuilder getMethodBuilder,
Type callSite,
Type contextType,
Type tConvertFuncType,
Type invokeGetFuncType,
PropertyBuilder tMp,
Type invokeSetFuncType, bool defaultImp)
{
if (indexParamTypes == null) {
throw new ArgumentNullException("indexParamTypes");
}
var tIlGen = getMethodBuilder.GetILGenerator();
var tConvertCallsiteField = callSite.GetFieldEvenIfGeneric(convertGet);
var tReturnLocal = tIlGen.DeclareLocal(tGetReturnType);
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tConvertCallsiteField))) {
tIlGen.EmitDynamicConvertBinder(CSharpBinderFlags.None, tGetReturnType, contextType);
tIlGen.EmitCallsiteCreate(tConvertFuncType);
tIlGen.Emit(OpCodes.Stsfld, tConvertCallsiteField);
}
var tInvokeGetCallsiteField = callSite.GetFieldEvenIfGeneric(invokeGet);
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tInvokeGetCallsiteField))) {
tIlGen.EmitDynamicGetBinder(CSharpBinderFlags.None, name, contextType, indexParamTypes);
tIlGen.EmitCallsiteCreate(invokeGetFuncType);
tIlGen.Emit(OpCodes.Stsfld, tInvokeGetCallsiteField);
}
tIlGen.Emit(OpCodes.Ldsfld, tConvertCallsiteField);
tIlGen.Emit(OpCodes.Ldfld, tConvertCallsiteField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tConvertCallsiteField);
tIlGen.Emit(OpCodes.Ldsfld, tInvokeGetCallsiteField);
tIlGen.Emit(OpCodes.Ldfld, tInvokeGetCallsiteField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tInvokeGetCallsiteField);
tIlGen.Emit(OpCodes.Ldarg_0);
tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod());
for (var i = 1; i <= indexParamTypes.Length; i++) {
tIlGen.EmitLoadArgument(i);
}
tIlGen.EmitCallInvokeFunc(invokeGetFuncType);
tIlGen.EmitCallInvokeFunc(tConvertFuncType);
tIlGen.EmitStoreLocation(tReturnLocal.LocalIndex);
var tReturnLabel = tIlGen.DefineLabel();
tIlGen.Emit(OpCodes.Br_S, tReturnLabel);
tIlGen.MarkLabel(tReturnLabel);
tIlGen.EmitLoadLocation(tReturnLocal.LocalIndex);
tIlGen.Emit(OpCodes.Ret);
tMp.SetGetMethod(getMethodBuilder);
if (setMethod != null) {
MethodAttributes tPublicPrivate = MethodAttributes.Public;
var tPrefixedSet = setMethod.Name;
if (!defaultImp) {
tPublicPrivate = MethodAttributes.Private;
tPrefixedSet = String.Format("{0}.{1}", info.DeclaringType.FullName, tPrefixedSet);
}
var tSetMethodBuilder = typeBuilder.DefineMethod(tPrefixedSet,
tPublicPrivate | MethodAttributes.SpecialName |
MethodAttributes.HideBySig | MethodAttributes.Virtual |
MethodAttributes.Final | MethodAttributes.NewSlot,
null,
setParamTypes);
if (!defaultImp) {
typeBuilder.DefineMethodOverride(tSetMethodBuilder, info.GetSetMethod());
}
foreach (var tParam in info.GetSetMethod().GetParameters()) {
tSetMethodBuilder.DefineParameter(tParam.Position + 1, AttributesForParam(tParam), tParam.Name);
}
tIlGen = tSetMethodBuilder.GetILGenerator();
var tSetCallsiteField = callSite.GetFieldEvenIfGeneric(invokeSet);
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tSetCallsiteField))) {
tIlGen.EmitDynamicSetBinder(CSharpBinderFlags.None, name, contextType, setParamTypes);
tIlGen.EmitCallsiteCreate(invokeSetFuncType);
tIlGen.Emit(OpCodes.Stsfld, tSetCallsiteField);
}
tIlGen.Emit(OpCodes.Ldsfld, tSetCallsiteField);
tIlGen.Emit(OpCodes.Ldfld, tSetCallsiteField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tSetCallsiteField);
tIlGen.Emit(OpCodes.Ldarg_0);
tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod());
for (var i = 1; i <= setParamTypes.Length; i++) {
tIlGen.EmitLoadArgument(i);
}
tIlGen.EmitCallInvokeFunc(invokeSetFuncType);
tIlGen.Emit(OpCodes.Pop);
tIlGen.Emit(OpCodes.Ret);
tMp.SetSetMethod(tSetMethodBuilder);
}
}
private void createHashMethod(PropertyBuilder propBuild,TypeBuilder typeBuild,FieldBuilder hash)
{
// First, we'll define the behavior of the "get" property for Hash as a method.
MethodBuilder typeHashGet = typeBuild.DefineMethod("GetHash",
MethodAttributes.Public,
typeof(Hashtable),
new Type[] { });
ILGenerator ilg = typeHashGet.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldfld, hash);
ilg.Emit(OpCodes.Ret);
// Now, we'll define the behavior of the "set" property for Hash.
MethodBuilder typeHashSet = typeBuild.DefineMethod("SetHash",
MethodAttributes.Public,
null,
new Type[] { typeof(Hashtable) });
ilg = typeHashSet.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldarg_1);
ilg.Emit(OpCodes.Stfld, hash);
ilg.Emit(OpCodes.Ret);
// map the two methods created above to their property
propBuild.SetGetMethod(typeHashGet);
propBuild.SetSetMethod(typeHashSet);
//add the [Browsable(false)] property to the Hash property so it doesnt show up on the property list
ConstructorInfo ci = typeof(BrowsableAttribute).GetConstructor(new Type[]{typeof(bool)});
CustomAttributeBuilder cab = new CustomAttributeBuilder(ci,new object[]{false});
propBuild.SetCustomAttribute(cab);
}
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);
}
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);
}
/// <summary>
/// Creates the setter.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="propertyBuilder">The property builder.</param>
/// <param name="column">The column.</param>
private static void CreateSetter(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, SLDataColumn 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 EmitSetter(TypeBuilder proxyTypeBuilder, PropertyBuilder propertyBuilder, FieldBuilder self, PropertyInfo declaration, PropertyInfo delegatedProperty, Type propertyType, Type[] indexTypes)
{
var setter = declaration.GetSetMethod();
if (setter != null)
{
indexTypes = indexTypes.Concat(propertyType.AsSingleEnumerable()).ToArray();
var setterBuilder = proxyTypeBuilder.DefineMethod("set_" + declaration.Name, PropertyAttribute, null, indexTypes);
var generator = setterBuilder.GetILGenerator();
if (delegatedProperty == null)
{
generator.ThrowException(typeof(NotSupportedException));
}
else
{
var delegatedSetter = delegatedProperty.GetSetMethod();
EmitImplementation(generator, self, delegatedSetter, indexTypes);
propertyBuilder.SetSetMethod(setterBuilder);
}
}
}
