public ILConversionResult Convert(ILConversion conversion, Type type, ILConversionOptions conversionOptions)
{
conversion.Input.TypesToConvert = new[] { type };
conversion.Input.Options = conversionOptions;
return(Convert(conversion));
}
public object ConvertCreateCall(Type type, string methodName, ILConversionOptions options)
{
var convertedType = ConvertSingleType(type, options);
var instance = CreateInstance(convertedType);
var methodInfo = convertedType.GetMethod(methodName);
if (methodInfo == null)
{
throw new Exception($"Could not find method named '{methodName}' on class named '{type.Name}'");
}
// var instructions = methodInfo.GetInstructions();
//for (int i = 0; i < instructions.Count; i++)
//{
// Debug.WriteLine(instructions[i]);
//}
var result = methodInfo.Invoke(instance, new object[0]);
return(result);
}
public ILConversionResult Convert(ILConversion conversion, Type[] types, ILConversionOptions conversionOptions)
{
conversion.Input.TypesToConvert = types;
conversion.Input.Options = conversionOptions;
return(Convert(conversion));
}
public ILConversionResult Convert(ILConversion conversion, Stream stream, ILConversionOptions conversionOptions)
{
conversion.Input = new ILConversionStreamInput();
conversion.Input.AssemblyStreamsToConvert = new [] { stream };
conversion.Input.Options = conversionOptions;
return(Convert(conversion));
}
public ILConversionResult Convert(ILConversion conversion, Stream[] streams, ILConversionOptions conversionOptions)
{
conversion.Input.AssemblyStreamsToConvert = streams;
conversion.Input.Options = conversionOptions;
// Now that all inputs have been provided, proceed with the conversion.
return(Convert(conversion));
}
// -------- CONVERSION CASE E2 ---------------
/// <summary>
/// Converts the assembly an assembly to a dynamic assembly and returns the conversion result as an out parameter.
/// </summary>
/// <param name="stream">A stream containing an assembly.</param>
/// <param name="conversionOptions"></param>
/// <param name="result"></param>
/// <returns></returns>
public Assembly Convert(Stream stream, ILConversionOptions conversionOptions, out ILConversionResult result)
{
result = Internal.Convert(new ILConversion(), stream, conversionOptions);
var output = (ILConversionAssembliesOutput)result.Output;
return(output.Assemblies[0]);
}
public ILConversionResult Convert(Type type, ILConversionOptions conversionOptions)
{
var conversion = CreateConversion(new ILConversionTypesInput()
{
Types = new[] { type }
});
return(Internal.Convert(conversion, type, conversionOptions));
}
public object ConvertAndCreateInstance(Type type, AssemblyBuilderAccess buidlerAccess)
{
var options = new ILConversionOptions()
{
BuilderAccess = buidlerAccess
};
var convertedType = ConvertSingleType(type, options);
return(CreateInstance(convertedType));
}
/// <summary>
/// Converts the assembly an assembly to a dynamic assembly and returns the conversion result as an out parameter.
/// </summary>
/// <param name="assembly"></param>
/// <param name="result"></param>
/// <returns></returns>
public Assembly QuickConvert(Assembly assembly, ILConversionOptions conversionOptions, out ILConversionResult result)
{
var conversion = CreateConversion(new ILConversionAssembliesInput()
{
Assemblies = new[] { assembly }
});
result = Internal.Convert(conversion, assembly, conversionOptions);
var output = (ILConversionAssembliesOutput)result.Output;
return(output.Assemblies[0]);
}
public void BuildConfiguration(ILConversion conversion, ILConversionOptions options)
{
if (conversion.Configuration == null)
{
conversion.Configuration = new ILConversionConfiguration();
}
conversion.Configuration.BuilderAccess = options.BuilderAccess;
conversion.Configuration.AddAssemblyPrefixAndSuffix = options.AddAssemblyPrefixAndSuffix;
conversion.Configuration.UseILGenerator = options.UseILGenerator;
}
public System.Type ConvertSingleType(System.Type type, ILConversionOptions options, out Assembly collectibleAssembly)
{
// Use the default static api to create a container to do the conversion.
var container = EvoAssembly.CreateContainer();
// do the conversion
var conversionResult = container.Convert(type, options);
Assert.IsNotNull(conversionResult);
var output = (ILConversionTypesOutput)conversionResult.Output;
var collectibleType = output.Types[0];
collectibleAssembly = collectibleType.Assembly;
Assert.IsTrue(collectibleAssembly.IsDynamic);
Assert.IsNotNull(collectibleType);
if (options.BuilderAccess == AssemblyBuilderAccess.RunAndSave)
{
var saveAssembly = conversionResult.Output.Assemblies[0];
if (saveAssembly is AssemblyBuilder builder)
{
var modules = collectibleAssembly.GetModules();
var module = modules[0];
var fileName = module.ScopeName;
builder.Save(fileName);
}
}
return(collectibleType);
}
public object CreateTypeAndExecute(Action <ILGenerator> action, ILConversionOptions options)
{
var assemblyName1 = CreateTestType(action);
Assembly assemblyLoaded = Assembly.LoadFrom(assemblyName1 + ".dll");
var types = assemblyLoaded.GetTypes();
var testType = GetTestType(types);
var constructor = testType.GetConstructor(Type.EmptyTypes);
var instance = constructor.Invoke(new object[0]);
var methodInfo = testType.GetMethod("Execute");
if (methodInfo == null)
{
throw new Exception($"Could not find method named '{"Execute"}' on class named '{testType.Name}'");
}
//var bytes = methodInfo.GetInstructions();
//for (int i = 0; i < bytes.Count; i++)
//{
// Debug.WriteLine(bytes[i]);
//}
var result1 = methodInfo.Invoke(instance, new object[0]);
// Convert the type. The test api code will check to make sure the instance is not null.
var result2 = ConvertCreateCall(testType, "Execute", options);
return(result2);
}
public static Assembly Convert(System.IO.Stream stream, ILConversionOptions options)
{
var container = CreateContainer();
return(container.Api.Runtimic.Execution.Conversion.Convert(stream, options));
}
public static ILConversionResult Convert(this RuntimicContainer container, System.Type type, ILConversionOptions conversionOptions)
{
return(container.Api.Runtimic.Execution.Conversion.Convert(type, conversionOptions));
}
public static System.Reflection.Assembly Convert(this RuntimicContainer container, System.Reflection.Assembly assembly, ILConversionOptions conversionOptions)
{
return(container.Api.Runtimic.Execution.Conversion.QuickConvert(assembly, conversionOptions));
}
public Assembly QuickConvert(Assembly assembly, ILConversionOptions options)
{
return(QuickConvert(assembly, options, out ILConversionResult result));
}
public ILConversionResult Convert(ILConversion conversion, Assembly[] assemblies, ILConversionOptions conversionOptions)
{
conversion.Input.AssembliesToConvert = assemblies;
conversion.Input.Options = conversionOptions;
return(Convert(conversion));
}
public System.Type ConvertSingleType(System.Type type, ILConversionOptions options)
{
return(ConvertSingleType(type, options, out Assembly collectibleAssembly));
}
public object ConvertAndCreateInstance(Type type, out Assembly assembly, out Type convertedType, ILConversionOptions options)
{
convertedType = ConvertSingleType(type, options, out assembly);
return(CreateInstance(convertedType));
}
public object ConvertAndCreateInstance(Type type, ILConversionOptions conversionOptions)
{
var convertedType = ConvertSingleType(type, conversionOptions);
return(CreateInstance(convertedType));
}
public static ILConversionResult Convert(System.Type type, ILConversionOptions options)
{
var container = CreateContainer();
return(container.Api.Runtimic.Execution.Conversion.Convert(type, options));
}
public Assembly Convert(Stream stream, ILConversionOptions conversionOptions)
{
return(Convert(stream, conversionOptions, out ILConversionResult result));
}
