public InternalAssemblyRunner(string exePath, Type[] paraTypes, Type returnType, ElevatorOptions options)
{
_exePath = exePath;
_paraTypes = paraTypes;
_returnType = returnType;
_options = options;
}
private static InternalAssemblyRunner InternalGenerate(MethodInfo method, object target, Type[] paramaterTypes, Type returnType,
ElevatorOptions options)
{
if (options == null)
{
options = new ElevatorOptions();
}
if (returnType == null)
{
returnType = typeof(void);
}
var assyName = options.AssemblyName;
var assyFile = assyName + ".exe";
var dir = Path.Combine(options.TempPath, RandomEx.GetString(8));
Directory.CreateDirectory(dir);
var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName(assyName), AssemblyBuilderAccess.Save, dir);
var moduleBuilder = assemblyBuilder.DefineDynamicModule(assyName, assyFile);
var typeBuilder = moduleBuilder.DefineType("Program", TypeAttributes.Class | TypeAttributes.Public);
var mainMethod = typeBuilder.DefineMethod("Main",
MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static,
typeof(int), new Type[] { typeof(string[]) });
var dynName = RandomEx.GetString(8);
var dynMethod = typeBuilder.DefineMethod(dynName,
MethodAttributes.Public | MethodAttributes.Static,
returnType, paramaterTypes);
var ref1 = EmitModifiedMethod(dynMethod, method, target);
var ref2 = EmitMainMethod(mainMethod, dynName, paramaterTypes);
typeBuilder.CreateType();
assemblyBuilder.SetEntryPoint(mainMethod, PEFileKinds.ConsoleApplication);
assemblyBuilder.Save(assyFile);
var references = assemblyBuilder.GetReferencedAssemblies()
.Select(r => Assembly.ReflectionOnlyLoad(r.FullName))
.Concat(ref1)
.Concat(ref2)
.Concat(options.Dependancies)
.Distinct(new AssemblyFullNameEqualityComparer())
.Where(a => !a.IsInGAC());
foreach (var refAssy in references)
{
var refName = Path.GetFileName(refAssy.Location);
File.Copy(refAssy.Location, Path.Combine(dir, refName));
}
return(new InternalAssemblyRunner(Path.Combine(dir, assyFile), paramaterTypes, returnType, options));
}
/// <summary>
/// Compiles the provided delegate into a separate assembly, so that the code can be executed with different
/// paramaters than the current process. (run as administrator, etc)
/// </summary>
/// <param name="method">The delegate to compile</param>
/// <param name="options">Optionally specify custom compilation options</param>
/// <returns>Returns replacement delegate that will execute the original delegate but in a different process.</returns>
public static ElevatorAssembly <Action <T1, T2, T3, T4> > Compile <T1, T2, T3, T4>(Action <T1, T2, T3, T4> method, ElevatorOptions options = null)
{
var assy = InternalGenerate(method.Method, method.Target, new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }, null, options);
return(new ElevatorAssembly <Action <T1, T2, T3, T4> >((one, two, three, four) => assy.Run(new object[] { one, two, three, four }), assy.Dispose));
}
/// <summary>
/// Compiles the provided delegate into a separate assembly, so that the code can be executed with different
/// paramaters than the current process. (run as administrator, etc)
/// </summary>
/// <param name="method">The delegate to compile</param>
/// <param name="options">Optionally specify custom compilation options</param>
/// <returns>Returns replacement delegate that will execute the original delegate but in a different process.</returns>
public static ElevatorAssembly <Action <T> > Compile <T>(Action <T> method, ElevatorOptions options = null)
{
var assy = InternalGenerate(method.Method, method.Target, new[] { typeof(T) }, null, options);
return(new ElevatorAssembly <Action <T> >((one) => assy.Run(new object[] { one }), assy.Dispose));
}
/// <summary>
/// Compiles the provided delegate into a separate assembly, so that the code can be executed with different
/// paramaters than the current process. (run as administrator, etc)
/// </summary>
/// <param name="method">The delegate to compile</param>
/// <param name="options">Optionally specify custom compilation options</param>
/// <returns>Returns replacement delegate that will execute the original delegate but in a different process.</returns>
public static ElevatorAssembly <Action> Compile(Action method, ElevatorOptions options = null)
{
var assy = InternalGenerate(method.Method, method.Target, new Type[] { }, null, options);
return(new ElevatorAssembly <Action>(() => assy.Run(new object[] { }), assy.Dispose));
}
/// <summary>
/// Compiles the provided delegate into a separate assembly, so that the code can be executed with different
/// paramaters than the current process. (run as administrator, etc)
/// </summary>
/// <param name="method">The delegate to compile</param>
/// <param name="options">Optionally specify custom compilation options</param>
/// <returns>Returns replacement delegate that will execute the original delegate but in a different process.</returns>
public static ElevatorAssembly <Func <T1, T2, T3, T4, T5, T6, T7, TResult> > Compile <T1, T2, T3, T4, T5, T6, T7, TResult>(Func <T1, T2, T3, T4, T5, T6, T7, TResult> method, ElevatorOptions options = null)
{
var assy = InternalGenerate(method.Method, method.Target, new Type[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7) }, typeof(TResult), options);
return(new ElevatorAssembly <Func <T1, T2, T3, T4, T5, T6, T7, TResult> >((one, two, three, four, five, six, seven) => (TResult)assy.Run(new object[] { one, two, three, four, five, six, seven }), assy.Dispose));
}
/// <summary>
/// Compiles the provided delegate into a separate assembly, so that the code can be executed with different
/// paramaters than the current process. (run as administrator, etc)
/// </summary>
/// <param name="method">The delegate to compile</param>
/// <param name="options">Optionally specify custom compilation options</param>
/// <returns>Returns replacement delegate that will execute the original delegate but in a different process.</returns>
public static ElevatorAssembly <Func <T1, T2, TResult> > Compile <T1, T2, TResult>(Func <T1, T2, TResult> method, ElevatorOptions options = null)
{
var assy = InternalGenerate(method.Method, method.Target, new Type[] { typeof(T1), typeof(T2) }, typeof(TResult), options);
return(new ElevatorAssembly <Func <T1, T2, TResult> >((one, two) => (TResult)assy.Run(new object[] { one, two }), assy.Dispose));
}
/// <summary>
/// Compiles the provided delegate into a separate assembly, so that the code can be executed with different
/// paramaters than the current process. (run as administrator, etc)
/// </summary>
/// <param name="method">The delegate to compile</param>
/// <param name="options">Optionally specify custom compilation options</param>
/// <returns>Returns replacement delegate that will execute the original delegate but in a different process.</returns>
public static ElevatorAssembly <Action <T1, T2, T3, T4, T5, T6, T7, T8> > Compile <T1, T2, T3, T4, T5, T6, T7, T8>(Action <T1, T2, T3, T4, T5, T6, T7, T8> method, ElevatorOptions options = null)
{
var assy = InternalGenerate(method.Method, method.Target, new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8) }, null, options);
return(new ElevatorAssembly <Action <T1, T2, T3, T4, T5, T6, T7, T8> >((one, two, three, four, five, six, seven, eight) => assy.Run(new object[] { one, two, three, four, five, six, seven, eight }), assy.Dispose));
}
