public void MultipleInstancesPluginTest()
{
var assmBuilder1 = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(Guid.NewGuid().ToString()),
AssemblyBuilderAccess.RunAndCollect);
var moduleBuilder1 = assmBuilder1.DefineDynamicModule(Guid.NewGuid().ToString());
var typeBuilder1 = moduleBuilder1.DefineType("Plugin1", TypeAttributes.Public);
typeBuilder1.AddInterfaceImplementation(typeof(IPlugin));
typeBuilder1.SetParent(typeof(PluginMock1));
typeBuilder1.CreateType();
var typeBuilder2 = moduleBuilder1.DefineType("Plugin2", TypeAttributes.Public);
typeBuilder2.AddInterfaceImplementation(typeof(IPlugin));
typeBuilder2.SetParent(typeof(PluginMock2));
typeBuilder2.CreateType();
var assm1 = moduleBuilder1.Assembly;
var assmBuffer1 = new Lokad.ILPack.AssemblyGenerator().GenerateAssemblyBytes(assm1);
var mgr = new PluginsManager(new Configuration()
{
Plugins = new List <string>()
}, new Mock <IDocifyApplication>().Object);
Assert.ThrowsAsync <MultiplePluginsPerNameException>(() => mgr.LoadPlugins(new PluginInfoMock[]
{
new PluginInfoMock("plg1", new FileMock(Location.FromPath("Plugin1Mock.dll"), assmBuffer1))
}.ToAsyncEnumerable()));
}
protected Delegate CreateDelegate(Type delegateType)
{
if (_dynMethod != null)
{
return(_dynMethod.CreateDelegate(delegateType));
}
else
{
var tb = _emiMethod.DeclaringType as TypeBuilder;
var t = tb.CreateType();
var assembly = t.Assembly;
try
{
var generator = new Lokad.ILPack.AssemblyGenerator();
string path = Path.Combine(Directory.GetCurrentDirectory(), "Dynamic");
Directory.CreateDirectory(path);
generator.GenerateAssembly(assembly, Path.Combine(path, assembly.GetName().Name + ".dll"));
}
catch
{
// we don't care if the assembly could not be created - it is for debug purposes anyway.
}
return(t.GetMethod(_emiMethod.Name).CreateDelegate(delegateType));
}
}
public async Task InitTest()
{
var assmBuilder1 = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(Guid.NewGuid().ToString()),
AssemblyBuilderAccess.RunAndCollect);
var moduleBuilder1 = assmBuilder1.DefineDynamicModule(Guid.NewGuid().ToString());
var typeBuilder1 = moduleBuilder1.DefineType("Plugin1", TypeAttributes.Public);
typeBuilder1.AddInterfaceImplementation(typeof(IPlugin));
typeBuilder1.SetParent(typeof(PluginMock1));
var p1 = typeBuilder1.CreateType();
var assm1 = moduleBuilder1.Assembly;
var assmBuffer1 = new Lokad.ILPack.AssemblyGenerator().GenerateAssemblyBytes(assm1);
var mgr = new PluginsManager(new Configuration()
{
Plugins = new List <string>()
}, new Mock <IDocifyApplication>().Object);
await mgr.LoadPlugins(new PluginInfoMock[]
{
new PluginInfoMock("plg1", new FileMock(Location.FromPath("Plugin1Mock.dll"), assmBuffer1)),
}.ToAsyncEnumerable());
var res = mgr.GetType().GetField("m_Plugins", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(mgr) as IEnumerable <IPluginBase>;
Assert.AreEqual(1, res.Count());
Assert.IsInstanceOf(typeof(IPlugin), res.First());
Assert.AreEqual(p1.FullName, res.First().GetType().FullName);
Assert.IsNotNull((res.First() as PluginMock1).App);
}
public void Save(AssemblyBuilder ass, string filename, ImageFileMachine machineKind)
{
#if !NETCOREAPP2_1_OR_GREATER
ass.Save(filename, PortableExecutableKinds.ILOnly, machineKind);
#elif LOKAD
var gen = new Lokad.ILPack.AssemblyGenerator();
gen.GenerateAssembly(ass, filename);
#endif
}
private static void SaveDebugAssembly(AssemblyBuilder ab)
{
Console.Error.WriteLine("Saving '{0}'", ab.GetName().Name + ".dll");
#if DNC
var generator = new Lokad.ILPack.AssemblyGenerator();
generator.GenerateAssembly(ab, ab.GetName().Name + ".dll");
#else
ab.Save(ab.GetName().Name + ".dll");
#endif
}
public void Compile()
{
GenStmt(_stmt);
_il.Emit(OpCodes.Ret);
_typeBuilder.CreateType();
_modb.CreateGlobalFunctions();
var generator = new Lokad.ILPack.AssemblyGenerator();
generator.GenerateAssembly(_asmb, this._moduleName);
}
static void Main(string[] args)
{
var doc = XDocument.Load("../../StringResources.xml");
var xitems = doc.Element("resources").Elements("item");
var items = xitems.Select(i => new {
Key = i.Attribute("key").Value,
Value = i.Attribute("value").Value,
Comment = i.Attribute("comment").Value,
});
var srName = new AssemblyName("StringResources");
var srAssemBuilder = AssemblyBuilder.DefineDynamicAssembly(srName, AssemblyBuilderAccess.RunAndCollect);
var srModBuilder = srAssemBuilder.DefineDynamicModule($"{srName.Name}.dll");
var commentAttrCons = typeof(CommentAttribute).GetConstructors()[0];
var srType = srModBuilder.DefineType("StringResources.Resource", TypeAttributes.Public);
foreach (var item in items)
{
var srProp = srType.DefineProperty(item.Key, PropertyAttributes.HasDefault, typeof(string), Type.EmptyTypes);
var srCommentAttr = new CustomAttributeBuilder(commentAttrCons, new object[] { item.Comment });
srProp.SetCustomAttribute(srCommentAttr);
var srPropGetter = srType.DefineMethod($"get_{item.Key}", MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Public | MethodAttributes.Static, typeof(string), Type.EmptyTypes);
var getterIl = srPropGetter.GetILGenerator();
getterIl.Emit(OpCodes.Ldstr, item.Value);
getterIl.Emit(OpCodes.Ret);
srProp.SetGetMethod(srPropGetter);
srPropGetter.SetCustomAttribute(srCommentAttr);
}
var type = srType.CreateType();
const string outputAssembly = "../../out/StringResources.dll";
if (File.Exists(outputAssembly))
{
File.Delete(outputAssembly);
}
var assemblyGenerator = new Lokad.ILPack.AssemblyGenerator();
assemblyGenerator.GenerateAssembly(srAssemBuilder, outputAssembly);
}
public void TestEmit()
{
var doc = NifSchema.LoadEmbedded();
var basics = new Dictionary <string, Type>()
{
{ "uint64", typeof(ulong) },
{ "int64", typeof(long) },
{ "ulittle32", typeof(uint) },
{ "uint", typeof(uint) },
{ "int", typeof(int) },
{ "ushort", typeof(ushort) },
{ "short", typeof(short) },
{ "char", typeof(char) },
{ "byte", typeof(byte) },
{ "bool", typeof(bool) },
{ "BlockTypeIndex", typeof(int) },
{ "FileVersion", typeof(int) },
{ "float", typeof(float) },
{ "hfloat", typeof(float) },
{ "HeaderString", typeof(string) },
{ "LineString", typeof(string) },
{ "Ptr", typeof(int) },
{ "Ref", typeof(int) },
{ "StringOffset", typeof(uint) },
{ "NiFixedString", typeof(uint) },
};
var version = doc.Versions
.Find(v => v.Id == "V20_2_0_7_SSE")
.GetVersionKeys()
.First();
var name = new AssemblyName("MyNonStandardLibrary");
var access = AssemblyBuilderAccess.Run;
var assembly = AssemblyBuilder.DefineDynamicAssembly(name, access);
var module = assembly.DefineDynamicModule("MyNonStandardLibrary.dll");
var schema = new SchemaDocumentBuilder(module, doc, basics, version);
var generator = new Lokad.ILPack.AssemblyGenerator();
generator.GenerateAssembly(assembly, "./MyNonStandardLibrary.dll");
}
public void Create_Simply_Type_Test()
{
MessageBuilder.GetMessageType <SimplyModel>();
MessageBuilder.GetMessageType <SimplyModel2>();
MessageBuilder.GetMessageType <NullableModel>();
MessageBuilder.GetMessageType <EnumModel>();
MessageBuilder.GetMessageType <CollectionModel>();
MessageBuilder.GetMessageType <DictionaryModel>();
MessageBuilder.GetMessageType <ContentModel>();
MessageBuilder.GetMessageType <MessageModel>();
MessageBuilder.GetMessageType <ObjectCollectionModel>();
MessageBuilder.GetMessageType <ObjectDictionaryModel>();
MessageBuilder.GetMessageType <PointModel>();
MessageBuilder.GetMessageType <ValueConstructorModel>();
var generator = new Lokad.ILPack.AssemblyGenerator();
var bytes = generator.GenerateAssemblyBytes(MessageBuilder.GetAssembly());
File.WriteAllBytes("dynamic.dll", bytes);
}
public async Task LoadSettingsTest()
{
var assmBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(Guid.NewGuid().ToString()),
AssemblyBuilderAccess.RunAndCollect);
var moduleBuilder = assmBuilder.DefineDynamicModule(Guid.NewGuid().ToString());
var typeBuilder = moduleBuilder.DefineType("Plugin1", TypeAttributes.Public);
typeBuilder.AddInterfaceImplementation(typeof(IPlugin <MockSettings1>));
typeBuilder.SetParent(typeof(PluginMock <MockSettings1>));
typeBuilder.CreateType();
var assm = moduleBuilder.Assembly;
var assmBuffer = new Lokad.ILPack.AssemblyGenerator().GenerateAssemblyBytes(assm);
var conf = new MetadataSerializer().Deserialize <Configuration>("^plg1:\r\n prop-two: 0.1\r\n prp3:\r\n - A\r\n - B");
conf.Plugins = new List <string>(new string[] { "plg1" });
var mgr = new PluginsManager(conf, new Mock <IDocifyApplication>().Object);
await mgr.LoadPlugins(new PluginInfoMock[]
{
new PluginInfoMock("plg1", new FileMock(Location.FromPath("mockplugins.dll"), assmBuffer))
}.ToAsyncEnumerable());
var res = mgr.GetType().GetField("m_Plugins", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(mgr) as IEnumerable <IPluginBase>;
var plg = res.OfType <PluginMock <MockSettings1> >().FirstOrDefault();
Assert.IsNotNull(plg);
Assert.IsNotNull(plg.Settings);
Assert.IsNotNull(plg.App);
Assert.AreEqual("A", plg.Settings.Prp1);
Assert.AreEqual(0.1, plg.Settings.PropTwo);
Assert.That(new string[] { "A", "B" }.SequenceEqual(plg.Settings.Prp3));
}
public void NoPluginFoundTest()
{
var assmBuilder1 = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(Guid.NewGuid().ToString()),
AssemblyBuilderAccess.RunAndCollect);
var moduleBuilder1 = assmBuilder1.DefineDynamicModule(Guid.NewGuid().ToString());
var typeBuilder1 = moduleBuilder1.DefineType("Plugin1", TypeAttributes.Public);
var p1 = typeBuilder1.CreateType();
var assm1 = moduleBuilder1.Assembly;
var assmBuffer1 = new Lokad.ILPack.AssemblyGenerator().GenerateAssemblyBytes(assm1);
var mgr = new PluginsManager(new Configuration()
{
Plugins = new List <string>()
}, new Mock <IDocifyApplication>().Object);
Assert.ThrowsAsync <MissingPluginImplementationException>(() => mgr.LoadPlugins(new PluginInfoMock[]
{
new PluginInfoMock("plg1", new FileMock(Location.FromPath("Plugin1Mock.dll"), assmBuffer1))
}.ToAsyncEnumerable()));
}
//use this instead
//https://github.com/ltrzesniewski/InlineIL.Fody
public static void GenerateCil()
{
var aName = new AssemblyName("DynamicAssemblyExample");
var ab =
AssemblyBuilder.DefineDynamicAssembly(
aName,
AssemblyBuilderAccess.RunAndCollect);
// For a single-module assembly, the module name is usually
// the assembly name plus an extension.
var mb =
ab.DefineDynamicModule(aName.Name);
var tb = mb.DefineType(
"MyDynamicType",
TypeAttributes.Public);
// Add a private field of type int (Int32).
var fbNumber = tb.DefineField(
"m_number",
typeof(int),
FieldAttributes.Private);
// Define a constructor that takes an integer argument and
// stores it in the private field.
Type[] parameterTypes = { typeof(int) };
var ctor1 = tb.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
parameterTypes);
var ctor1IL = ctor1.GetILGenerator();
// For a constructor, argument zero is a reference to the new
// instance. Push it on the stack before calling the base
// class constructor. Specify the default constructor of the
// base class (System.Object) by passing an empty array of
// types (Type.EmptyTypes) to GetConstructor.
ctor1IL.Emit(OpCodes.Ldarg_0);
ctor1IL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
// Push the instance on the stack before pushing the argument
// that is to be assigned to the private field m_number.
ctor1IL.Emit(OpCodes.Ldarg_0);
ctor1IL.Emit(OpCodes.Ldarg_1);
ctor1IL.Emit(OpCodes.Stfld, fbNumber);
ctor1IL.Emit(OpCodes.Ret);
// Define a default constructor that supplies a default value
// for the private field. For parameter types, pass the empty
// array of types or pass null.
var ctor0 = tb.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
Type.EmptyTypes);
var ctor0IL = ctor0.GetILGenerator();
// For a constructor, argument zero is a reference to the new
// instance. Push it on the stack before pushing the default
// value on the stack, then call constructor ctor1.
ctor0IL.Emit(OpCodes.Ldarg_0);
ctor0IL.Emit(OpCodes.Ldc_I4_S, 42);
ctor0IL.Emit(OpCodes.Call, ctor1);
ctor0IL.Emit(OpCodes.Ret);
// Define a property named Number that gets and sets the private
// field.
//
// The last argument of DefineProperty is null, because the
// property has no parameters. (If you don't specify null, you must
// specify an array of Type objects. For a parameterless property,
// use the built-in array with no elements: Type.EmptyTypes)
var pbNumber = tb.DefineProperty(
"Number",
PropertyAttributes.HasDefault,
typeof(int),
null);
// The property "set" and property "get" methods require a special
// set of attributes.
const System.Reflection.MethodAttributes getSetAttr = MethodAttributes.Public |
MethodAttributes.SpecialName | MethodAttributes.HideBySig;
// Define the "get" accessor method for Number. The method returns
// an integer and has no arguments. (Note that null could be
// used instead of Types.EmptyTypes)
var mbNumberGetAccessor = tb.DefineMethod(
"get_Number",
getSetAttr,
typeof(int),
Type.EmptyTypes);
var numberGetIL = mbNumberGetAccessor.GetILGenerator();
// For an instance property, argument zero is the instance. Load the
// instance, then load the private field and return, leaving the
// field value on the stack.
numberGetIL.Emit(OpCodes.Ldarg_0);
numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
numberGetIL.Emit(OpCodes.Ret);
// Define the "set" accessor method for Number, which has no return
// type and takes one argument of type int (Int32).
var mbNumberSetAccessor = tb.DefineMethod(
"set_Number",
getSetAttr,
null,
new Type[] { typeof(int) });
var numberSetIL = mbNumberSetAccessor.GetILGenerator();
// Load the instance and then the numeric argument, then store the
// argument in the field.
numberSetIL.Emit(OpCodes.Ldarg_0);
numberSetIL.Emit(OpCodes.Ldarg_1);
numberSetIL.Emit(OpCodes.Stfld, fbNumber);
numberSetIL.Emit(OpCodes.Ret);
// Last, map the "get" and "set" accessor methods to the
// PropertyBuilder. The property is now complete.
pbNumber.SetGetMethod(mbNumberGetAccessor);
pbNumber.SetSetMethod(mbNumberSetAccessor);
// Define a method that accepts an integer argument and returns
// the product of that integer and the private field m_number. This
// time, the array of parameter types is created on the fly.
var meth = tb.DefineMethod(
"MyMethod",
MethodAttributes.Public,
typeof(int),
new Type[] { typeof(int) });
var methIL = meth.GetILGenerator();
// To retrieve the private instance field, load the instance it
// belongs to (argument zero). After loading the field, load the
// argument one and then multiply. Return from the method with
// the return value (the product of the two numbers) on the
// execution stack.
methIL.Emit(OpCodes.Ldarg_0);
methIL.Emit(OpCodes.Ldfld, fbNumber);
methIL.Emit(OpCodes.Ldarg_1);
methIL.Emit(OpCodes.Mul);
methIL.Emit(OpCodes.Ret);
// Finish the type.
var t = tb.CreateType();
// The following line saves the single-module assembly. This
// requires AssemblyBuilderAccess to include Save. You can now
// type "ildasm MyDynamicAsm.dll" at the command prompt, and
// examine the assembly. You can also write a program that has
// a reference to the assembly, and use the MyDynamicType type.
//
var assembly = Assembly.GetAssembly(t);
var generator = new Lokad.ILPack.AssemblyGenerator();
generator.GenerateAssembly(assembly, aName.Name + "_1.dll");
GetCil(aName.Name + "_1.dll");
var mi = t.GetMethod("MyMethod");
var pi = t.GetProperty("Number");
// Create an instance of MyDynamicType using the default
// constructor.
var o1 = Activator.CreateInstance(t);
// Display the value of the property, then change it to 127 and
// display it again. Use null to indicate that the property
// has no index.
Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, null));
pi.SetValue(o1, 127, null);
Console.WriteLine("o1.Number: {0}", pi.GetValue(o1, null));
// Call MyMethod, passing 22, and display the return value, 22
// times 127. Arguments must be passed as an array, even when
// there is only one.
object[] arguments = { 22 };
Console.WriteLine("o1.MyMethod(22): {0}", mi.Invoke(o1, arguments));
// Create an instance of MyDynamicType using the constructor
// that specifies m_Number. The constructor is identified by
// matching the types in the argument array. In this case,
// the argument array is created on the fly. Display the
// property value.
var o2 = Activator.CreateInstance(t, new object[] { 5280 });
Console.WriteLine("o2.Number: {0}", pi.GetValue(o2, null));
}
private static void Save(Type typ, string path)
{
var generator = new Lokad.ILPack.AssemblyGenerator();
generator.GenerateAssembly(typ.Assembly, path);
}
public static void WriteAssemblyToDisk(this Type BaseType, string FileName)
{
var generator = new Lokad.ILPack.AssemblyGenerator();
generator.GenerateAssembly(Assembly.GetAssembly(BaseType), FileName);
}
