public void Test()
{
EmitHelper emit = new AssemblyBuilderHelper("HelloWorld.dll")
.DefineType ("Hello", typeof(object), typeof(IHello))
.DefineMethod(typeof(IHello).GetMethod("SayHello"))
.Emitter;
/*[a]*/emit/*[/a]*/
// string.Format("Hello, {0}!", toWhom)
//
./*[a]*/ldstr/*[/a]*/ ("Hello, {0}!")
./*[a]*/ldarg_1/*[/a]*/
./*[a]*/call/*[/a]*/ (typeof(string), "Format", typeof(string), typeof(object))
// Console.WriteLine("Hello, World!");
//
./*[a]*/call/*[/a]*/ (typeof(Console), "WriteLine", typeof(string))
./*[a]*/ret/*[/a]*/()
;
Type type = emit.Method.Type.Create();
IHello hello = (IHello)TypeAccessor.CreateInstance(type);
hello.SayHello("World");
}
public static IExecutor CreateExecutor(object service, MethodInfo method)
{
if (service == null)
{
throw new ArgumentNullException("Cannot create a null executor");
}
var type = service.GetType();
var typeName = type.Name + method.Name;
var assemblyBuilderHelper = new AssemblyBuilderHelper(typeName + "_Executor" + ".dll");
var typeBuilderHelper = assemblyBuilderHelper.DefineType(typeName, typeof(object),
typeof (IExecutor));
var serviceFieldBuilder = typeBuilderHelper.DefineField(type.Name, type, FieldAttributes.Public);
var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance);
var emit = typeBuilderHelper.DefineMethod(typeof(IExecutor).GetMethod("Execute")).Emitter;
var returnType = method.ReturnType;
var paramInfos = method.GetParameters();
emit
.ldarg_0
.ldfld(serviceFieldBuilder);
for (var j = 0; j < paramInfos.Length; j++)
{
var paramInfo = paramInfos[j];
var paramType = paramInfo.ParameterType;
emit = emit
.ldarg_1
.ldc_i4(j)
.ldelem_ref;
if (paramType.IsValueType)
{
emit
.unbox_any(paramType);
}
else if (paramType.IsClass || paramType.IsInterface)
{
emit.castclass(paramType);
}
}
emit.call(method);
if (returnType != typeof(void))
{
emit
.boxIfValueType(returnType)
.ret();
}
else
{
emit
.ldnull
.ret();
}
var executorType = typeBuilderHelper.Create();
var executor = (IExecutor) TypeAccessor.CreateInstance(executorType);
var serviceField = executorType.GetField(type.Name);
serviceField.SetValue(executor, service);
#if DEBUG
assemblyBuilderHelper.Save();
#endif
return executor;
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeBuilderHelper"/> class
/// with the specified parameters.
/// </summary>
/// <param name="assemblyBuilder">Associated <see cref="AssemblyBuilderHelper"/>.</param>
/// <param name="typeBuilder">A <see cref="TypeBuilder"/></param>
public TypeBuilderHelper(AssemblyBuilderHelper assemblyBuilder, System.Reflection.Emit.TypeBuilder typeBuilder)
{
if (assemblyBuilder == null) throw new ArgumentNullException("assemblyBuilder");
if (typeBuilder == null) throw new ArgumentNullException("typeBuilder");
_assembly = assemblyBuilder;
_typeBuilder = typeBuilder;
_typeBuilder.SetCustomAttribute(_assembly.BLToolkitAttribute);
}
public Type Build(Type sourceType, AssemblyBuilderHelper assemblyBuilder)
{
if (sourceType == null) throw new ArgumentNullException("sourceType");
if (assemblyBuilder == null) throw new ArgumentNullException("assemblyBuilder");
// Check InternalsVisibleToAttributes of the source type's assembly.
// Even if the sourceType is public, it may have internal fields and props.
//
_friendlyAssembly = false;
// Usually, there is no such attribute in the source assembly.
// Therefore we do not cache the result.
//
object[] attributes = sourceType.Assembly.GetCustomAttributes(typeof(InternalsVisibleToAttribute), true);
foreach (InternalsVisibleToAttribute visibleToAttribute in attributes)
{
AssemblyName an = new AssemblyName(visibleToAttribute.AssemblyName);
if (AssemblyName.ReferenceMatchesDefinition(assemblyBuilder.AssemblyName, an))
{
_friendlyAssembly = true;
break;
}
}
if (!sourceType.IsVisible && !_friendlyAssembly)
throw new TypeBuilderException(string.Format("Can not build type accessor for non-public type '{0}'.", sourceType.FullName));
string typeName = GetTypeAccessorClassName(_type);
_typeBuilder = assemblyBuilder.DefineType(typeName, _accessorType);
_typeBuilder.DefaultConstructor.Emitter
.ldarg_0
.call (TypeHelper.GetDefaultConstructor(_accessorType))
;
BuildCreateInstanceMethods();
BuildTypeProperties();
BuildMembers();
BuildObjectFactory();
_typeBuilder.DefaultConstructor.Emitter
.ret()
;
Type result = _typeBuilder.Create();
foreach (TypeBuilderHelper tb in _nestedTypes)
tb.Create();
return result;
}
/// <summary>
/// Creates a new instance of the TypeCreator class
/// </summary>
/// <param name="configurator"></param>
public TypeCreator(MDataConfigurator configurator)
{
_configurator = configurator;
_assemblyBuilder = new AssemblyBuilderHelper(_configurator.AssemblyNameForStorage, new Version(1,0),null);
_assemblyBuilder.AssemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(typeof(SecurityRulesAttribute).GetConstructors()[0], new object[] { SecurityRuleSet.Level1 }));
_assemblyBuilder.AssemblyName.Flags |= AssemblyNameFlags.Retargetable;
_scannedAssemblies = new Collection<string>();
_domainToLogic = new Dictionary<Type, Type>();
_domainCache = new Dictionary<Type, Type>();
}
public Type Build(AssemblyBuilderHelper assemblyBuilder)
{
_typeBuilder = assemblyBuilder.DefineType(GetTypeName(), typeof(DuckType), _interfaceType);
if (!BuildMembers(_interfaceType))
return null;
foreach (Type t in _interfaceType.GetInterfaces())
if (!BuildMembers(t))
return null;
return _typeBuilder.Create();
}
public static void SaveGlobalAssembly()
{
if (_globalAssembly != null)
{
_globalAssembly.Save();
WriteDebug("The global assembly saved in '{0}'.", _globalAssembly.Path);
_globalAssembly = null;
_globalAssemblyPath = null;
_globalAssemblyVersion = null;
_globalAssemblyKeyFile = null;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeBuilderHelper"/> class
/// with the specified parameters.
/// </summary>
/// <param name="assemblyBuilder">Associated <see cref="AssemblyBuilderHelper"/>.</param>
/// <param name="typeBuilder">A <see cref="TypeBuilder"/></param>
public TypeBuilderHelper(AssemblyBuilderHelper assemblyBuilder, System.Reflection.Emit.TypeBuilder typeBuilder)
{
if (assemblyBuilder == null)
{
throw new ArgumentNullException("assemblyBuilder");
}
if (typeBuilder == null)
{
throw new ArgumentNullException("typeBuilder");
}
_assembly = assemblyBuilder;
_typeBuilder = typeBuilder;
_typeBuilder.SetCustomAttribute(_assembly.BLToolkitAttribute);
}
public void RegisterService(object service, bool isOverride)
{
var originalAsmName = new AssemblyName("NTSock" + service.GetType().FullName);
var assemblyBuilderHelper = new AssemblyBuilderHelper(originalAsmName.Name + ".dll");
servicesLock.EnterWriteLock();
try
{
var serviceType = service.GetType();
var methods = serviceType.GetMethods();
if (methods != null)
{
for (var i = 0; i < methods.Length; i++)
{
var method = methods[i];
if (method.GetCustomAttributes(typeof(ServiceMethodAttribute), false).Length == 0)
{
continue;
}
var executor = ExecutorFactory.CreateExecutor(service, method, i, assemblyBuilderHelper);
if (methodMaps.ContainsKey(executor.ExecutorKey))
{
if (!isOverride)
{
throw new ArgumentException("Cannot override an existing service.");
}
methodMaps.Remove(executor.ExecutorKey);
}
methodMaps.Add(executor.ExecutorKey, executor);
}
ExecutorFactory.CreateProxy(service, assemblyBuilderHelper);
}
#if DEBUG
assemblyBuilderHelper.Save();
#endif
}
finally
{
servicesLock.ExitWriteLock();
}
}
public DbFunctionHelperManager()
{
dbFunctionHelperMap = new Dictionary<Type, IDbFunctionHelper>();
dbMapLock = new ReaderWriterLockSlim();
assemblyBuilderHelper = new AssemblyBuilderHelper("DbFunctionBuilderHelper.dll");
}
private static Type CreateResponseType(string typeName, Type returnType, AssemblyBuilderHelper assemblyBuilderHelper)
{
if (returnType == typeof(void))
{
return typeof(VoidResultResponse);
}
var responseType = typeName + "Response";
var typeBuilderHelper = assemblyBuilderHelper.DefineType("Response." + responseType, typeof(Response));
var resultField = typeBuilderHelper.DefineField("result", returnType, FieldAttributes.Public);
var constructorEmit = typeBuilderHelper.DefinePublicConstructor(returnType).Emitter;
var defaulConstructor = typeof(Response).GetConstructor(Type.EmptyTypes);
constructorEmit
.ldarg_0
.call(defaulConstructor)
.ldarg_0
.ldarg_1
.stfld(resultField)
.ret();
constructorEmit = typeBuilderHelper.DefinePublicConstructor(Type.EmptyTypes).Emitter;
constructorEmit
.ldarg_0
.call(defaulConstructor)
.ret();
var resultProperty = typeBuilderHelper.TypeBuilder.DefineProperty("Result", PropertyAttributes.None, returnType,
new[] {returnType});
var getResultPropertyMethod = typeBuilderHelper.DefineMethod("get_Result",
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig, returnType, Type.EmptyTypes);
var getResultPropertyMethodEmit = getResultPropertyMethod.Emitter;
getResultPropertyMethodEmit
.ldarg_0
.ldfld(resultField)
.ret();
var setResultPropertyMethod = typeBuilderHelper.DefineMethod("set_Result",
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig, null, returnType);
var setResultPropertyMethodEmit = setResultPropertyMethod.Emitter;
setResultPropertyMethodEmit
.ldarg_0
.ldarg_1
.stfld(resultField)
.ret();
resultProperty.SetGetMethod(getResultPropertyMethod);
resultProperty.SetSetMethod(setResultPropertyMethod);
var getResultMethod = typeof (Response).GetMethod("GetResult");
var getResultMethodEmit = typeBuilderHelper.DefineMethod(getResultMethod).Emitter;
getResultMethodEmit
.ldarg_0
.ldfld(resultField)
.boxIfValueType(returnType)
.ret();
return typeBuilderHelper.Create();
}
public static void CreateProxy(object service, AssemblyBuilderHelper assemblyBuilderHelper)
{
if (service == null)
{
throw new ArgumentNullException("Cannot create null proxy");
}
var serviceType = service.GetType();
var proxyTypeName = serviceType.Namespace + "." + serviceType.Name + "Proxy";
var proxyType = assemblyBuilderHelper.DefineType(proxyTypeName, typeof (IProxy));
var serviceContainerField = typeof (IProxy).GetField("container", BindingFlags.Instance | BindingFlags.NonPublic);
var poolField = typeof (IProxy).GetField("pool", BindingFlags.Instance | BindingFlags.NonPublic);
var defaultConstructor = typeof (IProxy).GetConstructor(Type.EmptyTypes);
var construtorEmit = proxyType.DefinePublicConstructor(typeof (ServiceContainer), typeof (SocketPool)).Emitter;
construtorEmit
.ldarg_0
.call(defaultConstructor)
.ldarg_0
.ldarg_1
.stfld(serviceContainerField)
.ldarg_0
.ldarg_2
.stfld(poolField)
.ret();
var methods = serviceType.GetMethods(BindingFlags.Instance | BindingFlags.Public);
for (var i = 0; i < methods.Length; i++)
{
var method = methods[i];
if (method.GetCustomAttributes(typeof(ServiceMethodAttribute), false).Length == 0)
{
continue;
}
var returnType = method.ReturnType;
var requestTypeName = "Request." + serviceType.Name + "_" + method.Name + i + "Request";
var requestType = assemblyBuilderHelper.AssemblyBuilder.GetType(requestTypeName);
if (requestType == null)
{
throw new ApplicationException("Cannot find request type: " + requestTypeName);
}
var responseTypeName = "Response." + serviceType.Name + "_" + method.Name + i + "Response";
var responseType = returnType != typeof(void) ? assemblyBuilderHelper.AssemblyBuilder.GetType(responseTypeName) : typeof(VoidResultResponse);
if (responseType == null)
{
throw new ApplicationException("Cannot find response type: " + responseTypeName);
}
var paramInfos = method.GetParameters();
var synParamTypes = new Type[paramInfos.Length];
var asyncParamTypes = new Type[paramInfos.Length + 2];
asyncParamTypes[0] = typeof(WaitCallback); //callback function
asyncParamTypes[1] = typeof(object); //context param
for (var j = 0; j < synParamTypes.Length; j++)
{
synParamTypes[j] = paramInfos[j].ParameterType;
asyncParamTypes[j + 2] = paramInfos[j].ParameterType;
}
//Generate synchronous proxy method
var synchronousMethodEmit = synParamTypes.Length == 0
? proxyType.DefineMethod(method.Name, MethodAttributes.Public, returnType,
Type.EmptyTypes).Emitter
: proxyType.DefineMethod(method.Name, MethodAttributes.Public, returnType, synParamTypes).Emitter;
var syncRequestLocal = synchronousMethodEmit.DeclareLocal(requestType);
synchronousMethodEmit
.newobj(requestType)
.stloc(syncRequestLocal);
synchronousMethodEmit = synchronousMethodEmit.ldarg_0;
for (var j = 1; j <= paramInfos.Length; j++)
{
synchronousMethodEmit
.ldloc(syncRequestLocal)
.ldarg(j)
.stfld(requestType.GetField(paramInfos[j - 1].Name));
}
if (returnType == typeof(void))
{
synchronousMethodEmit
.ldloc(syncRequestLocal)
.call(typeof (IProxy).GetMethod("DoRequest", BindingFlags.Instance | BindingFlags.NonPublic))
.ret();
}
else
{
var doRequestMethod =
typeof (IProxy).GetMethod("RequestSync", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(
returnType);
synchronousMethodEmit
.ldloc(syncRequestLocal)
.call(doRequestMethod)
.ret();
}
//Generate asynchronous proxy method
var asynchronousMethodEmit = proxyType.DefineMethod("Begin" + method.Name, MethodAttributes.Public, null, asyncParamTypes).Emitter;
var asynRequestLocal = asynchronousMethodEmit.DeclareLocal(requestType);
asynchronousMethodEmit
.newobj(requestType)
.stloc(asynRequestLocal);
asynchronousMethodEmit = asynchronousMethodEmit.ldarg_0;
for (var j = 1; j <= paramInfos.Length; j++)
{
asynchronousMethodEmit
.ldloc(asynRequestLocal)
.ldarg(j + 2)
.stfld(requestType.GetField(paramInfos[j - 1].Name));
}
asynchronousMethodEmit
.ldloc(asynRequestLocal)
.ldarg_1
.ldarg_2
.call(typeof(IProxy).GetMethod("BeginRequest", BindingFlags.Instance | BindingFlags.NonPublic))
.ret();
}
proxyType.Create();
}
private static AssemblyBuilderHelper GetAssemblyBuilder(Type type, string suffix)
{
AssemblyBuilderHelper ab = GlobalAssemblyBuilder;
if (ab == null)
{
string assemblyDir = AppDomain.CurrentDomain.BaseDirectory;
// Dynamic modules are locationless, so ignore them.
// _ModuleBuilder is the base type for both
// ModuleBuilder and InternalModuleBuilder classes.
//
if (!(type.Module is _ModuleBuilder))
assemblyDir = Path.GetDirectoryName(type.Module.FullyQualifiedName);
string fullName = type.FullName;
if (type.IsGenericType)
fullName = AbstractClassBuilder.GetTypeFullName(type);
ab = new AssemblyBuilderHelper(assemblyDir + "\\" + fullName + "." + suffix + ".dll");
}
return ab;
}
private static Type CreateRequestType(string typeName, ParameterInfo[] infos, AssemblyBuilderHelper assemblyBuilderHelper)
{
var requestTypeName = typeName + "Request";
var typeBuilderHelper = assemblyBuilderHelper.DefineType("Request." + requestTypeName, typeof(Request));
var requestDescriptionField = typeof (Request).GetField("requestDescription");
var fieldInfos = new FieldInfo[infos.Length];
var propertyInfos = new PropertyBuilder[infos.Length];
var constructorEmit = typeBuilderHelper.DefinePublicConstructor(Type.EmptyTypes).Emitter;
var defaultConstructor = typeof (Request).GetConstructor(Type.EmptyTypes);
constructorEmit
.ldarg_0
.call(defaultConstructor)
.ldarg_0
.ldstr(typeName)
.stfld(requestDescriptionField)
.ret();
for (var i = 0; i < infos.Length; i++)
{
fieldInfos[i] = typeBuilderHelper.DefineField(infos[i].Name, infos[i].ParameterType, FieldAttributes.Public);
var propertyName = char.IsLower(infos[i].Name[0])
? char.ToUpper(infos[i].Name[0]) + infos[i].Name.Substring(1)
: infos[i].Name + "_";
propertyInfos[i] = typeBuilderHelper.TypeBuilder.DefineProperty(propertyName, PropertyAttributes.None,
infos[i].ParameterType,
new[] { infos[i].ParameterType });
var getPropertyMethod = typeBuilderHelper.DefineMethod("get_" + propertyName,
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig, infos[i].ParameterType,
Type.EmptyTypes);
var getPropertyMethodEmit = getPropertyMethod.Emitter;
getPropertyMethodEmit
.ldarg_0
.ldfld(fieldInfos[i])
.ret();
var setPropertyMethod = typeBuilderHelper.DefineMethod("set_" + propertyName,
MethodAttributes.Public | MethodAttributes.SpecialName |
MethodAttributes.HideBySig, null, infos[i].ParameterType);
var setPropertyMethodEmit = setPropertyMethod.Emitter;
setPropertyMethodEmit
.ldarg_0
.ldarg_1
.stfld(fieldInfos[i])
.ret();
propertyInfos[i].SetGetMethod(getPropertyMethod);
propertyInfos[i].SetSetMethod(setPropertyMethod);
}
return typeBuilderHelper.Create();
}
private static void SaveAssembly(AssemblyBuilderHelper assemblyBuilder, Type type)
{
if (_globalAssembly != null)
return;
if (_saveTypes)
{
try
{
assemblyBuilder.Save();
WriteDebug("The '{0}' type saved in '{1}'.",
type.FullName,
assemblyBuilder.Path);
}
catch (Exception ex)
{
WriteDebug("Can't save the '{0}' assembly for the '{1}' type: {2}.",
assemblyBuilder.Path,
type.FullName,
ex.Message);
}
}
}
public static IExecutor CreateExecutor(object service, MethodInfo method, int methodIndex, AssemblyBuilderHelper assemblyBuilderHelper)
{
if (service == null)
{
throw new ArgumentNullException("Cannot create null executor");
}
var type = service.GetType();
var typeName = type.Name + "_" + method.Name + methodIndex;
var typeBuilderHelper = assemblyBuilderHelper.DefineType("Executor." + typeName, typeof(object), typeof (IExecutor));
var serviceFieldBuilder = typeBuilderHelper.DefineField(type.Name, type, FieldAttributes.Public);
var emit = typeBuilderHelper.DefineMethod(typeof(IExecutor).GetMethod("Execute")).Emitter;
var returnType = method.ReturnType;
var paramInfos = method.GetParameters();
var requestType = CreateRequestType(typeName, paramInfos, assemblyBuilderHelper);
var responseType = CreateResponseType(typeName, returnType, assemblyBuilderHelper);
var getExecutorKeyEmit = typeBuilderHelper.DefineMethod(typeof(IExecutor).GetMethod("get_ExecutorKey")).Emitter;
getExecutorKeyEmit
.ldstr(typeName)
.ret();
emit
.ldarg_0
.ldfld(serviceFieldBuilder);
for (var j = 0; j < paramInfos.Length; j++)
{
var paramInfo = paramInfos[j];
var fieldInfo = requestType.GetField(paramInfo.Name);
emit = emit
.ldarg_1
.ldfld(fieldInfo);
}
if (returnType != typeof(void))
{
var resultLocal = emit.DeclareLocal(returnType);
var responseLocal = emit.DeclareLocal(responseType);
emit
.call(method)
.stloc(resultLocal)
.newobj(responseType)
.stloc(responseLocal)
.ldloc(responseLocal)
.ldloc(resultLocal)
.stfld(responseType.GetField("result"))
.ldloc(responseLocal)
.ret();
}
else
{
emit
.call(method)
.newobj(typeof(VoidResultResponse))
.ret();
}
var executorType = typeBuilderHelper.Create();
var executor = (IExecutor) TypeAccessor.CreateInstance(executorType);
var serviceField = executorType.GetField(type.Name);
serviceField.SetValue(executor, service);
return executor;
}
public void Test()
{
TypeBuilderHelper typeBuilder =
new AssemblyBuilderHelper("HelloWorld.dll").DefineType("Test", typeof(TestObject));
// Property
//
PropertyInfo propertyInfo = typeof(TestObject).GetProperty("Property");
MethodBuilderHelper methodBuilder = typeBuilder.DefineMethod(propertyInfo.GetGetMethod());
EmitHelper emit = methodBuilder.Emitter;
emit
.ldc_i4(10)
.ret()
;
// Method1
//
MethodInfo methodInfo = typeof(TestObject).GetMethod(
"Method1", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
methodBuilder = typeBuilder.DefineMethod(methodInfo);
emit = methodBuilder.Emitter;
emit
.ldc_i4(10)
.ret()
;
// Method2
//
methodInfo = typeof(TestObject).GetMethod("Method2", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
methodBuilder = typeBuilder.DefineMethod(
"Method2",
MethodAttributes.Virtual |
MethodAttributes.Public |
MethodAttributes.HideBySig |
MethodAttributes.PrivateScope |
MethodAttributes.VtableLayoutMask,
typeof(int),
new Type[] { typeof(float) });
typeBuilder.TypeBuilder.DefineMethodOverride(methodBuilder, methodInfo);
emit = methodBuilder.Emitter;
emit
.ldc_i4(10)
.ret()
;
// Create type.
//
Type type = typeBuilder.Create();
TestObject obj = (TestObject)Activator.CreateInstance(type);
Assert.AreEqual(10, obj.Property);
Assert.AreEqual(10, obj.Method3(0));
Assert.AreEqual(10, obj.Method2(0));
}
