private Assembly Generate()
{
var assemblyPath = Path.GetDirectoryName(this.assembly.Location);
var trees = new ConcurrentBag<SyntaxTree>();
var allowUnsafe = false;
Parallel.ForEach(assembly.GetExportedTypes()
.Where(_ => string.IsNullOrWhiteSpace(_.Validate(this.options.Serialization, new AssemblyNameGenerator(_))) && !typeof(Array).IsAssignableFrom(_) &&
!typeof(Enum).IsAssignableFrom(_) && !typeof(ValueType).IsAssignableFrom(_) &&
!typeof(Delegate).IsAssignableFrom(_)), _ =>
{
var builder = new AssemblyBuilder(_,
new ReadOnlyDictionary<int, ReadOnlyCollection<HandlerInformation>>(
new Dictionary<int, ReadOnlyCollection<HandlerInformation>>()),
new SortedSet<string>(), this.options);
builder.Build();
trees.Add(builder.Tree);
allowUnsafe |= builder.IsUnsafe;
});
var referencedAssemblies = this.assembly.GetReferencedAssemblies().Select(_ => Assembly.Load(_)).ToList();
referencedAssemblies.Add(this.assembly);
var compiler = new AssemblyCompiler(trees, this.options.Optimization,
new AssemblyNameGenerator(this.assembly).AssemblyName,
referencedAssemblies.AsReadOnly(), currentDirectory, allowUnsafe, this.options.AllowWarnings);
compiler.Compile();
return compiler.Result;
}
public AssemblyResultTests()
{
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = assembly;
AppDomain appDomain = Thread.GetDomain();
builder = appDomain.DefineDynamicAssembly(assemblyName,
AssemblyBuilderAccess.RunAndSave);
}
/// <summary>
/// 构建一个可保存的动态程序集 ModuleScope 模块
/// </summary>
/// <param name="assemblySaveDir">程序集保存的目录</param>
public ModuleScope(String assemblySaveDir)
{
if (assemblySaveDir != null && !Directory.Exists(assemblySaveDir))
{
throw new DirectoryNotFoundException(assemblySaveDir);
}
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(NameOfAssembly), AssemblyBuilderAccess.RunAndSave, assemblySaveDir);
ModuleBuilder = _assemblyBuilder.DefineDynamicModule(NameOfAssembly, AssemblyFileName);
SavePhysicalAssembly = true;
}
static object Create (AssemblyBuilder ab, string typeName, Type baseType)
{
ModuleBuilder mb = ab.DefineDynamicModule (ab.GetName ().Name + ".dll");
TypeBuilder tb = mb.DefineType (typeName, TypeAttributes.Public, baseType);
tb.SetCustomAttribute (new CustomAttributeBuilder (
typeof (SerializableAttribute).GetConstructor (
Type.EmptyTypes), new object [0]));
Type emittedType = tb.CreateType ();
return Activator.CreateInstance (emittedType);
}
protected static void SetUp ()
{
AssemblyName assemblyName = new AssemblyName ();
assemblyName.Name = ASSEMBLY_NAME;
assembly =
Thread.GetDomain ().DefineDynamicAssembly (
assemblyName, AssemblyBuilderAccess.RunAndSave, Path.GetTempPath ());
module = assembly.DefineDynamicModule ("module1");
}
public CodeGen(Stmt stmt, string moduleName)
{
if (string.IsNullOrEmpty(moduleName)) throw new ArgumentException("must have a module name", "moduleName");
_stmt = stmt;
_moduleName = moduleName;
if (Path.GetFileName(moduleName) != moduleName) throw new Exception("can only output into current directory!");
var filename = Path.GetFileNameWithoutExtension(moduleName);
var asmName = new AssemblyName(filename);
_asmb = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Save);
_modb = _asmb.DefineDynamicModule(moduleName);
_typeBuilder = _modb.DefineType("Foo");
_methb = _typeBuilder.DefineMethod("Main", MethodAttributes.Static, typeof(void),
Type.EmptyTypes);
_il = _methb.GetILGenerator();
SymbolTable = new Dictionary<string, LocalBuilder>();
}
static HugsWrapper()
{
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = "HugsAssembly";
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.AssemblyResolve += new ResolveEventHandler(Resolver);
assemblyBuilder =
currentDomain.DefineDynamicAssembly(assemblyName,
AssemblyBuilderAccess.Run,//AssemblyBuilderAccess.RunAndSave,
(String)null);
moduleBuilder =
assemblyBuilder.DefineDynamicModule("HugsModule");
// assemblyBuilder.DefineDynamicModule("HugsModule", "test.dll");
hugs = new Server();
uniq = 0;
}
private void CreateAssemblyBuilder()
{
AppDomain myDomain = AppDomain.CurrentDomain;
assemblyBuilder = myDomain.DefineDynamicAssembly(CreateAssemblyName(), AssemblyBuilderAccess.RunAndSave, Path.GetDirectoryName(outputPath));
}
public object CreateDynamicType()
{
var assemblyName = new AssemblyName {
Name = "tmpAssembly"
};
#if NETCORE
var typeBuilder =
AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
.DefineDynamicModule("tmpModule")
.DefineType("SqlBuilderDynamicParameters", TypeAttributes.Public | TypeAttributes.Class);
#else
var typeBuilder =
Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
.DefineDynamicModule("tmpModule")
.DefineType("SqlBuilderDynamicParameters", TypeAttributes.Public | TypeAttributes.Class);
#endif
var emptyCtor = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
var ctorIL = emptyCtor.GetILGenerator();
var unsetValues = new List <Property>();
// Loop over the attributes that will be used as the properties names in out new type
foreach (var p in properties)
{
// Generate a private field
var field = typeBuilder.DefineField("_" + p.Name, p.Type, FieldAttributes.Private);
//set default values with Emit for popular types
if (p.Type == typeof(int))
{
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldc_I4, (int)p.Value);
ctorIL.Emit(OpCodes.Stfld, field);
}
else if (p.Type == typeof(long))
{
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldc_I8, (long)p.Value);
ctorIL.Emit(OpCodes.Stfld, field);
}
else if (p.Type == typeof(string))
{
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldstr, (string)p.Value);
ctorIL.Emit(OpCodes.Stfld, field);
}
else
{
unsetValues.Add(p); //otherwise use reflection
}
// Generate a public property
var property = typeBuilder.DefineProperty(p.Name, PropertyAttributes.None, p.Type, new[] { p.Type });
// Define the "get" accessor method for current private field.
var currGetPropMthdBldr = typeBuilder.DefineMethod("get_" + p.Name, GetSetAttr, p.Type, Type.EmptyTypes);
// Get Property impl
var 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.
var currSetPropMthdBldr = typeBuilder.DefineMethod("set_" + p.Name, GetSetAttr, null, new[] { p.Type });
// Set Property impl
var currSetIL = currSetPropMthdBldr.GetILGenerator();
currSetIL.Emit(OpCodes.Ldarg_0);
currSetIL.Emit(OpCodes.Ldarg_1);
currSetIL.Emit(OpCodes.Stfld, field);
currSetIL.Emit(OpCodes.Ret);
// Hook up, getters and setters.
property.SetGetMethod(currGetPropMthdBldr);
property.SetSetMethod(currSetPropMthdBldr);
}
ctorIL.Emit(OpCodes.Ret);
#if NETCORE
var generetedType = typeBuilder.CreateTypeInfo().AsType();
#else
var generetedType = typeBuilder.CreateType();
#endif
var instance = Activator.CreateInstance(generetedType);
//Using reflection for less property types. Not caching since it's a generated type.
foreach (var p in unsetValues)
{
generetedType.GetProperty(p.Name).GetSetMethod().Invoke(instance, new[] { p.Value });
}
return(instance);
}
/// <summary>
/// 动态生成接口的实现类
/// </summary>
/// <param name="interfaceType"></param>
/// <param name="constructor"></param>
/// <returns></returns>
private Type BuildTargetType(Type interfaceType, params object[] constructor)
{
targetType = interfaceType;
string assemblyName = targetType.Name + "ProxyAssembly";
string moduleName = targetType.Name + "ProxyModule";
string typeName = targetType.Name + "Proxy";
AssemblyName assyName = new AssemblyName(assemblyName);
AssemblyBuilder assyBuilder = AssemblyBuilder.DefineDynamicAssembly(assyName, AssemblyBuilderAccess.Run);
ModuleBuilder modBuilder = assyBuilder.DefineDynamicModule(moduleName);
//新类型的属性
TypeAttributes newTypeAttribute = TypeAttributes.Class | TypeAttributes.Public;
//父类型
Type parentType;
//要实现的接口
Type[] interfaceTypes;
if (targetType.IsInterface)
{
parentType = typeof(object);
interfaceTypes = new Type[] { targetType };
}
else
{
parentType = targetType;
interfaceTypes = Type.EmptyTypes;
}
//得到类型生成器
TypeBuilder typeBuilder = modBuilder.DefineType(typeName, newTypeAttribute, parentType, interfaceTypes);
//定义一个字段存放httpService
var httpType = typeof(HttpService);
FieldBuilder httpServiceField = typeBuilder.DefineField("httpService",
httpType, FieldAttributes.Public);
//定义一个字段存放IServiceProvider
var iServiceProviderType = typeof(IServiceProvider);
FieldBuilder serviceProviderField = typeBuilder.DefineField("iServiceProvider",
iServiceProviderType, FieldAttributes.Public);
//定义一个集合存放参数集合
FieldBuilder paramterArrField = typeBuilder.DefineField("paramterArr",
typeof(List <object>), FieldAttributes.Public);
//创建构造函数
ConstructorBuilder constructorBuilder =
typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { httpType, iServiceProviderType });
//il创建构造函数，对httpService和IServiceProvider两个字段进行赋值，同时初始化存放参数的集合
ILGenerator ilgCtor = constructorBuilder.GetILGenerator();
ilgCtor.Emit(OpCodes.Ldarg_0); //加载当前类
ilgCtor.Emit(OpCodes.Ldarg_1);
ilgCtor.Emit(OpCodes.Stfld, httpServiceField);
ilgCtor.Emit(OpCodes.Ldarg_0); //加载当前类
ilgCtor.Emit(OpCodes.Ldarg_2);
ilgCtor.Emit(OpCodes.Stfld, serviceProviderField);
ilgCtor.Emit(OpCodes.Ldarg_0); //加载当前类
ilgCtor.Emit(OpCodes.Newobj, typeof(List <object>).GetConstructors().First());
ilgCtor.Emit(OpCodes.Stfld, paramterArrField);
ilgCtor.Emit(OpCodes.Ret); //返回
MethodInfo[] targetMethods = targetType.GetMethods();
foreach (MethodInfo targetMethod in targetMethods)
{
//只挑出virtual的方法
if (targetMethod.IsVirtual)
{
//缓存接口的方法体，便于后续将方法体传递给httpService
string methodKey = Guid.NewGuid().ToString();
MethodsCache[methodKey] = targetMethod;
//得到方法的各个参数的类型和参数
var paramInfo = targetMethod.GetParameters();
var parameterType = paramInfo.Select(it => it.ParameterType).ToArray();
var returnType = targetMethod.ReturnType;
//方法返回值只能是task，即只支持异步，因为http操作是io操作
if (!typeof(Task).IsAssignableFrom(returnType))
{
throw new Exception("return type must be task<>");
}
var underType = returnType.IsGenericType ? returnType.GetGenericArguments().First() : returnType;
//通过emit生成方法体
MethodBuilder methodBuilder = typeBuilder.DefineMethod(targetMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual, targetMethod.ReturnType, parameterType);
ILGenerator ilGen = methodBuilder.GetILGenerator();
MethodInfo executeMethod = null;
var methodTmp = httpType.GetMethod("ExecuteAsync");
if (methodTmp == null)
{
throw new Exception("找不到执行方法");
}
executeMethod = methodTmp.IsGenericMethod ? methodTmp.MakeGenericMethod(underType) : methodTmp;
// 栈底放这玩意，加载字段前要加载类实例，即Ldarg_0
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, httpServiceField);
//把所有参数都放到list<object>里
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, paramterArrField);
for (int i = 0; i < parameterType.Length; i++)
{
ilGen.Emit(OpCodes.Dup);
ilGen.Emit(OpCodes.Ldarg_S, i + 1);
if (parameterType[i].IsValueType)
{
ilGen.Emit(OpCodes.Box, parameterType[i]);
}
ilGen.Emit(OpCodes.Callvirt, typeof(List <object>).GetMethod("Add"));
}
// 当前栈[httpServiceField paramterArrField]
//从缓存里取出方法体
ilGen.Emit(OpCodes.Call,
typeof(FeignProxyBuilder).GetMethod("get_MethodsCache", BindingFlags.Static | BindingFlags.Public));
ilGen.Emit(OpCodes.Ldstr, methodKey);
ilGen.Emit(OpCodes.Call, typeof(Dictionary <string, MethodInfo>).GetMethod("get_Item"));
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, serviceProviderField);
ilGen.Emit(OpCodes.Callvirt, executeMethod);
//清空list里的参数
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, paramterArrField);
ilGen.Emit(OpCodes.Callvirt, typeof(List <object>).GetMethod("Clear"));
// pop the stack if return void
if (targetMethod.ReturnType == typeof(void))
{
ilGen.Emit(OpCodes.Pop);
}
// complete
ilGen.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(methodBuilder, targetMethod);
}
}
var resultType = typeBuilder.CreateTypeInfo().AsType();
return(resultType);
}
public TypeHelper(Type type)
{
_builder = AssemblyBuilder
.DefineDynamicAssembly(new AssemblyName(type.Assembly.GetName().Name), AssemblyBuilderAccess.Run)
.DefineDynamicModule(type.Module.Name);
}
private bool InitializeTDxInputWrapper()
{
bool bReturn = false;
Object typeLib = null;
try
{
//get Com-Server from Registry
RegistryKey regKey
= Registry.LocalMachine.OpenSubKey("Software\\Classes\\CLSID\\{82C5AB54-C92C-4D52-AAC5-27E25E22604C}\\InprocServer32", false);
if (regKey != null)
{
string strTypeLibName = regKey.GetValue("").ToString();
regKey.Close();
LoadTypeLibEx(strTypeLibName
, RegKind.RegKind_None
, out typeLib);
}
else
{
// --- No registry set, there must be no 3DConnexion ---
return false;
}
}
catch (Exception)
{
}
if (typeLib == null)
{
Console.WriteLine("LoadTypeLibEx failed.");
throw new NotSupportedException("Com- Server not found.");
}
TypeLibConverter converter = new TypeLibConverter();
ConversionEventHandler eventHandler = new ConversionEventHandler();
m_Assembly = converter.ConvertTypeLibToAssembly(typeLib, "Import3DxInputAssembly.dll", 0, eventHandler, null, null, null, null);
//Type[] ExpTypes = m_Assembly.GetTypes();
try
{
m_OSimpleDevice = m_Assembly.CreateInstance("Import3DxInputAssembly.DeviceClass");
}
catch
{
//int nTest;
}
if (m_OSimpleDevice != null)
{
Type TheType = m_OSimpleDevice.GetType();
//MethodInfo[] TheMethods = TheType.GetMethods();
MethodInfo method = TheType.GetMethod("get_Sensor");
m_OSensor = method.Invoke(m_OSimpleDevice, null); // kein Parameter
method = TheType.GetMethod("get_Keyboard");
m_OKeyboard = method.Invoke(m_OSimpleDevice, null);
TheType = m_OKeyboard.GetType();
//TheMethods = TheType.GetMethods();
bReturn = true;
}
return bReturn;
}
internal override void Apply(ClassLoaderWrapper loader, AssemblyBuilder ab, object annotation)
{
}
internal static void RegisterForSaveDebug(AssemblyBuilder ab)
{
if(saveDebugAssemblies == null)
{
saveDebugAssemblies = new List<AssemblyBuilder>();
}
saveDebugAssemblies.Add(ab);
}
static LinqRuntimeTypeBuilder()
{
moduleBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run)
.DefineDynamicModule(assemblyName.Name);
}
private Type EmitHelperClass(string HandlerName, EventInfo Info)
{
if (helperModule == null)
{
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = assemblyName + "Helper";
asmBuilder = Thread.GetDomain().DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
helperModule = asmBuilder.DefineDynamicModule(assemblyName + "Module", true);
}
//////////////////////////////////////////////////////////////////////////
// Define Type
//////////////////////////////////////////////////////////////////////////
TypeBuilder helperTypeBld = helperModule.DefineType(HandlerName + "Helper", TypeAttributes.Public);
// Define fields
FieldBuilder typeField = helperTypeBld.DefineField("eventType", typeof(Type), FieldAttributes.Private);
FieldBuilder eventField = helperTypeBld.DefineField("CommonEvent", typeof(CommonEventHandlerDlgt), FieldAttributes.Private);
EventBuilder commonEvent = helperTypeBld.DefineEvent("CommonEvent", EventAttributes.None, typeof(CommonEventHandlerDlgt));
//////////////////////////////////////////////////////////////////////////
// Build Constructor
//////////////////////////////////////////////////////////////////////////
Type objType = Type.GetType("System.Object");
ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);
// Build constructor with arguments (Type)
Type[] ctorParams = new Type[] { typeof(EventInfo) };
ConstructorBuilder ctor = helperTypeBld.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctorParams);
// Call constructor of base class
ILGenerator ctorIL = ctor.GetILGenerator();
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Call, objCtor);
// store first argument to typeField
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_1);
ctorIL.Emit(OpCodes.Stfld, typeField);
// return
ctorIL.Emit(OpCodes.Ret);
// Now constructor is finished!
//////////////////////////////////////////////////////////////////////////
// Build customized event handler
//////////////////////////////////////////////////////////////////////////
string eventName = Info.Name;
Type ehType = Info.EventHandlerType;
MethodInfo mi = ehType.GetMethod("Invoke");
ParameterInfo[] eventParams = mi.GetParameters();
// Build the type list of the parameter
int paramCount = eventParams.Length;
Type[] invokeParams = new Type[paramCount];
for (int i = 0; i < paramCount; i++)
{
invokeParams[i] = eventParams[i].ParameterType;
}
string methodName = "CustomEventHandler";
MethodAttributes attr = MethodAttributes.Public | MethodAttributes.HideBySig;
MethodBuilder invokeMthd = helperTypeBld.DefineMethod(methodName, attr, typeof(void), invokeParams);
// A ILGenerator can now be spawned, attached to the MethodBuilder.
ILGenerator ilGen = invokeMthd.GetILGenerator();
// Create Label before return
Label endOfMethod = ilGen.DefineLabel();
// Create a local variable of type ‘string’, and call it ‘args’
LocalBuilder localObj = ilGen.DeclareLocal(typeof(object[]));
localObj.SetLocalSymInfo("args"); // Provide name for the debugger.
// create object array of proper length
ilGen.Emit(OpCodes.Ldc_I4, paramCount);
ilGen.Emit(OpCodes.Newarr, typeof(object));
ilGen.Emit(OpCodes.Stloc_0);
// Now put all arguments in the object array
for (int i = 0; i < paramCount; i++)
{
byte i1b = Convert.ToByte(i + 1);
ilGen.Emit(OpCodes.Ldloc_0);
ilGen.Emit(OpCodes.Ldc_I4, i);
ilGen.Emit(OpCodes.Ldarg_S, i1b);
// Is argument value type?
if (invokeParams[i].IsValueType)
{
// Box the value type
ilGen.Emit(OpCodes.Box, invokeParams[i]);
}
// Put the argument in the object array
ilGen.Emit(OpCodes.Stelem_Ref);
}
// raise common event
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, eventField);
ilGen.Emit(OpCodes.Brfalse_S, endOfMethod);
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, eventField);
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, typeField);
ilGen.Emit(OpCodes.Ldloc_0);
MethodInfo raiseEventMethod = typeof(CommonEventHandlerDlgt).GetMethod("Invoke", BindingFlags.Public | BindingFlags.Instance);
if (raiseEventMethod == null)
{
throw new ApplicationException("CommonEventHandlerDlg:Invoke not found");
}
ilGen.Emit(OpCodes.Callvirt, raiseEventMethod);
// return
ilGen.MarkLabel(endOfMethod);
ilGen.Emit(OpCodes.Ret);
//////////////////////////////////////////////////////////////////////////
// add_CommonEvent
//////////////////////////////////////////////////////////////////////////
methodName = "add_CommonEvent";
attr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
invokeParams = new Type[1];
invokeParams[0] = typeof(CommonEventHandlerDlgt);
MethodBuilder addMethod = helperTypeBld.DefineMethod(methodName, attr, typeof(void), invokeParams);
ilGen = addMethod.GetILGenerator();
// define code
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, eventField);
ilGen.Emit(OpCodes.Ldarg_1);
Type[] combineTypes = new Type[] { typeof(Delegate), typeof(Delegate) };
MethodInfo combineMtd = typeof(Delegate).GetMethod("Combine", combineTypes);
if (combineMtd == null)
{
throw new ApplicationException("Delegate:Combine not found");
}
ilGen.Emit(OpCodes.Call, combineMtd);
ilGen.Emit(OpCodes.Castclass, typeof(CommonEventHandlerDlgt));
ilGen.Emit(OpCodes.Stfld, eventField);
ilGen.Emit(OpCodes.Ret);
// Set add method
commonEvent.SetAddOnMethod(addMethod);
//////////////////////////////////////////////////////////////////////////
// remove_CommonEvent
//////////////////////////////////////////////////////////////////////////
methodName = "remove_CommonEvent";
attr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
invokeParams = new Type[1];
invokeParams[0] = typeof(CommonEventHandlerDlgt);
MethodBuilder removeMethod = helperTypeBld.DefineMethod(methodName, attr, typeof(void), invokeParams);
ilGen = removeMethod.GetILGenerator();
// define code
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, eventField);
ilGen.Emit(OpCodes.Ldarg_1);
MethodInfo removeMtd = typeof(Delegate).GetMethod("Remove", combineTypes);
if (removeMtd == null)
{
throw new ApplicationException("Delegate:Remove not found");
}
ilGen.Emit(OpCodes.Call, removeMtd);
ilGen.Emit(OpCodes.Castclass, typeof(CommonEventHandlerDlgt));
ilGen.Emit(OpCodes.Stfld, eventField);
ilGen.Emit(OpCodes.Ret);
// Set remove method
commonEvent.SetRemoveOnMethod(removeMethod);
//////////////////////////////////////////////////////////////////////////
// Now event handler is finished!
//////////////////////////////////////////////////////////////////////////
return(helperTypeBld.CreateType());
}
public static object CreateType()
{
AssemblyName assemblyName = new AssemblyName("assemblyName");
AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("PersonModule", "Person.dll", true);
TypeBuilder typeBuilder = moduleBuilder.DefineType("Person", TypeAttributes.Public);
// 添加私有字段
FieldBuilder fbNumber = typeBuilder.DefineField(
"m_number",
typeof(int),
FieldAttributes.Private);
// 添加公开字段
FieldBuilder fbString = typeBuilder.DefineField(
"Name",
typeof(string),
FieldAttributes.Public
);
// 定义带参数构造
ConstructorBuilder ctor1 = typeBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
new Type[] { typeof(int), typeof(string) }
);
ILGenerator ctor1IL = ctor1.GetILGenerator();
// 对于构造方法而言，第一个参数是新实例的引用，再使用参数之前需要先将它push到栈中
// 应该说，对于所有非静态实例，第0个参数都是对象本身，即this。
// 需要注意的是，调用对象中的字段或者属性时，需要先将this放入计算堆栈，即ldarg_0;
ctor1IL.Emit(OpCodes.Ldarg_0);
// 调用base的构造
ctor1IL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
// 和前面一样
ctor1IL.Emit(OpCodes.Ldarg_0);
// 使用真正的参数
ctor1IL.Emit(OpCodes.Ldarg_1);
ctor1IL.Emit(OpCodes.Stfld, fbNumber);
ctor1IL.Emit(OpCodes.Ldarg_0);
ctor1IL.Emit(OpCodes.Ldarg_2);
ctor1IL.Emit(OpCodes.Stfld, fbString);
ctor1IL.Emit(OpCodes.Ret);
// 定义无参数默认构造
ConstructorBuilder ctor0 = typeBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
Type.EmptyTypes
);
ILGenerator ctor0IL = ctor0.GetILGenerator();
ctor0IL.Emit(OpCodes.Ldarg_0);
ctor0IL.Emit(OpCodes.Ldc_I4_S, 65);
ctor0IL.Emit(OpCodes.Ldstr, "默认名");
// 调用有参构造
ctor0IL.Emit(OpCodes.Call, ctor1);
ctor0IL.Emit(OpCodes.Ret);
// 定义属性
PropertyBuilder pbNumber = typeBuilder.DefineProperty(
"Number",
PropertyAttributes.HasDefault,
typeof(int),
null);
// 定义Get方法
MethodBuilder mbNumberGetAccessor = typeBuilder.DefineMethod(
"GetNumber",
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
typeof(int),
Type.EmptyTypes);
ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();
numberGetIL.Emit(OpCodes.Ldarg_0);
numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
numberGetIL.Emit(OpCodes.Ret);
// 定义Set方法
MethodBuilder mbNumberSetAccessor = typeBuilder.DefineMethod(
"SetNumber",
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
null,
new Type[] { typeof(int) });
ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
numberSetIL.Emit(OpCodes.Ldarg_0);
numberSetIL.Emit(OpCodes.Ldarg_1);
numberSetIL.Emit(OpCodes.Stfld, fbNumber);
numberSetIL.Emit(OpCodes.Ret);
// 将方法绑定到属性上
pbNumber.SetGetMethod(mbNumberGetAccessor);
pbNumber.SetSetMethod(mbNumberSetAccessor);
// 定义一个增加number方法
MethodBuilder mbAdditionalAccessor = typeBuilder.DefineMethod(
"AdditionalNumber",
MethodAttributes.Public,
typeof(int),
new Type[] { typeof(int) }
);
ILGenerator numberAdditionalIL = mbAdditionalAccessor.GetILGenerator();
numberAdditionalIL.DeclareLocal(typeof(int)).SetLocalSymInfo("result");
numberAdditionalIL.Emit(OpCodes.Ldarg_1);
numberAdditionalIL.Emit(OpCodes.Ldarg_0);
numberAdditionalIL.Emit(OpCodes.Ldfld, fbNumber);
numberAdditionalIL.Emit(OpCodes.Add);
numberAdditionalIL.Emit(OpCodes.Stloc_0);
numberAdditionalIL.Emit(OpCodes.Ldloc_0);
numberAdditionalIL.Emit(OpCodes.Ret);
// 增加一个字符串拼接方法
MethodBuilder mbAddPrefixAccessor = typeBuilder.DefineMethod(
"AddPrefix",
MethodAttributes.Public,
typeof(string),
new Type[] { typeof(string), typeof(int) }
);
ILGenerator prefixIL = mbAddPrefixAccessor.GetILGenerator();
Label trylabel = prefixIL.DefineLabel();
Label loopLabel = prefixIL.DefineLabel();
Label beginLable = prefixIL.DefineLabel();
Label endLable = prefixIL.DefineLabel();
prefixIL.DeclareLocal(typeof(string)).SetLocalSymInfo("prefix");
prefixIL.DeclareLocal(typeof(string)).SetLocalSymInfo("result");
prefixIL.DeclareLocal(typeof(int)).SetLocalSymInfo("i");
prefixIL.DeclareLocal(typeof(string)).SetLocalSymInfo("e");
// try
Label tryLable = prefixIL.BeginExceptionBlock();
prefixIL.Emit(OpCodes.Ldarg_2);
prefixIL.Emit(OpCodes.Ldc_I4_0);
prefixIL.Emit(OpCodes.Bgt, trylabel);
// throw exception
prefixIL.Emit(OpCodes.Ldstr, "count is zero");
prefixIL.Emit(OpCodes.Newobj, typeof(Exception).GetConstructor(new Type[] { typeof(string) }));
prefixIL.Emit(OpCodes.Throw);
prefixIL.MarkLabel(trylabel);
prefixIL.Emit(OpCodes.Ldstr, "https://");
prefixIL.Emit(OpCodes.Stloc_0);
prefixIL.Emit(OpCodes.Ldloc_0);
prefixIL.Emit(OpCodes.Ldarg_1);
prefixIL.Emit(OpCodes.Call, typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string) }));
prefixIL.Emit(OpCodes.Stloc_1);
prefixIL.Emit(OpCodes.Ldc_I4_0);
prefixIL.Emit(OpCodes.Stloc_2);
prefixIL.Emit(OpCodes.Br, beginLable);
prefixIL.MarkLabel(loopLabel);
prefixIL.Emit(OpCodes.Ldloc_1);
prefixIL.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
prefixIL.Emit(OpCodes.Ldloc_2);
prefixIL.Emit(OpCodes.Ldc_I4_1);
prefixIL.Emit(OpCodes.Add);
prefixIL.Emit(OpCodes.Stloc_2);
prefixIL.MarkLabel(beginLable);
prefixIL.Emit(OpCodes.Ldloc_2);
prefixIL.Emit(OpCodes.Ldarg_2);
prefixIL.Emit(OpCodes.Blt, loopLabel);
prefixIL.Emit(OpCodes.Leave, endLable);
// catch
prefixIL.BeginCatchBlock(typeof(Exception));
prefixIL.Emit(OpCodes.Callvirt, typeof(Exception).GetMethod("get_Message"));
prefixIL.Emit(OpCodes.Stloc_3);
prefixIL.Emit(OpCodes.Ldstr, " Error happened ");
prefixIL.Emit(OpCodes.Ldloc_3);
prefixIL.Emit(OpCodes.Call, typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string) }));
prefixIL.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
prefixIL.EndExceptionBlock();
prefixIL.Emit(OpCodes.Ldnull);
prefixIL.Emit(OpCodes.Stloc_1);
prefixIL.MarkLabel(endLable);
prefixIL.Emit(OpCodes.Ldloc_1);
prefixIL.Emit(OpCodes.Ret);
// 添加接口
typeBuilder.AddInterfaceImplementation(typeof(IPerson));
// 实现方法
MethodBuilder mbim = typeBuilder.DefineMethod("SayHello",
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot
| MethodAttributes.Virtual | MethodAttributes.Final,
null,
Type.EmptyTypes);
ILGenerator il = mbim.GetILGenerator();
il.Emit(OpCodes.Ldstr, "The Sayhello implememtation of IPerson");
il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
il.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(mbim, typeof(IPerson).GetMethod("SayHello"));
Type personType = typeBuilder.CreateType();
assemblyBuilder.Save("Person.dll");
return(Activator.CreateInstance(personType));
}
// Create EventSpy.
// Arguments are a name and object to spy on (the spy target).
//
public EventSpy(String spyname, Object o)
{
// create dynamic assembly
AssemblyName name = new AssemblyName();
name.Name = "EventSpy" + spyname;
AssemblyBuilder asm = AppDomain.CurrentDomain.DefineDynamicAssembly(name,
AssemblyBuilderAccess.Run);
// create dynamic module
ModuleBuilder mod = asm.DefineDynamicModule("EventSpyModule", true);
// What follows is a whole bunch of grody code, all of whose purpose
// is to generate a dynamic class that looks more or less like this:
//
// public class EvSpyImpl
// {
// private EventSpy spy;
// public EvSpyImpl(EventSpy s)
// {
// spy = s;
// }
// public void OnEventXxx(object o, EventXxxArgs e)
// {
// spy.ReportEvent("EventXxx", o, e);
// }
// }
//
// First, create the class
TypeBuilder helperClass = mod.DefineType("EvSpyImpl",
TypeAttributes.Public);
// Add a field called "spy" of type EventSpy.
FieldBuilder fld = helperClass.DefineField("spy", typeof(EventSpy),
FieldAttributes.Private);
// Create constructor to initialize the "spy" field.
// In C#, the ctor would look like this:
//
// public EvSpyImpl(EventSpy s)
// {
// spy = s;
// }
//
// The MSIL for this looks like this (from ILDASM):
//
// ldarg.0
// call instance void [mscorlib]System.Object::.ctor()
// ldarg.0
// ldarg.1
// stfld class SpyTools.EventSpy SpyTools.EventSpy::spy
// ret
//
ConstructorBuilder ctor = helperClass.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
new Type[] { typeof(EventSpy) });
ILGenerator ilctor = ctor.GetILGenerator();
ilctor.Emit(OpCodes.Ldarg_0);
ConstructorInfo basector = typeof(Object).GetConstructor(new Type[0]);
ilctor.Emit(OpCodes.Call, basector);
ilctor.Emit(OpCodes.Ldarg_0);
ilctor.Emit(OpCodes.Ldarg_1);
ilctor.Emit(OpCodes.Stfld, fld);
ilctor.Emit(OpCodes.Ret);
// Now create an OnEventXxx method for every event Xxx exposed by
// the target object (o). Each method looks like this:
//
// public void OnEventXxx(object o, EventXxxArgs e)
// {
// spy.ReportEvent("EventXxx", o, e);
// }
// }
//
// The MSIL for this looks like this (from ILDASM):
//
// ldarg.0
// ldfld class SpyTools.EventSpy SpyTools.EventSpy::spy
// ldstr "EventXxx"
// ldarg.1
// ldarg.2
// callvirt instance void SpyTools.EventSpy::ReportEvent(string,
// object, class [mscorlib]System.EventArgs)
// ret
//
Type targType = o.GetType();
BindingFlags whichEvents = BindingFlags.Instance | BindingFlags.Public;
EventInfo[] allEvents = targType.GetEvents(whichEvents);
MethodInfo miReportEvent = this.GetType().GetMethod("ReportEvent");
// loop over all events to create each handler
foreach (EventInfo ev in allEvents)
{
if (ev.Name.Contains("MouseMove"))
{
continue;
}
// get event handler (delegate) Type
Type delgType = ev.EventHandlerType;
// To get parameter types (eg., FooEventArgs), need to get
// parameter types of the delegate's Invoke method.
MethodInfo invoke = delgType.GetMethod("Invoke");
ParameterInfo[] prams = invoke.GetParameters();
int len = prams.Length;
// Copy parameter types into an array
Type[] mthparams = new Type[len];
for (int i = 0; i < len; i++)
{
mthparams[i] = prams[i].ParameterType;
}
// name of method is "On" + eventName, eg., "OnFooEvent"
String mthname = "On" + ev.Name;
// create the method with proper signature
MethodBuilder mthd = helperClass.DefineMethod(
mthname,
MethodAttributes.Public,
invoke.ReturnType,
mthparams);
// Now generate the MSIL as described in comment above.
ILGenerator il = mthd.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, fld);
il.Emit(OpCodes.Ldstr, ev.Name);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Callvirt, miReportEvent);
il.Emit(OpCodes.Ret);
}
// Once all fields and methods are defined, finally create the Type.
Type mytype = helperClass.CreateType();
// Now create an instance of it with "this" as the spy object.
Object spyimpl = Activator.CreateInstance(mytype, new Object[] { this });
// Now hook up each event handler to its event in the target object.
foreach (EventInfo ev in allEvents)
{
if (ev.Name.Contains("MouseMove"))
{
continue;
}
ev.AddEventHandler(o,
Delegate.CreateDelegate(ev.EventHandlerType,
spyimpl, "On" + ev.Name));
}
}
private static void LoadPlugins()
{
versionCount = versionCount + 1;
Deb.Log("KramaxPluginReload: (Re)loading plugins with version {0}.", versionCount);
Type type = typeof(KramaxReloadExtensions.ReloadableMonoBehaviour);
foreach (PluginSetting setting in PluginSettings)
{
//Skip reloading of loadonce assemblies
if (setting.LoadOnce == true)
{
continue;
}
//Call ondestroy on alive classes
List <PluginClass> toRemove = new List <PluginClass>();
foreach (PluginClass pluginClass in PluginClasses.Where(pc => pc.pluginSetting == setting))
{
if (pluginClass.alive)
{
pluginClass.DeleteInstance();
}
toRemove.Add(pluginClass);
}
//Remove old class references
foreach (PluginClass r in toRemove)
{
PluginClasses.Remove(r);
}
var assembly = LoadAssembly(setting.Path);
//Remove assembly if reloading failed
if (assembly == null)
{
foreach (PluginClass pluginClass in PluginClasses.Where(pc => pc.pluginSetting == setting).ToList())
{
PluginClasses.Remove(pluginClass);
}
continue;
}
String tmpAssemblyName = String.Format("KramaxPIRLAsmb_{0}", versionCount);
String tmpModuleName = String.Format("KramaxPIRLMod_{0}", versionCount);
AssemblyBuilder assemblyBldr =
Thread.GetDomain().DefineDynamicAssembly(new AssemblyName(tmpAssemblyName),
AssemblyBuilderAccess.Run);
ModuleBuilder moduleBldr = assemblyBldr.DefineDynamicModule(tmpModuleName);
IList <Type> derivedClassess =
(from t in assembly.GetTypes()
where t.IsSubclassOf(typeof(MonoBehaviour))
select t).ToList();
List <PluginClass> plugins = new List <PluginClass>();
Dictionary <Type, Type> typeMapping = new Dictionary <Type, Type>();
foreach (var derivedClass in derivedClassess)
{
Deb.Log("KramaxPluginReload.LoadPlugins: got type {0}.", derivedClass.Name);
Deb.Log("KramaxPluginReload.LoadPlugins: from assembly {0}, v{1}.",
derivedClass.Assembly.GetName().Name,
derivedClass.Assembly.GetName().Version);
System.Attribute[] attrs = System.Attribute.GetCustomAttributes(derivedClass);
KSPAddon kspAddon = null;
foreach (var att in attrs)
{
if (att is KSPAddon)
{
kspAddon = att as KSPAddon;
}
}
if (!derivedClass.IsSubclassOf(typeof(KramaxReloadExtensions.ReloadableMonoBehaviour)))
{
Deb.Log("KramaxPluginReload.LoadPlugins: ERROR type {0} is not ReloadableMonoBehaviour subclass.",
derivedClass.Name);
continue;
}
if (kspAddon != null)
{
Deb.Log("KramaxPluginReload.LoadPlugins: type {0} will be top-level component.", derivedClass.Name);
PluginClass pluginClass = new PluginClass();
pluginClass.pluginSetting = setting;
pluginClass.originalType = derivedClass;
pluginClass.kspAddon = kspAddon;
pluginClass.type = CreateUniqueSubClass(moduleBldr, derivedClass, versionCount);
plugins.Add(pluginClass);
}
else
{
Deb.Log("KramaxPluginReload.LoadPlugins: type {0} will be sub-level component.", derivedClass.Name);
var newType = CreateUniqueSubClass(moduleBldr, derivedClass, versionCount);
typeMapping[derivedClass] = newType;
}
}
foreach (var plugin in plugins)
{
plugin.typeMapping = typeMapping;
PluginClasses.Add(plugin);
}
}
foreach (var pluginClass in PluginClasses)
{
if (pluginClass.kspAddon.once == false || pluginClass.fired == false)
{
bool awake = false;
switch (pluginClass.kspAddon.startup)
{
case KSPAddon.Startup.Instantly:
case KSPAddon.Startup.EveryScene:
//TODO: Check wether PSystem should even respawn.
case KSPAddon.Startup.PSystemSpawn:
awake = true;
break;
case KSPAddon.Startup.Credits:
awake = (HighLogic.LoadedScene == GameScenes.CREDITS);
break;
case KSPAddon.Startup.EditorAny:
awake = (HighLogic.LoadedScene == GameScenes.EDITOR);
break;
case KSPAddon.Startup.Flight:
awake = (HighLogic.LoadedScene == GameScenes.FLIGHT);
break;
case KSPAddon.Startup.MainMenu:
awake = (HighLogic.LoadedScene == GameScenes.MAINMENU);
break;
case KSPAddon.Startup.Settings:
awake = (HighLogic.LoadedScene == GameScenes.SETTINGS);
break;
case KSPAddon.Startup.SpaceCentre:
awake = (HighLogic.LoadedScene == GameScenes.SPACECENTER);
break;
case KSPAddon.Startup.TrackingStation:
awake = (HighLogic.LoadedScene == GameScenes.TRACKSTATION);
break;
}
if (awake)
{
Deb.Log("KramaxPluginReload.LoadPlugins: plugin should be awake: {0}.", pluginClass.Name);
pluginClass.CreateInstance();
}
}
}
Deb.Log("KramaxPluginReload.LoadPlugins: Plugins (re)loaded.");
}
private Type EmitHelperClass(string HandlerName, EventInfo Info)
{
if (helperModule == null)
{
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = assemblyName + "Helper";
AppDomain domain = Thread.GetDomain();
//AppDomain domain = AppDomain.CreateDomain("testingHelper");
asmBuilder = domain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
helperModule = asmBuilder.DefineDynamicModule(assemblyName + "Module", true);
}
//////////////////////////////////////////////////////////////////////////
// Define Type
//////////////////////////////////////////////////////////////////////////
TypeBuilder helperTypeBld = helperModule.DefineType(HandlerName + "Helper", TypeAttributes.Public);
// Define fields
FieldBuilder typeField = helperTypeBld.DefineField("eventType", typeof(Type), FieldAttributes.Private);
FieldBuilder eventField = helperTypeBld.DefineField("CommonEvent", typeof(CommonEventHandlerDlgt), FieldAttributes.Private);
EventBuilder commonEvent = helperTypeBld.DefineEvent("CommonEvent", EventAttributes.None, typeof(CommonEventHandlerDlgt));
//////////////////////////////////////////////////////////////////////////
// Build Constructor
//////////////////////////////////////////////////////////////////////////
Type objType = Type.GetType("System.Object");
ConstructorInfo objCtor = objType.GetConstructor(new Type[0]);
// Build constructor with arguments (Type)
Type[] ctorParams = new Type[] { typeof(EventInfo) };
ConstructorBuilder ctor = helperTypeBld.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctorParams);
// Call constructor of base class
ILGenerator ctorIL = ctor.GetILGenerator();
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Call, objCtor);
// store first argument to typeField
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_1);
ctorIL.Emit(OpCodes.Stfld, typeField);
// return
ctorIL.Emit(OpCodes.Ret);
// Now constructor is finished!
//////////////////////////////////////////////////////////////////////////
// Build customized event handler
//////////////////////////////////////////////////////////////////////////
Type ehType = Info.EventHandlerType;
MethodInfo mi = ehType.GetMethod("Invoke");
ParameterInfo[] eventParams = mi.GetParameters();
// Build the type list of the parameter
int paramCount = eventParams.Length;
Type[] invokeParams = new Type[paramCount];
for (int i = 0; i < paramCount; i++)
{
invokeParams[i] = eventParams[i].ParameterType;
}
string methodName = "CustomEventHandler";
MethodAttributes attr = MethodAttributes.Public | MethodAttributes.HideBySig;
MethodBuilder invokeMthd = helperTypeBld.DefineMethod(methodName, attr, typeof(void), invokeParams);
// A ILGenerator can now be spawned, attached to the MethodBuilder.
ILGenerator ilGen = invokeMthd.GetILGenerator();
// Create Label before return
Label endOfMethod = ilGen.DefineLabel();
// Create a local variable of type ‘string’, and call it ‘args’
LocalBuilder localObj = ilGen.DeclareLocal(typeof(object[]));
localObj.SetLocalSymInfo("args"); // Provide Name for the debugger.
// create object array of proper length
ilGen.Emit(OpCodes.Ldc_I4, paramCount);
ilGen.Emit(OpCodes.Newarr, typeof(object));
ilGen.Emit(OpCodes.Stloc_0);
// Now put all arguments in the object array
for (int i = 0; i < paramCount; i++)
{
byte i1b = Convert.ToByte(i + 1);
ilGen.Emit(OpCodes.Ldloc_0);
ilGen.Emit(OpCodes.Ldc_I4, i);
ilGen.Emit(OpCodes.Ldarg_S, i1b);
// Is argument value type?
if (invokeParams[i].IsValueType)
{
// Box the value type
ilGen.Emit(OpCodes.Box, invokeParams[i]);
}
// Put the argument in the object array
ilGen.Emit(OpCodes.Stelem_Ref);
}
// raise common event
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, eventField);
ilGen.Emit(OpCodes.Brfalse_S, endOfMethod);
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, eventField);
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, typeField);
ilGen.Emit(OpCodes.Ldloc_0);
MethodInfo raiseEventMethod = typeof(CommonEventHandlerDlgt).GetMethod("Invoke", BindingFlags.Public | BindingFlags.Instance);
if (raiseEventMethod == null) throw new ApplicationException("CommonEventHandlerDlg:Invoke not found");
ilGen.Emit(OpCodes.Callvirt, raiseEventMethod);
// return
ilGen.MarkLabel(endOfMethod);
ilGen.Emit(OpCodes.Ret);
//////////////////////////////////////////////////////////////////////////
// add_CommonEvent
//////////////////////////////////////////////////////////////////////////
methodName = "add_CommonEvent";
attr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
invokeParams = new Type[1];
invokeParams[0] = typeof(CommonEventHandlerDlgt);
MethodBuilder addMethod = helperTypeBld.DefineMethod(methodName, attr, typeof(void), invokeParams);
ilGen = addMethod.GetILGenerator();
// define code
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, eventField);
ilGen.Emit(OpCodes.Ldarg_1);
Type[] combineTypes = new Type[] { typeof(Delegate), typeof(Delegate) };
MethodInfo combineMtd = typeof(Delegate).GetMethod("Combine", combineTypes);
if (combineMtd == null) throw new ApplicationException("Delegate:Combine not found");
ilGen.Emit(OpCodes.Call, combineMtd);
ilGen.Emit(OpCodes.Castclass, typeof(CommonEventHandlerDlgt));
ilGen.Emit(OpCodes.Stfld, eventField);
ilGen.Emit(OpCodes.Ret);
// Set add method
commonEvent.SetAddOnMethod(addMethod);
//////////////////////////////////////////////////////////////////////////
// remove_CommonEvent
//////////////////////////////////////////////////////////////////////////
methodName = "remove_CommonEvent";
attr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
invokeParams = new Type[1];
invokeParams[0] = typeof(CommonEventHandlerDlgt);
MethodBuilder removeMethod = helperTypeBld.DefineMethod(methodName, attr, typeof(void), invokeParams);
ilGen = removeMethod.GetILGenerator();
// define code
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldarg_0);
ilGen.Emit(OpCodes.Ldfld, eventField);
ilGen.Emit(OpCodes.Ldarg_1);
MethodInfo removeMtd = typeof(Delegate).GetMethod("Remove", combineTypes);
if (removeMtd == null) throw new ApplicationException("Delegate:Remove not found");
ilGen.Emit(OpCodes.Call, removeMtd);
ilGen.Emit(OpCodes.Castclass, typeof(CommonEventHandlerDlgt));
ilGen.Emit(OpCodes.Stfld, eventField);
ilGen.Emit(OpCodes.Ret);
// Set add method
commonEvent.SetAddOnMethod(addMethod);
//////////////////////////////////////////////////////////////////////////
// Now event handler is finished!
//////////////////////////////////////////////////////////////////////////
return helperTypeBld.CreateType();
}
private Type CreateType(IProxyInvocationHandler handler, Type[] interfaces, string dynamicTypeName)
{
Type retVal = null;
if (handler != null && interfaces != null)
{
Type objType = typeof(System.Object);
Type handlerType = typeof(IProxyInvocationHandler);
AppDomain domain = Thread.GetDomain();
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = ASSEMBLY_NAME;
assemblyName.Version = new Version(1, 0, 0, 0);
// create a new assembly for this proxy, one that isn't presisted on the file system
AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly(
assemblyName, AssemblyBuilderAccess.Run);
// assemblyName, AssemblyBuilderAccess.RunAndSave,"."); // to save it to the disk
// create a new module for this proxy
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(MODULE_NAME);
// Set the class to be public and sealed
TypeAttributes typeAttributes =
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed;
// Gather up the proxy information and create a new type builder. One that
// inherits from Object and implements the interface passed in
TypeBuilder typeBuilder = moduleBuilder.DefineType(
dynamicTypeName, typeAttributes, objType, interfaces);
// Define a member variable to hold the delegate
FieldBuilder handlerField = typeBuilder.DefineField(
HANDLER_NAME, handlerType, FieldAttributes.Private);
// build a constructor that takes the delegate object as the only argument
//ConstructorInfo defaultObjConstructor = objType.GetConstructor( new Type[0] );
ConstructorInfo superConstructor = objType.GetConstructor(new Type[0]);
ConstructorBuilder delegateConstructor = typeBuilder.DefineConstructor(
MethodAttributes.Public, CallingConventions.Standard, new Type[] { handlerType });
#region ( "Constructor IL Code" )
ILGenerator constructorIL = delegateConstructor.GetILGenerator();
// Load "this"
constructorIL.Emit(OpCodes.Ldarg_0);
// Load first constructor parameter
constructorIL.Emit(OpCodes.Ldarg_1);
// Set the first parameter into the handler field
constructorIL.Emit(OpCodes.Stfld, handlerField);
// Load "this"
constructorIL.Emit(OpCodes.Ldarg_0);
// Call the super constructor
constructorIL.Emit(OpCodes.Call, superConstructor);
// Constructor return
constructorIL.Emit(OpCodes.Ret);
#endregion
// for every method that the interfaces define, build a corresponding
// method in the dynamic type that calls the handlers invoke method.
foreach (Type interfaceType in interfaces)
{
GenerateMethod(interfaceType, handlerField, typeBuilder);
}
retVal = typeBuilder.CreateType();
// assemblyBuilder.Save(dynamicTypeName + ".dll");
}
return(retVal);
}
public void CtorFourTest()
{
//test for the constructor with signature--
//public CustomAttributeBuilder(ConstructorInfo, object[], PropertyInfo[], object[], FieldInfo[], object[]);
/*
* WE build a imaginary type as follows
* [CustomAttribute()]
* public class TestType
* {
*
* }
* We also set the "AttributeOne" property ,
* and "Feild" of class CustomAttribute
* by means of the constuctor of CustomAttributeBuilder
* And then check for the validity
*/
AssemblyName asmName = new AssemblyName();
asmName.Name = "TestAssembly.dll";
AssemblyBuilder asmBuilder = Thread.GetDomain().DefineDynamicAssembly(
asmName, AssemblyBuilderAccess.Run);
ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("TestModule");
TypeBuilder typeBuilder = modBuilder.DefineType("TestType",
TypeAttributes.Public);
Type [] ctorParams = new Type [] { };
ConstructorInfo classCtorInfo =
typeof(CustomAttribute).GetConstructor(ctorParams);
CustomAttributeBuilder typeCABuilder = new CustomAttributeBuilder(
classCtorInfo,
new object [] { },
new PropertyInfo [] { typeof(CustomAttribute).GetProperty("AttributeOne") },
new object [] { "TestCase" },
typeof(CustomAttribute).GetFields(),
new object [] { "FieldValue" }
);
typeBuilder.SetCustomAttribute(typeCABuilder);
// create the type
Type myType = typeBuilder.CreateType();
//Now check for the validity of the attributes.
object testInstance = Activator.CreateInstance(myType);
//check the validity of the attribute associated with Print method
object [] customAttrs = myType.GetCustomAttributes(false);
Assert.AreEqual(customAttrs.Length, 1, "#1");
//Custom Attributes of TestType
CustomAttribute attr = customAttrs [0] as CustomAttribute;
Assert.AreEqual(attr.AttributeOne, "TestCase", "#2");
Assert.AreEqual(attr.Feild, "FieldValue", "#3");
}
private static Type GetOIType()
{
if (_oiType != null)
{
return(_oiType);
}
AssemblyName name = new AssemblyName("LOSConfigProxy.dll");
// Define a dynamic assembly and module
AssemblyBuilder asm = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
ModuleBuilder module = asm.DefineDynamicModule("LOSConfigProxy");
// Define a class to inherit from OptionInterface
TypeBuilder proxy = module.DefineType("LOSConfigProxy", TypeAttributes.Class, typeof(OptionInterface));
// FIELD DEFINITIONS
// data (LOSConfigData)
FieldBuilder configData = proxy.DefineField("configData", typeof(LOSConfigData), FieldAttributes.Private);
// METHOD DEFINITIONS
// ctor (PartialityMod) => LOSConfig.Ctor (OptionInterface)
{
ConstructorBuilder cb = proxy.DefineConstructor(MethodAttributes.Public, CallingConventions.Any, new Type[] { typeof(PartialityMod) });
ILGenerator ilg = cb.GetILGenerator();
ConstructorInfo baseCtor = typeof(OptionInterface).GetConstructor(new Type[] { typeof(PartialityMod) });
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldarg_1);
ilg.Emit(OpCodes.Call, baseCtor); // Call base.ctor
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Newobj, typeof(LOSConfigData).GetConstructor(Type.EmptyTypes)); // Assign a new instance to configData
ilg.Emit(OpCodes.Stfld, configData);
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Call, typeof(LOSConfig).GetMethod("Ctor")); // Call proxy
ilg.Emit(OpCodes.Ret);
}
// Initialize () => LOSConfig.Initialize (OptionInterface)
{
MethodBuilder mb = proxy.DefineMethod("Initialize", MethodAttributes.Public | MethodAttributes.Virtual);
ILGenerator ilg = mb.GetILGenerator();
MethodInfo baseInitialize = typeof(OptionInterface).GetMethod("Initialize", BindingFlags.Public | BindingFlags.Instance);
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Call, baseInitialize); // Call base.Initialize
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Call, typeof(LOSConfig).GetMethod("Initialize")); // Call proxy
ilg.Emit(OpCodes.Ret);
}
// ConfigOnChange () => LOSConfig.ConfigOnChange (OptionInterface)
{
MethodBuilder mb = proxy.DefineMethod("ConfigOnChange", MethodAttributes.Public | MethodAttributes.Virtual);
ILGenerator ilg = mb.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Call, typeof(LOSConfig).GetMethod("ConfigOnChange")); // Call proxy
ilg.Emit(OpCodes.Ret);
}
// Update (float) => LOSConfig.Update (OptionInterface, float)
{
MethodBuilder mb = proxy.DefineMethod("Update", MethodAttributes.Public | MethodAttributes.Virtual, null, new Type[] { typeof(float) });
ILGenerator ilg = mb.GetILGenerator();
MethodInfo baseUpdate = typeof(OptionInterface).GetMethod("Update", BindingFlags.Public | BindingFlags.Instance);
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldarg_1);
ilg.Emit(OpCodes.Call, baseUpdate); // Call base.Update
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldarg_1);
ilg.Emit(OpCodes.Call, typeof(LOSConfig).GetMethod("Update")); // Call proxy
ilg.Emit(OpCodes.Ret);
}
// GetConfigData (OptionInterface)
{
MethodBuilder mb = proxy.DefineMethod("GetConfigData", MethodAttributes.Assembly | MethodAttributes.Static,
typeof(LOSConfigData), new Type[] { typeof(OptionInterface) });
ILGenerator ilg = mb.GetILGenerator();
ilg.Emit(OpCodes.Ldarg_0);
ilg.Emit(OpCodes.Ldfld, configData);
ilg.Emit(OpCodes.Ret);
}
_oiType = proxy.CreateType();
return(_oiType);
}
public ProxyTypeNameTest()
{
var asmBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Test.Norns.Urd.Reflection.TypeExtenionsTest.Generated"), AssemblyBuilderAccess.RunAndCollect);
moduleBuilder = asmBuilder.DefineDynamicModule("core");
}
public ModuleBuilder DefineDynamicModule(AssemblyBuilder assemblyBuilder, string moduleName)
{
return(assemblyBuilder.DefineDynamicModule(moduleName, string.Format("{0}.mod", assemblyName), true));
}
internal override void Apply(ClassLoaderWrapper loader, AssemblyBuilder ab, object annotation)
{
if (type.IsSubclassOf(Types.SecurityAttribute))
{
#if STATIC_COMPILER
ab.__AddDeclarativeSecurity(MakeCustomAttributeBuilder(loader, annotation));
#endif
}
#if STATIC_COMPILER
else if (type == JVM.Import(typeof(System.Runtime.CompilerServices.TypeForwardedToAttribute)))
{
ab.__AddTypeForwarder((Type)ConvertValue(loader, Types.Type, ((object[])annotation)[3]));
}
else if (type == JVM.Import(typeof(System.Reflection.AssemblyVersionAttribute)))
{
string str = (string)ConvertValue(loader, Types.String, ((object[])annotation)[3]);
Version version;
if (IkvmcCompiler.TryParseVersion(str, out version))
{
ab.__SetAssemblyVersion(version);
}
else
{
loader.IssueMessage(Message.InvalidCustomAttribute, type.FullName, "The version '" + str + "' is invalid.");
}
}
else if (type == JVM.Import(typeof(System.Reflection.AssemblyCultureAttribute)))
{
string str = (string)ConvertValue(loader, Types.String, ((object[])annotation)[3]);
if (str != "")
{
ab.__SetAssemblyCulture(str);
}
}
else if (type == JVM.Import(typeof(System.Reflection.AssemblyDelaySignAttribute))
|| type == JVM.Import(typeof(System.Reflection.AssemblyKeyFileAttribute))
|| type == JVM.Import(typeof(System.Reflection.AssemblyKeyNameAttribute)))
{
loader.IssueMessage(Message.IgnoredCustomAttribute, type.FullName, "Please use the corresponding compiler switch.");
}
else if (type == JVM.Import(typeof(System.Reflection.AssemblyAlgorithmIdAttribute)))
{
// this attribute is currently not exposed as an annotation and isn't very interesting
throw new NotImplementedException();
}
else if (type == JVM.Import(typeof(System.Reflection.AssemblyFlagsAttribute)))
{
// this attribute is currently not exposed as an annotation and isn't very interesting
throw new NotImplementedException();
}
#endif
else
{
ab.SetCustomAttribute(MakeCustomAttributeBuilder(loader, annotation));
}
}
public void Save(AssemblyBuilder assemblyBuilder)
{
assemblyBuilder.Save(assemblyName + ".dll");
}
static NativeImplementationBuilder()
{
builder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(Guid.NewGuid().ToString()), AssemblyBuilderAccess.Run);
module = builder.DefineDynamicModule("Implementations");
}
public static void Main()
{
// Get the assembly that contains the Timer type (Sytem.dll).
// The following code uses the fact that System.dll has the
// same public key as mscorlib.dll to construct a string
// representing the full assembly name.
string fullName = "";
foreach (Assembly assem in AppDomain.CurrentDomain.GetAssemblies())
{
if (assem.GetName().Name == "mscorlib")
{
fullName = assem.FullName;
}
}
Assembly sys = Assembly.Load("System" + fullName.Substring(fullName.IndexOf(",")));
// Get a Type object representing the Timer type.
Type t = sys.GetType("System.Timers.Timer");
// Create an instance of the Timer type.
timer = Activator.CreateInstance(t);
// Use reflection to get the Elapsed event.
EventInfo eInfo = t.GetEvent("Elapsed");
// In order to create a method to handle the Elapsed event,
// it is necessary to know the signature of the delegate
// used to raise the event. Reflection.Emit can then be
// used to construct a dynamic class with a static method
// that has the correct signature.
// Get the event handler type of the Elapsed event. This is
// a delegate type, so it has an Invoke method that has
// the same signature as the delegate. The following code
// creates an array of Type objects that represent the
// parameter types of the Invoke method.
//
Type handlerType = eInfo.EventHandlerType;
MethodInfo invokeMethod = handlerType.GetMethod("Invoke");
ParameterInfo[] parms = invokeMethod.GetParameters();
Type[] parmTypes = new Type[parms.Length];
for (int i = 0; i < parms.Length; i++)
{
parmTypes[i] = parms[i].ParameterType;
}
// Use Reflection.Emit to create a dynamic assembly that
// will be run but not saved. An assembly must have at
// least one module, which in this case contains a single
// type. The only purpose of this type is to contain the
// event handler method. (In the .NET Framework version
// 2.0 you can use dynamic methods, which are simpler
// because there is no need to create an assembly, module,
// or type.)
AssemblyName aName = new AssemblyName();
aName.Name = "DynamicTypes";
AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Run);
ModuleBuilder mb = ab.DefineDynamicModule(aName.Name);
TypeBuilder tb = mb.DefineType("Handler", TypeAttributes.Class | TypeAttributes.Public);
// Create the method that will handle the event. The name
// is not important. The method is static, because there is
// no reason to create an instance of the dynamic type.
//
// The parameter types and return type of the method are
// the same as those of the delegate's Invoke method,
// captured earlier.
MethodBuilder handler = tb.DefineMethod("DynamicHandler",
MethodAttributes.Public | MethodAttributes.Static,
invokeMethod.ReturnType, parmTypes);
// Generate code to handle the event. In this case, the
// handler simply prints a text string to the console.
//
ILGenerator il = handler.GetILGenerator();
il.EmitWriteLine("Timer's Elapsed event is raised.");
il.Emit(OpCodes.Ret);
// CreateType must be called before the Handler type can
// be used. In order to create the delegate that will
// handle the event, a MethodInfo from the finished type
// is required.
Type finished = tb.CreateType();
MethodInfo eventHandler = finished.GetMethod("DynamicHandler");
// Use the MethodInfo to create a delegate of the correct
// type, and call the AddEventHandler method to hook up
// the event.
Delegate d = Delegate.CreateDelegate(handlerType, eventHandler);
eInfo.AddEventHandler(timer, d);
// Late-bound calls to the Interval and Enabled property
// are required to enable the timer with a one-second
// interval.
t.InvokeMember("Interval", BindingFlags.SetProperty, null, timer, new Object[] { 1000 });
t.InvokeMember("Enabled", BindingFlags.SetProperty, null, timer, new Object[] { true });
Console.WriteLine("Press the Enter key to end the program.");
Console.ReadLine();
}
public static Type AddType()
{
// Create an assembly.
AssemblyName myAssemblyName = new AssemblyName();
myAssemblyName.Name = "AdderExceptionAsm";
// Create dynamic assembly.
AppDomain myAppDomain = Thread.GetDomain();
AssemblyBuilder myAssemblyBuilder = myAppDomain.DefineDynamicAssembly(myAssemblyName,
AssemblyBuilderAccess.Run);
// Create a dynamic module.
ModuleBuilder myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("AdderExceptionMod");
TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("Adder");
Type[] myAdderParams = new Type[] { typeof(int), typeof(int) };
// Method to add two numbers.
MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod("DoAdd", MethodAttributes.Public |
MethodAttributes.Static, typeof(int), myAdderParams);
ILGenerator myAdderIL = myMethodBuilder.GetILGenerator();
// Create constructor.
ConstructorInfo myConstructorInfo = typeof(OverflowException).GetConstructor(
new Type[] { typeof(string) });
MethodInfo myExToStrMI = typeof(OverflowException).GetMethod("ToString");
MethodInfo myWriteLineMI = typeof(Console).GetMethod("WriteLine", new Type[]
{ typeof(string), typeof(object) });
// Declare local variable.
LocalBuilder myLocalBuilder1 = myAdderIL.DeclareLocal(typeof(int));
LocalBuilder myLocalBuilder2 = myAdderIL.DeclareLocal(typeof(OverflowException));
// Define label.
Label myFailedLabel = myAdderIL.DefineLabel();
Label myEndOfMethodLabel = myAdderIL.DefineLabel();
// Begin exception block.
Label myLabel = myAdderIL.BeginExceptionBlock();
myAdderIL.Emit(OpCodes.Ldarg_0);
myAdderIL.Emit(OpCodes.Ldc_I4_S, 10);
myAdderIL.Emit(OpCodes.Bgt_S, myFailedLabel);
myAdderIL.Emit(OpCodes.Ldarg_1);
myAdderIL.Emit(OpCodes.Ldc_I4_S, 10);
myAdderIL.Emit(OpCodes.Bgt_S, myFailedLabel);
myAdderIL.Emit(OpCodes.Ldarg_0);
myAdderIL.Emit(OpCodes.Ldarg_1);
myAdderIL.Emit(OpCodes.Add_Ovf_Un);
myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder1);
myAdderIL.Emit(OpCodes.Br_S, myEndOfMethodLabel);
myAdderIL.MarkLabel(myFailedLabel);
myAdderIL.Emit(OpCodes.Ldstr, "Cannot accept values over 10 for addition.");
myAdderIL.Emit(OpCodes.Newobj, myConstructorInfo);
myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder2);
myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder2);
// Call fault block.
myAdderIL.BeginFaultBlock();
Console.WriteLine("Fault block called.");
//Throw exception.
myAdderIL.ThrowException(typeof(NotSupportedException));
// Call finally block.
myAdderIL.BeginFinallyBlock();
myAdderIL.Emit(OpCodes.Ldstr, "{0}");
myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder2);
myAdderIL.EmitCall(OpCodes.Callvirt, myExToStrMI, null);
myAdderIL.EmitCall(OpCodes.Call, myWriteLineMI, null);
myAdderIL.Emit(OpCodes.Ldc_I4_M1);
myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder1);
// End exception block.
myAdderIL.EndExceptionBlock();
myAdderIL.MarkLabel(myEndOfMethodLabel);
myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder1);
myAdderIL.Emit(OpCodes.Ret);
return(myTypeBuilder.CreateType());
}
public AssemblyBuilderIKVM(AssemblyBuilder builder, CompilerContext ctx)
: base(ctx)
{
this.builder = builder;
}
private static void SaveDebugAssembly(AssemblyBuilder ab)
{
Console.Error.WriteLine("Saving '{0}'", ab.GetName().Name + ".dll");
ab.Save(ab.GetName().Name + ".dll");
}
public static ModuleBuilder GetModuleBuilder(AssemblyBuilder asmBuild, string moduleName)
{
return(asmBuild.DefineDynamicModule(moduleName));
}
private static AssemblyBuilder GetAsmBuilder(string name)
{
return(AssemblyBuilder.DefineDynamicAssembly(new AssemblyName {
Name = name
}, AssemblyBuilderAccess.Run));
}
/// <summary>Creates patched method.</summary>
/// <exception cref="ArgumentNullException">Thrown when one or more required arguments are null.</exception>
/// <exception cref="Exception"> Thrown when an exception error condition occurs.</exception>
/// <param name="original"> The original method.</param>
/// <param name="harmonyInstanceID">Identifier for the harmony instance.</param>
/// <param name="prefixes"> The prefix methods.</param>
/// <param name="postfixes"> The postfix methods.</param>
/// <param name="transpilers"> The transpiler methods.</param>
/// <returns>A new dynamic method.</returns>
///
public static DynamicMethod CreatePatchedMethod(MethodBase original, string harmonyInstanceID, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers)
{
if (original == null)
{
throw new ArgumentNullException(nameof(original), "Original method is null. Did you specify it correctly?");
}
try
{
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered("### Patch " + original.DeclaringType + ", " + original);
}
var idx = prefixes.Count() + postfixes.Count();
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
if (patch == null)
{
return(null);
}
var il = patch.GetILGenerator();
// for debugging
AssemblyBuilder assemblyBuilder = null;
TypeBuilder typeBuilder = null;
if (DEBUG_METHOD_GENERATION_BY_DLL_CREATION)
{
il = DynamicTools.CreateSaveableMethod(original, "_Patch" + idx, out assemblyBuilder, out typeBuilder);
}
var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
var privateVars = new Dictionary <string, LocalBuilder>();
LocalBuilder resultVariable = null;
if (idx > 0)
{
resultVariable = DynamicTools.DeclareLocalVariable(il, AccessTools.GetReturnedType(original));
privateVars[RESULT_VAR] = resultVariable;
}
prefixes.ForEach(prefix =>
{
prefix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
privateVars[prefix.DeclaringType.FullName] = privateStateVariable;
});
});
var skipOriginalLabel = il.DefineLabel();
var canHaveJump = AddPrefixes(il, original, prefixes, privateVars, skipOriginalLabel);
var copier = new MethodCopier(original, il, originalVariables);
foreach (var transpiler in transpilers)
{
copier.AddTranspiler(transpiler);
}
var endLabels = new List <Label>();
var endBlocks = new List <ExceptionBlock>();
copier.Finalize(endLabels, endBlocks);
foreach (var label in endLabels)
{
Emitter.MarkLabel(il, label);
}
foreach (var block in endBlocks)
{
Emitter.MarkBlockAfter(il, block);
}
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
if (canHaveJump)
{
Emitter.MarkLabel(il, skipOriginalLabel);
}
AddPostfixes(il, original, postfixes, privateVars, false);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
AddPostfixes(il, original, postfixes, privateVars, true);
Emitter.Emit(il, OpCodes.Ret);
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered("DONE");
FileLog.LogBuffered("");
FileLog.FlushBuffer();
}
// for debugging
if (DEBUG_METHOD_GENERATION_BY_DLL_CREATION)
{
DynamicTools.SaveMethod(assemblyBuilder, typeBuilder);
return(null);
}
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
catch (Exception ex)
{
var exceptionString = "Exception from HarmonyInstance \"" + harmonyInstanceID + "\" patching " + original.FullDescription();
if (HarmonyInstance.DEBUG)
{
FileLog.Log("Exception: " + exceptionString);
}
throw new Exception(exceptionString, ex);
}
finally
{
if (HarmonyInstance.DEBUG)
{
FileLog.FlushBuffer();
}
}
}
static int Main()
{
var ab = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Mine"), AssemblyBuilderAccess.Run);
var modb = ab.DefineDynamicModule("Mine.dll");
//
// Set up the IFoo interface
//
var ifooType = modb.DefineType("IFoo", TypeAttributes.Interface | TypeAttributes.Abstract | TypeAttributes.Public);
// Define a simple instance method on the interface
{
var mb = ifooType.DefineMethod("InstanceMethod", MethodAttributes.Public, typeof(int), Type.EmptyTypes);
var ilg = mb.GetILGenerator();
ilg.Emit(OpCodes.Ldc_I4_1);
ilg.Emit(OpCodes.Ret);
}
// Define a default interface method
{
var mb = ifooType.DefineMethod("DefaultMethod", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot, typeof(int), Type.EmptyTypes);
var ilg = mb.GetILGenerator();
ilg.Emit(OpCodes.Ldc_I4_2);
ilg.Emit(OpCodes.Ret);
}
// Define a regular interface method
{
var mb = ifooType.DefineMethod("InterfaceMethod", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Abstract, typeof(int), Type.EmptyTypes);
}
ifooType.CreateTypeInfo();
//
// Set up the IBar interface
//
var ibarType = modb.DefineType("IBar", TypeAttributes.Interface | TypeAttributes.Abstract | TypeAttributes.Public, null, new Type[] { ifooType });
// Override the regular interface method on IFoo with a default implementation
{
var mb = ibarType.DefineMethod("InterfaceMethodImpl", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Final, typeof(int), Type.EmptyTypes);
var ilg = mb.GetILGenerator();
ilg.Emit(OpCodes.Ldc_I4_4);
ilg.Emit(OpCodes.Ret);
ibarType.DefineMethodOverride(mb, ifooType.GetMethod("InterfaceMethod"));
}
ibarType.CreateTypeInfo();
//
// Make a simple Foo class that implements IBar
//
var fooType = modb.DefineType("Foo", TypeAttributes.Class | TypeAttributes.Public, typeof(object), new Type[] { ibarType });
fooType.CreateTypeInfo();
//
// Test what we created
//
object o = Activator.CreateInstance(fooType);
int result = 0;
result |= (int)ifooType.GetMethod("InstanceMethod").Invoke(o, null);
result |= (int)ifooType.GetMethod("DefaultMethod").Invoke(o, null);
result |= (int)ifooType.GetMethod("InterfaceMethod").Invoke(o, null);
return(result == 0x07 ? 100 : result);
}
public InterfaceImplementor(Handler handler)
{
Type intf = typeof(TInterface);
string intname = intf.Name;
if (!intf.IsInterface)
{
throw new ArgumentException("TInterface is not an interface");
}
AssemblyName asmName = new AssemblyName();
asmName.Name = intname + "Implementation";
AppDomain ad = AppDomain.CurrentDomain;
AssemblyBuilder ab = ad.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);
ModuleBuilder mb = ab.DefineDynamicModule(asmName.Name, asmName.Name + ".dll");
TypeBuilder tb = mb.DefineType(
asmName.Name + "Impl",
TypeAttributes.Class,
typeof(MarshalByRefObject),
new Type[] { intf });
FieldBuilder methodHandler = tb.DefineField(
"handler",
typeof(Handler),
FieldAttributes.Private);
ConstructorInfo baseConstructorInfo = typeof(object).GetConstructor(new Type[0]);
ConstructorBuilder cb = tb.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
new Type[] { typeof(Handler) });
// Make the constructor
ILGenerator gen = cb.GetILGenerator();
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Call, baseConstructorInfo);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Stfld, methodHandler);
gen.Emit(OpCodes.Ret);
foreach (MethodInfo mi in intf.GetMethods())
{
ParameterInfo[] pis = mi.GetParameters();
MethodBuilder method = tb.DefineMethod(
mi.Name,
MethodAttributes.Public |
MethodAttributes.Virtual |
MethodAttributes.Final |
MethodAttributes.HideBySig |
MethodAttributes.NewSlot,
CallingConventions.Standard,
mi.ReturnType,
ArrayUtils.ConvertAll(pis, x => x.ParameterType));
ILGenerator mgen = method.GetILGenerator();
LocalBuilder lb = mgen.DeclareLocal(typeof(object[]));
mgen.Emit(OpCodes.Nop);
mgen.Emit(OpCodes.Ldarg_0);
mgen.Emit(OpCodes.Ldfld, methodHandler);
mgen.Emit(OpCodes.Ldstr, mi.Name);
// Make the object array
if (pis.Length == 0)
{
mgen.Emit(OpCodes.Ldc_I4_0);
}
else if (pis.Length == 1)
{
mgen.Emit(OpCodes.Ldc_I4_1);
}
else if (pis.Length == 2)
{
mgen.Emit(OpCodes.Ldc_I4_2);
}
else if (pis.Length == 3)
{
mgen.Emit(OpCodes.Ldc_I4_3);
}
else if (pis.Length == 4)
{
mgen.Emit(OpCodes.Ldc_I4_4);
}
else if (pis.Length == 5)
{
mgen.Emit(OpCodes.Ldc_I4_5);
}
else if (pis.Length == 6)
{
mgen.Emit(OpCodes.Ldc_I4_6);
}
else if (pis.Length == 7)
{
mgen.Emit(OpCodes.Ldc_I4_7);
}
else if (pis.Length == 8)
{
mgen.Emit(OpCodes.Ldc_I4_8);
}
else
{
mgen.Emit(OpCodes.Ldc_I4, pis.Length);
}
mgen.Emit(OpCodes.Newarr, typeof(object));
mgen.Emit(OpCodes.Stloc_0);
for (int i = 0; i < pis.Length; i++)
{
// Load the object array
mgen.Emit(OpCodes.Ldloc_0);
if (i == 0)
{
mgen.Emit(OpCodes.Ldc_I4_0);
mgen.Emit(OpCodes.Ldarg_1);
}
else
{
mgen.Emit(OpCodes.Ldc_I4, i);
mgen.Emit(OpCodes.Ldarg, i + 1);
}
if (pis[i].ParameterType.IsValueType)
{
mgen.Emit(OpCodes.Box, pis[i].ParameterType);
}
mgen.Emit(OpCodes.Stelem_Ref);
}
mgen.Emit(OpCodes.Ldloc_0);
mgen.EmitCall(
OpCodes.Callvirt,
typeof(Handler).GetMethod("Invoke"),
new Type[] { typeof(object) });
if (mi.ReturnType == typeof(void))
{
mgen.Emit(OpCodes.Pop);
}
mgen.Emit(OpCodes.Ret);
tb.DefineMethodOverride(method, mi);
}
Type t = tb.CreateType();
ab.Save(asmName.Name + ".dll");
Interface = (TInterface)Activator.CreateInstance(t, handler);
}
public void CtorOneTest()
{
//test for the constructor with signature--
// public CustomAttributeBuilder(ConstructorInfo, object[]);
/*
* WE build a imaginary type as follows
* class TestType
* {
* [CustomAttribute("one","two")]
* public string Str;
*
* [CustomAttribute("hello","world")]
* public void Print()
* {Console.WriteLine("Hello World"); }
*
* }
* And then check for the validity of attributes in the test functions
*/
AssemblyName asmName = new AssemblyName();
asmName.Name = "TestAssembly.dll";
AssemblyBuilder asmBuilder = Thread.GetDomain().DefineDynamicAssembly(
asmName, AssemblyBuilderAccess.Run);
ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("TestModule");
TypeBuilder typeBuilder = modBuilder.DefineType("TestType",
TypeAttributes.Public);
Type[] ctorParams = new Type[] { typeof(string), typeof(string) };
ConstructorInfo classCtorInfo =
typeof(CustomAttribute).GetConstructor(ctorParams);
CustomAttributeBuilder feildCABuilder = new CustomAttributeBuilder(
classCtorInfo,
new object [] { "one", "two" }
),
methodCABuilder = new CustomAttributeBuilder(
classCtorInfo,
new object [] { "hello", "world" }
);
//now let's build a feild of type string and associate a attribute with it
FieldBuilder fieldBuilder = typeBuilder.DefineField("Str",
typeof(string), FieldAttributes.Public);
fieldBuilder.SetCustomAttribute(feildCABuilder);
//now build a method
MethodBuilder methodBuilder = typeBuilder.DefineMethod("Print",
MethodAttributes.Public, null, null);
methodBuilder.SetCustomAttribute(methodCABuilder);
ILGenerator methodIL = methodBuilder.GetILGenerator();
methodIL.EmitWriteLine("Hello, world!");
methodIL.Emit(OpCodes.Ret);
// create the type
Type myType = typeBuilder.CreateType();
//Now check for the validity of the attributes.
object testInstance = Activator.CreateInstance(myType);
//check the validity of the attribute associated with Print method
object [] methodAttrs = myType.GetMember("Print") [0].GetCustomAttributes(true);
Assert.AreEqual(methodAttrs.Length, 1, "#1");
CustomAttribute methodAttr = methodAttrs [0] as CustomAttribute;
Assert.AreEqual(methodAttr.AttributeOne, "hello", "#2");
Assert.AreEqual(methodAttr.AttributeTwo, "world", "#3");
//check the validity of the attribute associated with Str feild
object [] fieldAttrs = myType.GetField("Str").GetCustomAttributes(true);
Assert.AreEqual(fieldAttrs.Length, 1, "#4");
CustomAttribute fieldAttr = fieldAttrs [0] as CustomAttribute;
Assert.AreEqual(fieldAttr.AttributeOne, "one", "#5");
Assert.AreEqual(fieldAttr.AttributeTwo, "two", "#6");
}
private static ModuleBuilder BuildModule(AssemblyBuilder ab)
{
return(ab.DefineDynamicModule(assemblyName, assemblyName + ".dll"));
}
public void StoreReference()
{
Reference wrappedReference = _mockRepository.StrictMock <Reference> ();
ILGenerator gen = new DynamicMethod("Foo", typeof(void), Type.EmptyTypes, AssemblyBuilder.GetExecutingAssembly().ManifestModule).GetILGenerator();
// expect
wrappedReference.StoreReference(gen);
_mockRepository.ReplayAll();
TypeReferenceWrapper tr = new TypeReferenceWrapper(wrappedReference, typeof(int));
tr.StoreReference(gen);
_mockRepository.VerifyAll();
}
private void WriteAssemblyAttributes(CompilerOptions options, string assemblyName, AssemblyBuilder asm)
{
if (!Helpers.IsNullOrEmpty(options.TargetFrameworkName))
{
// get [TargetFramework] from mscorlib/equivalent and burn into the new assembly
Type versionAttribType = null;
try
{ // this is best-endeavours only
versionAttribType = GetType("System.Runtime.Versioning.TargetFrameworkAttribute", MapType(typeof(string)).Assembly);
}
catch { /* don't stress */ }
if (versionAttribType != null)
{
PropertyInfo[] props;
object[] propValues;
if (Helpers.IsNullOrEmpty(options.TargetFrameworkDisplayName))
{
props = new PropertyInfo[0];
propValues = new object[0];
}
else
{
props = new PropertyInfo[1] { versionAttribType.GetProperty("FrameworkDisplayName") };
propValues = new object[1] { options.TargetFrameworkDisplayName };
}
CustomAttributeBuilder builder = new CustomAttributeBuilder(
versionAttribType.GetConstructor(new Type[] { MapType(typeof(string)) }),
new object[] { options.TargetFrameworkName },
props,
propValues);
asm.SetCustomAttribute(builder);
}
}
// copy assembly:InternalsVisibleTo
Type internalsVisibleToAttribType = null;
#if !FX11
try
{
internalsVisibleToAttribType = MapType(typeof(System.Runtime.CompilerServices.InternalsVisibleToAttribute));
}
catch { /* best endeavors only */ }
#endif
if (internalsVisibleToAttribType != null)
{
BasicList internalAssemblies = new BasicList(), consideredAssemblies = new BasicList();
foreach (MetaType metaType in types)
{
Assembly assembly = metaType.Type.Assembly;
if (consideredAssemblies.IndexOfReference(assembly) >= 0) continue;
consideredAssemblies.Add(assembly);
AttributeMap[] assemblyAttribsMap = AttributeMap.Create(this, assembly);
for (int i = 0; i < assemblyAttribsMap.Length; i++)
{
if (assemblyAttribsMap[i].AttributeType != internalsVisibleToAttribType) continue;
object privelegedAssemblyObj;
assemblyAttribsMap[i].TryGet("AssemblyName", out privelegedAssemblyObj);
string privelegedAssemblyName = privelegedAssemblyObj as string;
if (privelegedAssemblyName == assemblyName || Helpers.IsNullOrEmpty(privelegedAssemblyName)) continue; // ignore
if (internalAssemblies.IndexOfString(privelegedAssemblyName) >= 0) continue; // seen it before
internalAssemblies.Add(privelegedAssemblyName);
CustomAttributeBuilder builder = new CustomAttributeBuilder(
internalsVisibleToAttribType.GetConstructor(new Type[] { MapType(typeof(string)) }),
new object[] { privelegedAssemblyName });
asm.SetCustomAttribute(builder);
}
}
}
}
public Context(ILGenerator il)
{
Sink = new AssemblyBuilder(il);
EndOfTemplate = Sink.DefineLabel();
}
/// <summary>
/// 构建一个无法保存的动态程序集 ModuleScope 模块
/// </summary>
public ModuleScope()
{
_assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(NameOfAssembly), AssemblyBuilderAccess.Run);
ModuleBuilder = _assemblyBuilder.DefineDynamicModule(NameOfAssembly);
SavePhysicalAssembly = false;
}
// Methods
/* private scope */ static void Main()
{
Console.WriteLine("CodeTrace was used to record the steps to build a specific assembly.");
Console.WriteLine("CodeTrace started at 28/06/2010 11:46:26");
_ct_Product_Name = "TestCodeTrace.Rewrite.exe";
Dictionary<int, Type> dictionary = new Dictionary<int, Type>();
dictionary.Add(0, null);
dictionary.Add(typeof(object).GetHashCode(), typeof(object));
_ct_SourceTypeHashToTypeLookup = dictionary;
Dictionary<int, MethodBuilder> dictionary2 = new Dictionary<int, MethodBuilder>();
dictionary2.Add(0, null);
_ct_SourceMethodHashToMethodBuilderLookup = dictionary2;
_ct_SourceMethodHashToILGeneratorLookup = new Dictionary<int, Func<ILGenerator>>();
a = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(Path.GetFileNameWithoutExtension(_ct_Product_Name)), AssemblyBuilderAccess.RunAndSave, @"W:\jsc.svn\examples\rewrite\TestCodeTrace\TestCodeTrace\bin\Debug\staging");
m = a.DefineDynamicModule(Path.GetFileNameWithoutExtension(_ct_Product_Name), "~TestCodeTrace.Rewrite.exe");
DefineTypeName = "TestCodeTrace.Program";
Console.WriteLine("CodeTrace DefineType " + DefineTypeName);
DeclaringType = m.DefineType(DefineTypeName, TypeAttributes.BeforeFieldInit, _ct_SourceTypeHashToTypeLookup[0], new Type[0]);
_ct_SourceTypeHashToTypeLookup[0x52a258] = DeclaringType;
(_ct_SourceTypeHashToTypeLookup[0x52a258] as TypeBuilder).SetParent(_ct_SourceTypeHashToTypeLookup[0x704e84dc]);
DeclaringMethod = (_ct_SourceTypeHashToTypeLookup[0x52a258] as TypeBuilder).DefineMethod("Main", MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.FamORAssem, CallingConventions.Standard, null, null);
_ct_SourceMethodHashToMethodBuilderLookup[-1395084204] = DeclaringMethod;
_ct_SourceMethod = -1395084204;
_ct_SourceMethodHashToILGeneratorLookup[_ct_SourceMethod] = new Func<ILGenerator>(_ct_SourceMethodHashToMethodBuilderLookup[_ct_SourceMethod].GetILGenerator);
_ct_SourceMethodHashToILGeneratorLookup[-1395084204]().Emit(OpCodes.Nop);
_ct_SourceMethodHashToILGeneratorLookup[-1395084204]().Emit(OpCodes.Ret);
DeclaringMethod = (_ct_SourceTypeHashToTypeLookup[0x52a258] as TypeBuilder).DefineMethod("Method2", MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.Private, CallingConventions.Standard, null, null);
_ct_SourceMethodHashToMethodBuilderLookup[-1395116976] = DeclaringMethod;
_ct_SourceMethod = -1395116976;
_ct_SourceMethodHashToILGeneratorLookup[_ct_SourceMethod] = new Func<ILGenerator>(_ct_SourceMethodHashToMethodBuilderLookup[_ct_SourceMethod].GetILGenerator);
DefineTypeName = "TestCodeTrace.IDocument`1";
Console.WriteLine("CodeTrace DefineType " + DefineTypeName);
DeclaringType = m.DefineType(DefineTypeName, TypeAttributes.BeforeFieldInit | TypeAttributes.Public, _ct_SourceTypeHashToTypeLookup[0], new Type[0]);
_ct_SourceTypeHashToTypeLookup[0x41330fc] = DeclaringType;
(_ct_SourceTypeHashToTypeLookup[0x41330fc] as TypeBuilder).SetParent(_ct_SourceTypeHashToTypeLookup[0x704e84dc]);
_ct_GenericParameters = (_ct_SourceTypeHashToTypeLookup[0x41330fc] as TypeBuilder).DefineGenericParameters(new string[] { "TConstraint1" });
List<Type> list = new List<Type>();
foreach (int num in new int[] { 0x704e84dc })
{
list.Add(_ct_SourceTypeHashToTypeLookup[num]);
}
_ct_DeclaringType = _ct_SourceTypeHashToTypeLookup[0x41330fc].MakeGenericType(list.ToArray());
_ct_SourceTypeHashToTypeLookup[0x41331e0] = _ct_DeclaringType;
DefineTypeName = "TestCodeTrace.IXMLDocument";
Console.WriteLine("CodeTrace DefineType " + DefineTypeName);
DeclaringType = m.DefineType(DefineTypeName, TypeAttributes.BeforeFieldInit | TypeAttributes.Public, _ct_SourceTypeHashToTypeLookup[0], new Type[0]);
_ct_SourceTypeHashToTypeLookup[0x4133dec] = DeclaringType;
(_ct_SourceTypeHashToTypeLookup[0x4133dec] as TypeBuilder).SetParent(_ct_SourceTypeHashToTypeLookup[0x41331e0]);
DeclaringMethod = (_ct_SourceTypeHashToTypeLookup[0x4133dec] as TypeBuilder).DefineMethod("Method2", MethodAttributes.HideBySig | MethodAttributes.Private, CallingConventions.HasThis | CallingConventions.Standard, null, null);
_ct_SourceMethodHashToMethodBuilderLookup[-1129754532] = DeclaringMethod;
_ct_SourceMethod = -1129754532;
_ct_SourceMethodHashToILGeneratorLookup[_ct_SourceMethod] = new Func<ILGenerator>(_ct_SourceMethodHashToMethodBuilderLookup[_ct_SourceMethod].GetILGenerator);
_ct_SourceMethodHashToILGeneratorLookup[-1129754532]().Emit(OpCodes.Nop);
_ct_SourceMethodHashToILGeneratorLookup[-1129754532]().Emit(OpCodes.Ret);
DeclaringField = (_ct_SourceTypeHashToTypeLookup[0x41330fc] as TypeBuilder).DefineField("__Type1", _ct_SourceTypeHashToTypeLookup[0x4133dec], FieldAttributes.Public);
Console.WriteLine("CodeTrace CreateType: " + "TestCodeTrace.IDocument`1");
(_ct_SourceTypeHashToTypeLookup[0x41330fc] as TypeBuilder).CreateType();
Console.WriteLine("CodeTrace CreateType: " + "TestCodeTrace.IXMLDocument");
(_ct_SourceTypeHashToTypeLookup[0x4133dec] as TypeBuilder).CreateType();
_ct_SourceMethodHashToILGeneratorLookup[-1395116976]().Emit(OpCodes.Nop);
_ct_SourceMethodHashToILGeneratorLookup[-1395116976]().Emit(OpCodes.Ret);
Console.WriteLine("CodeTrace CreateType: " + "TestCodeTrace.Program");
(_ct_SourceTypeHashToTypeLookup[0x52a258] as TypeBuilder).CreateType();
m.CreateGlobalFunctions();
a.Save("~TestCodeTrace.Rewrite.exe");
Console.WriteLine("CodeTrace ended at 28/06/2010 11:46:28");
}
public static void CreateReflectedAssembly()
{
AssemblyName AsmName = new AssemblyName("ReflectedTypes");
AsmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(AsmName, AssemblyBuilderAccess.RunAndSave);
ReflectedModule = AsmBuilder.DefineDynamicModule(AsmName.Name, AsmName.Name + ".dll");
}
internal override void Apply(ClassLoaderWrapper loader, AssemblyBuilder ab, object annotation)
{
Annotation annot = type.Annotation;
foreach (object ann in UnwrapArray(annotation))
{
annot.Apply(loader, ab, ann);
}
}
public static void VerifyAssemblyBuilder(AssemblyBuilder assembly, AssemblyName name, IEnumerable<CustomAttributeBuilder> attributes)
{
Assert.Equal(name.ToString(), assembly.FullName);
Assert.Equal(name.ToString(), assembly.GetName().ToString());
Assert.True(assembly.IsDynamic);
Assert.Equal(attributes?.Count() ?? 0, assembly.CustomAttributes.Count());
Assert.Equal(1, assembly.Modules.Count());
Module module = assembly.Modules.First();
Assert.NotEmpty(module.Name);
Assert.Equal(assembly.Modules, assembly.GetModules());
Assert.Empty(assembly.DefinedTypes);
Assert.Empty(assembly.GetTypes());
}
public void Resolve(string assemblyName, string dllName)
{
// create assembly and module
AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName(assemblyName),
AssemblyBuilderAccess.Save
);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName, dllName);
// create Inanity.Object type
TypeBuilder inanityObjectTypeBuilder = moduleBuilder.DefineType(
"Inanity.Object",
TypeAttributes.Public | TypeAttributes.Abstract,
null, // parent
new Type[] {
typeof(IDisposable)
}
);
inanityObjectTypeBuilder.DefineField(
"ptr",
typeof(UIntPtr),
FieldAttributes.Family
);
ConstructorBuilder inanityObjectConstructorBuilder = inanityObjectTypeBuilder.DefineDefaultConstructor(MethodAttributes.Family);
{
MethodBuilder disposeMethod = inanityObjectTypeBuilder.DefineMethod(
"Dispose",
MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig,
typeof(void),
new Type[] { }
);
disposeMethod.SetImplementationFlags(MethodImplAttributes.InternalCall);
}
inanityObjectTypeBuilder.CreateType();
// create type bulders for all classes
foreach (string fullClassName in classes.Keys)
{
classes[fullClassName].typeBuilder = moduleBuilder.DefineType(
fullClassName,
TypeAttributes.Public | (classes[fullClassName].constructor == null ? TypeAttributes.Abstract : 0)
);
}
// lambda for resolving types
Func <string, Type> resolveType = delegate(string typeName)
{
switch (typeName)
{
case "void":
return(typeof(void));
case "bool":
return(typeof(bool));
case "int32":
return(typeof(Int32));
case "uint32":
return(typeof(UInt32));
case "int64":
return(typeof(Int64));
case "uint64":
return(typeof(UInt64));
case "float":
return(typeof(float));
case "double":
return(typeof(double));
case "string":
return(typeof(string));
case "object":
return(typeof(object));
default:
{
ClassDesc classDesc;
if (!classes.TryGetValue(typeName, out classDesc))
{
throw new Exception("Cannot resolve type " + typeName);
}
return(classDesc.typeBuilder);
}
}
};
// set parents, create constructors and methods
foreach (string className in classes.Keys)
{
ClassDesc classDesc = classes[className];
TypeBuilder typeBuilder = classDesc.typeBuilder;
// set parent
{
TypeBuilder parentTypeBuilder;
if (classDesc.parentClassName != null)
{
if (!classes.TryGetValue(classDesc.parentClassName, out classDesc.parentClassDesc))
{
throw new Exception("Parent class " + classDesc.parentClassName + " is not registered");
}
parentTypeBuilder = classDesc.parentClassDesc.typeBuilder;
}
else
{
parentTypeBuilder = inanityObjectTypeBuilder;
}
typeBuilder.SetParent(parentTypeBuilder);
}
// set constructor
{
ConstructorDesc constructorDesc = classDesc.constructor;
if (constructorDesc != null)
{
Type[] argumentTypes = constructorDesc.argumentTypes.Select(resolveType).ToArray();
// define extern thunk method
MethodBuilder methodBuilder = typeBuilder.DefineMethod(
"__c",
MethodAttributes.Private,
CallingConventions.HasThis,
typeof(void),
argumentTypes
);
methodBuilder.SetImplementationFlags(MethodImplAttributes.InternalCall);
classDesc.constructorThunkMethodBuilder = methodBuilder;
// define constructor
ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.HasThis,
argumentTypes
);
classDesc.constructorBuilder = constructorBuilder;
}
else
{
classDesc.constructorBuilder = typeBuilder.DefineDefaultConstructor(MethodAttributes.Family);
}
}
// add methods
foreach (string methodName in classDesc.methods.Keys)
{
MethodDesc methodDesc = classDesc.methods[methodName];
MethodBuilder methodBuilder = typeBuilder.DefineMethod(
methodName,
MethodAttributes.Public | MethodAttributes.Final,
CallingConventions.HasThis,
resolveType(methodDesc.returnType),
methodDesc.argumentTypes.Select(resolveType).ToArray()
);
methodBuilder.SetImplementationFlags(MethodImplAttributes.InternalCall);
}
// add static methods
foreach (string staticMethodName in classDesc.staticMethods.Keys)
{
FunctionDesc functionDesc = classDesc.staticMethods[staticMethodName];
MethodBuilder methodBuilder = typeBuilder.DefineMethod(
staticMethodName,
MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Static,
CallingConventions.Standard,
resolveType(functionDesc.returnType),
functionDesc.argumentTypes.Select(resolveType).ToArray()
);
methodBuilder.SetImplementationFlags(MethodImplAttributes.InternalCall);
}
}
// emit code for constructors
foreach (ClassDesc classDesc in classes.Values)
{
ConstructorDesc constructorDesc = classDesc.constructor;
if (constructorDesc == null)
{
continue;
}
Type[] argumentTypes = constructorDesc.argumentTypes.Select(resolveType).ToArray();
ILGenerator ilGenerator = classDesc.constructorBuilder.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Call,
classDesc.parentClassDesc != null
? classDesc.parentClassDesc.constructorBuilder
: inanityObjectConstructorBuilder
);
ilGenerator.Emit(OpCodes.Ldarg_0);
for (int i = 0; i < argumentTypes.Length; ++i)
{
ilGenerator.Emit(OpCodes.Ldarg, i + 1);
}
ilGenerator.Emit(OpCodes.Call, classDesc.constructorThunkMethodBuilder);
ilGenerator.Emit(OpCodes.Ret);
}
// create types
foreach (ClassDesc classDesc in classes.Values)
{
classDesc.typeBuilder.CreateType();
}
// save assembly
assemblyBuilder.Save(dllName);
}
public override void GenerateCode (AssemblyBuilder assemblyBuilder)
{
/* do nothing */
}
public void SaveAssembly()
{
_assmblyBuilder.Save(_assmblyBuilder.GetName().Name + ".dll");
_assmblyBuilder = null;
}
public void Equals(AssemblyBuilder assembly, object obj, bool expected)
{
Assert.Equal(expected, assembly.Equals(obj));
if (obj is AssemblyBuilder)
{
Assert.Equal(expected, assembly.GetHashCode().Equals(obj.GetHashCode()));
}
}
public static ModuleBuilder GetModuleBuilder(AssemblyBuilder asmBuild, string moduleName)
{
return asmBuild.DefineDynamicModule(moduleName);
}
//==== Helpers ===================================================
// Prepare an assembly
private void PrepareAssembly( string typeName, bool bSave )
{
AssemblyBuilderAccess acc = bSave ? AssemblyBuilderAccess.Save:AssemblyBuilderAccess.Run;
AssemblyName aName = new AssemblyName();
aName.Name = typeName;
appdomain = AppDomain.CurrentDomain;
assemblybuilder = appdomain.DefineDynamicAssembly( aName, acc );
modulebuilder = assemblybuilder.DefineDynamicModule( typeName+".dll" );
typebuilder = modulebuilder.DefineType( typeName, TypeAttributes.Public );
}
