public void genVariable(Symbol s)
{
Emit.FieldBuilder fbuilder = typeBuilder.DefineField(s.Name, getSystemTypeFormat(s.Type),
Reflect.FieldAttributes.Private |
Reflect.FieldAttributes.Static);
fbuilderTable.Add(s.Name, fbuilder);
}
public static void MixinType (TypeBuilder typeBuilder,Type mixinInterfaceType,FieldBuilder mixinField)
{
MethodInfo[] methods = mixinInterfaceType.GetMethods();
foreach (MethodInfo method in methods)
MixinMethod(typeBuilder,method,mixinField);
}
private MethodBuilder DefineRaiseMethod(TypeBuilder builder, FieldBuilder addPropertyChangedField)
{
var notifyPropertyChangedMethod = builder.DefineMethod("NotifyPropertyChanged", MethodAttributes.Public | MethodAttributes.Virtual, typeof(void),
new [] {typeof (string)});
var il = notifyPropertyChangedMethod.GetILGenerator();
il.DeclareLocal(typeof (bool));
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, addPropertyChangedField);
il.Emit(OpCodes.Ceq);
il.Emit(OpCodes.Stloc_0);
il.Emit(OpCodes.Ldloc_0);
Label ifNullLabel = il.DefineLabel();
il.Emit(OpCodes.Brtrue_S, ifNullLabel);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, addPropertyChangedField);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Newobj, typeof (PropertyChangedEventArgs).GetConstructors().First());
il.Emit(OpCodes.Callvirt, typeof(PropertyChangedEventHandler).GetMethod("Invoke"));
il.MarkLabel(ifNullLabel);
il.Emit(OpCodes.Ret);
return notifyPropertyChangedMethod;
}
public AbstractProxyBuilder(ModuleBuilder moduleBuilder, string className, Type interfaceType, Type innerType)
{
Verify.ArgumentNotNull(moduleBuilder, "moduleBuilder");
Verify.ArgumentNotNull(className, "className");
Verify.ArgumentNotNull(interfaceType, "interfaceType");
Verify.ArgumentNotNull(innerType, "innerType");
if (!interfaceType.IsInterface) {
throw new ArgumentException("must be an interface type", "interfaceType");
}
_errorMessages = new List<string>();
_moduleBuilder = moduleBuilder;
_className = className;
_interfaceType = interfaceType;
_innerType = innerType;
_typeBuilder = _moduleBuilder.DefineType(
_className,
TypeAttributes.Public |
TypeAttributes.Class |
TypeAttributes.AutoClass |
TypeAttributes.AnsiClass |
TypeAttributes.BeforeFieldInit |
TypeAttributes.AutoLayout,
typeof(object),
new Type[] {_interfaceType});
_innerFieldBuilder = _typeBuilder.DefineField("inner", _innerType, FieldAttributes.Private);
}
public void Build(TypeBuilder typeBuilder, FieldBuilder injectionSetField, Type injectionType)
{
var parameterTypes = new[] { typeof(string) };
var methods = new Methods(typeBuilder, _methodName, parameterTypes);
var injectionMethod = injectionType.GetMethod(_methodName, new[] { typeof(BaseType), typeof(string) });
var il = methods.GetILGenerator(injectionType);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, methods.BaseMethod);
il.EmitGetInjections(injectionSetField, injectionType);
il.EmitInjectionLoop(x =>
{
x.Emit(OpCodes.Ldarg_0);
x.Emit(OpCodes.Ldarg_1);
x.Emit(OpCodes.Callvirt, injectionMethod);
});
il.Emit(OpCodes.Ret);
}
public void Build(TypeBuilder typeBuilder, FieldBuilder injectionSetField, Type injectionType)
{
var parameterTypes = new[] { typeof(DbModelBuilder), typeof(DbContext) };
var methods = new Methods(typeBuilder, MethodName, new[] { typeof(DbModelBuilder) });
var injectionMethod = ReflectionHelper.GetMethod(injectionType, MethodName, BindingFlags.Instance | BindingFlags.Public, parameterTypes);
var il = methods.GetILGenerator(injectionType);
DeclareLocals(injectionType, il);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, methods.BaseMethod);
il.EmitGetInjections(injectionSetField, injectionType);
il.EmitInjectionLoop(x =>
{
x.Emit(OpCodes.Ldarg_1);
x.Emit(OpCodes.Ldarg_0);
x.Emit(OpCodes.Callvirt, injectionMethod);
ConfigureDbSets(typeBuilder, x);
});
il.Emit(OpCodes.Ret);
}
private static void EmitInitField(ILGenerator il, FieldBuilder fb, Type type)
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldtoken, type);
il.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"));
il.Emit(OpCodes.Stfld, fb);
}
public SwitchCase(TypeContainer elemType, string elemName, object[] discriminatorValues,
FieldBuilder elemField) {
m_elemType = elemType;
m_elemName = elemName;
m_elemField = elemField;
m_discriminatorValues = discriminatorValues;
}
public void ImplementProxy(TypeBuilder typeBuilder)
{
typeBuilder.AddInterfaceImplementation(typeof (IProxy));
InterceptorField = typeBuilder
.DefineField("__interceptor",
typeof (Proxy.DynamicProxy.IInterceptor),
FieldAttributes.Private);
var getterMethod = typeBuilder
.DefineMethod("get_Interceptor",
InterceptorMethodsAttributes,
CallingConventions.HasThis,
typeof (Proxy.DynamicProxy.IInterceptor),
new System.Type[0]);
getterMethod.SetImplementationFlags(MethodImplAttributes.IL);
var il = getterMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, InterceptorField);
il.Emit(OpCodes.Ret);
var setterMethod = typeBuilder
.DefineMethod("set_Interceptor",
InterceptorMethodsAttributes,
CallingConventions.HasThis,
typeof (void),
new[] {typeof (Proxy.DynamicProxy.IInterceptor)});
setterMethod.SetImplementationFlags(MethodImplAttributes.IL);
il = setterMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, InterceptorField);
il.Emit(OpCodes.Ret);
var originalSetter = typeof (IProxy).GetMethod("set_Interceptor");
var originalGetter = typeof (IProxy).GetMethod("get_Interceptor");
typeBuilder.DefineMethodOverride(setterMethod, originalSetter);
typeBuilder.DefineMethodOverride(getterMethod, originalGetter);
}
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 InterfaceImplementation(
TypeBuilder typeBuilder,
Type @interface,
FieldBuilder proxyInterceptionPipelineField,
bool explicitImplementation)
: this(typeBuilder, @interface, proxyInterceptionPipelineField, explicitImplementation, null)
{ }
public TargetedInvocationMethodGenerator(
TargetedMethodMetadata methodMetadata,
FieldBuilder targetField)
{
_methodMetadata = methodMetadata;
_targetField = targetField;
}
public void ImplementProxy(TypeBuilder typeBuilder)
{
// Implement the IProxy interface
typeBuilder.AddInterfaceImplementation(typeof (IProxy));
field = typeBuilder.DefineField("__interceptor", typeof (IInterceptor), FieldAttributes.Private);
// Implement the getter
MethodBuilder getterMethod = typeBuilder.DefineMethod("get_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof(IInterceptor), new System.Type[0]);
getterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL);
ILGenerator IL = getterMethod.GetILGenerator();
// This is equivalent to:
// get { return __interceptor;
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Ldfld, field);
IL.Emit(OpCodes.Ret);
// Implement the setter
MethodBuilder setterMethod = typeBuilder.DefineMethod("set_Interceptor", InterceptorMethodsAttributes, CallingConventions.HasThis, typeof (void), new[] {typeof (IInterceptor)});
setterMethod.SetImplementationFlags(MethodImplAttributes.Managed | MethodImplAttributes.IL);
IL = setterMethod.GetILGenerator();
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Ldarg_1);
IL.Emit(OpCodes.Stfld, field);
IL.Emit(OpCodes.Ret);
MethodInfo originalSetter = typeof (IProxy).GetMethod("set_Interceptor");
MethodInfo originalGetter = typeof (IProxy).GetMethod("get_Interceptor");
typeBuilder.DefineMethodOverride(setterMethod, originalSetter);
typeBuilder.DefineMethodOverride(getterMethod, originalGetter);
}
public override MethodGenerator CreateGenerator(
FieldMetadataFieldBuilderMap instanceFieldBuilders,
MethodMetadataFieldBuilderMap methodMetadataFieldBuilders,
FieldBuilder dispatcherField)
{
return new DuckTypeMethodGenerator(this);
}
private FieldInfo[] GenerateProperties( TypeBuilder tb , DynamicProperty[] properties ) {
FieldInfo[] fields = new FieldBuilder[properties.Length];
for ( int i = 0 ; i < properties.Length ; i++ ) {
DynamicProperty dp = properties[i];
FieldBuilder fb = tb.DefineField( "_" + dp.Name , dp.Type , FieldAttributes.Private );
PropertyBuilder pb = tb.DefineProperty( dp.Name , PropertyAttributes.HasDefault , dp.Type , null );
MethodBuilder mbGet = tb.DefineMethod( "get_" + dp.Name ,
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig ,
dp.Type , Type.EmptyTypes );
ILGenerator genGet = mbGet.GetILGenerator();
genGet.Emit( OpCodes.Ldarg_0 );
genGet.Emit( OpCodes.Ldfld , fb );
genGet.Emit( OpCodes.Ret );
MethodBuilder mbSet = tb.DefineMethod( "set_" + dp.Name ,
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig ,
null , new[] { dp.Type } );
ILGenerator genSet = mbSet.GetILGenerator();
genSet.Emit( OpCodes.Ldarg_0 );
genSet.Emit( OpCodes.Ldarg_1 );
genSet.Emit( OpCodes.Stfld , fb );
genSet.Emit( OpCodes.Ret );
pb.SetGetMethod( mbGet );
pb.SetSetMethod( mbSet );
fields[i] = fb;
}
return fields;
}
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);
}
public override void Declare(ILGenerator ilGenerator)
{
fieldBuilder =
enumerator.DefineField("__local" + index + "_" + Name,
LocalType.RawType,
FieldAttributes.Private);
}
internal MethodOverride(
TypeBuilder typeBuilder,
FieldBuilder proxyInterceptionPipelineField,
MethodInfo methodToOverride,
Type targetType,
GenericParameterMapper targetTypeParameterMapper,
int overrideCount)
{
this.typeBuilder = typeBuilder;
this.proxyInterceptionPipelineField = proxyInterceptionPipelineField;
this.methodToOverride = methodToOverride;
this.methodParameters = methodToOverride.GetParameters();
this.targetType = targetType;
// if the method is inherited and the declaring type is generic, we need to map
// the parameters of the original declaration to the actual intercepted type type
// E.g. consider given class Type1<T> with virtual method "T Method<U>()", the mappings in
// different scenarios would look like:
// Type2<S> : Type2<S> => S Method<U>()
// Type2<S> : Type2<IEnumerable<S>> => IEnumerable<S> Method<U>()
// Type2 : Type1<IEnumerable<string>> => IEnumerable<string> Method<U>()
var declaringType = methodToOverride.DeclaringType;
this.targetTypeParameterMapper =
declaringType.IsGenericType && declaringType != methodToOverride.ReflectedType
? new GenericParameterMapper(declaringType, targetTypeParameterMapper)
: targetTypeParameterMapper;
this.overrideCount = overrideCount;
}
public void Build(TypeBuilder typeBuilder, FieldBuilder injectionSetField, Type injectionType)
{
var parameterTypes = new[] { typeof(DbEntityEntry), typeof(IDictionary<object, object>) };
var returnType = typeof(DbEntityValidationResult);
var methods = new Methods(typeBuilder, MethodName, parameterTypes, returnType);
var injectionMethod = injectionType.GetMethod("On" + MethodName, new[] { returnType, parameterTypes[0], parameterTypes[1] });
var il = methods.GetILGenerator(injectionType);
// declare result variable
il.DeclareLocal(typeof(DbEntityValidationResult));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Call, methods.BaseMethod);
il.Emit(OpCodes.Stloc_3);
il.EmitGetInjections(injectionSetField, injectionType);
il.EmitInjectionLoop(x =>
{
x.Emit(OpCodes.Ldloc_3);
x.Emit(OpCodes.Ldarg_1);
x.Emit(OpCodes.Ldarg_2);
x.Emit(OpCodes.Callvirt, injectionMethod);
});
il.Emit(OpCodes.Ldloc_3);
il.Emit(OpCodes.Ret);
}
private static void BuildConstructor(TypeBuilder proxyBuilder, Type proxyType,
FieldBuilder wrappedType, FieldBuilder invokeHandlers, TypeDebugging debug)
{
var arguments = new Type[] { proxyType, typeof(IInvocationHandler[]) };
var constructor = proxyBuilder.DefineConstructor(
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig,
CallingConventions.Standard, arguments);
using (var generator = debug.GetMethodDebugging(constructor))
{
// Call the base constructor.
generator.Emit(OpCodes.Ldarg_0);
var objectCtor = proxyType.GetConstructor(Type.EmptyTypes);
generator.Emit(OpCodes.Call, objectCtor);
// Store the target object.
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Stfld, wrappedType);
// Store the handlers.
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_2);
generator.Emit(OpCodes.Stfld, invokeHandlers);
generator.Emit(OpCodes.Ret);
}
}
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;
}
public InterfaceImplementation(
TypeBuilder typeBuilder,
Type @interface,
GenericParameterMapper genericParameterMapper,
FieldBuilder proxyInterceptionPipelineField,
bool explicitImplementation,
FieldBuilder targetField)
{
this.typeBuilder = typeBuilder;
this.@interface = @interface;
this.genericParameterMapper = genericParameterMapper;
this.proxyInterceptionPipelineField = proxyInterceptionPipelineField;
this.explicitImplementation = explicitImplementation;
this.targetField = targetField;
if (@interface.IsGenericType)
{
// when the @interface is generic we need to get references to its methods though it
// in this case, the targetInterface is a constructed version using the generic type parameters
// from the generated type generate type
var definition = @interface.GetGenericTypeDefinition();
var mappedParameters = definition.GetGenericArguments().Select(t => genericParameterMapper.Map(t)).ToArray();
this.targetInterface = definition.MakeGenericType(mappedParameters);
}
else
{
this.targetInterface = @interface;
}
}
public void ImplementDisposalBehavior()
{
// IL: Prepare "disposingEventHandler" and "disposed" fields
disposingEventHandlerField = target.DefineField("disposingEventHandler", typeof (EventHandler), FieldAttributes.Private);
disposedField = target.DefineField("disposed", typeof(bool), FieldAttributes.Private);
target.DefineMethodOverride(GetDisposeMethodBody(), typeof(IDisposable).GetMethod("Dispose", new Type[] {}));
}
internal static void Build(TypeBuilder proxyBuilder, Type proxyType,
FieldBuilder wrappedObject, FieldBuilder invokeHandlers, TypeDebugging debug)
{
ProxyConstructorBuilder.BuildParameterlessConstructor(
proxyBuilder, proxyType, debug);
ProxyConstructorBuilder.BuildConstructor(
proxyBuilder, proxyType, wrappedObject, invokeHandlers, debug);
}
/// <summary>
/// First local variable should be injectionType.MakeArrayType() type.
/// </summary>
/// <remarks> Parameters not checked.</remarks>
public static void EmitGetInjections(this ILGenerator il, FieldBuilder injectionSetField, Type injectionType)
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, injectionSetField);
il.Emit(OpCodes.Callvirt, typeof(InjectionSet).GetMethod(GetInjectionsName, EmptyParameters).MakeGenericMethod(new[] { injectionType }));
il.Emit(OpCodes.Stloc_0);
}
internal MethodOverride(TypeBuilder typeBuilder, FieldBuilder proxyInterceptionPipelineField, MethodInfo methodToOverride, int overrideCount)
{
this.typeBuilder = typeBuilder;
this.proxyInterceptionPipelineField = proxyInterceptionPipelineField;
this.methodToOverride = methodToOverride;
this.methodParameters = methodToOverride.GetParameters();
this.overrideCount = overrideCount;
}
public override MethodGenerator CreateGenerator(
FieldMetadataFieldBuilderMap instanceFieldBuilders,
MethodMetadataFieldBuilderMap methodMetadataFieldBuilders,
FieldBuilder dispatcherField)
{
var methodInfoField = methodMetadataFieldBuilders[this];
return new ClassMethodGenerator(this, dispatcherField, methodInfoField);
}
public InterfaceImplementation(
TypeBuilder typeBuilder,
Type @interface,
FieldBuilder proxyInterceptionPipelineField,
bool explicitImplementation,
FieldBuilder targetField)
: this(typeBuilder, @interface, GenericParameterMapper.DefaultMapper, proxyInterceptionPipelineField, explicitImplementation, targetField)
{
}
internal EnumBuilder (ModuleBuilder mb, string name, TypeAttributes visibility, Type underlyingType)
{
_tb = new TypeBuilder (mb, name, (visibility | TypeAttributes.Sealed),
typeof(Enum), null, PackingSize.Unspecified, 0, null);
_underlyingType = underlyingType;
_underlyingField = _tb.DefineField ("value__", underlyingType,
(FieldAttributes.SpecialName | FieldAttributes.Private | FieldAttributes.RTSpecialName));
setup_enum_type (_tb);
}
protected override TypeBuilder CreateTypeBuilder(string name, Type baseType)
{
TypeBuilder typeBuilder = DynamicProxyManager.CreateTypeBuilder(name, baseType);
objectFactoryField = typeBuilder.DefineField("__objectFactory", typeof(IObjectFactory),
FieldAttributes.Private | FieldAttributes.Static | FieldAttributes.InitOnly);
return typeBuilder;
}
public StaticGlobalAllocator(LanguageContext/*!*/ context, string name) {
_typeGen = Snippets.Shared.DefineType(name, typeof(object), false, false);
_codeContextField = _typeGen.AddStaticField(typeof(CodeContext), "__global_context");
_codeContext = CreateFieldBuilderExpression(_codeContextField);
_scope = new Scope(new PythonDictionary(new GlobalDictionaryStorage(_globalVals)));
_context = new CodeContext(_scope, context);
}
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);
}
/// <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());
}
