//
// This is a sample code to demonstrate various resource emit APIs.
// Written by Haibo Luo; http://blogs.msdn.com/haibo_luo
// 
// THIS CODE IS PROVIDED AS IS, WITH NO WARRANTIES INTENDED OR IMPLIED. USE AT YOUR OWN RISK
// 

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.IO;

// this class will be used as the base class for the emitted type
// the virtual method "Show" will be called in the Main method of the emitted assembly

public class ResourceConsumer {
    public virtual void Show() {
        Assembly assembly = Assembly.GetEntryAssembly();

        Console.WriteLine(">>> All modules:");
        foreach (Module mod in assembly.GetModules(true)) {
            Console.WriteLine(mod.FullyQualifiedName);
        }
        Console.WriteLine();

        Console.WriteLine(">>> Go through ManifestResource:");
        foreach (string name in assembly.GetManifestResourceNames()) {
            Console.WriteLine("\n===Resource name: {0} ===", name);
            ManifestResourceInfo mri = assembly.GetManifestResourceInfo(name);
            Console.WriteLine("  location      : {0}", mri.ResourceLocation);
            Console.WriteLine("  filename      : {0}", mri.FileName);
            Console.WriteLine("  assembly      : {0}", mri.ReferencedAssembly);

            Stream stream = assembly.GetManifestResourceStream(name);
            Console.Write("  stream content: [{0}] ", stream.Length);
            for (int i = 0; i < Math.Min(stream.Length, 16); i++)
                Console.Write("{0:X2} ", stream.ReadByte());
            Console.WriteLine("...");

            if (!name.EndsWith(".resources"))
                continue;

            ResourceManager rm = new ResourceManager(name.Substring(0, name.Length - 10), assembly);
            Console.WriteLine("        - name1 : {0}", rm.GetObject("name1"));
            Console.WriteLine("        - name2 : {0}", rm.GetObject("name2"));
            Console.WriteLine("        - name3 : {0}", rm.GetObject("name3"));
        }
    }
}

class ResourceEmitter {
    public static void Main() {
        //
        // emit the following C# code as assembly "temp.exe":
        //
        // class Repro : ResourceConsumer {
        //    static void Main() {
        //        Repro repro = new Repro();
        //        repro.Show();
        //    }
        // }
        //
        // 
        // emit the following C# code as "second.netmodule"
        //
        // class TypeInModule2 {}
        //

        string assemblyName = "temp";

        AssemblyBuilder asmb = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(assemblyName), AssemblyBuilderAccess.RunAndSave);
        ModuleBuilder mod1 = asmb.DefineDynamicModule(assemblyName, assemblyName + ".exe");
        TypeBuilder tb = mod1.DefineType("Repro", TypeAttributes.Class | TypeAttributes.Public, typeof(ResourceConsumer));
        ConstructorBuilder cb = tb.DefineDefaultConstructor(MethodAttributes.Public);

        MethodBuilder mb = tb.DefineMethod("Main", MethodAttributes.Static, CallingConventions.Standard, typeof(void), Type.EmptyTypes);
        asmb.SetEntryPoint(mb);

        ILGenerator ilgen = mb.GetILGenerator();
        ilgen.Emit(OpCodes.Newobj, cb);
        ilgen.Emit(OpCodes.Callvirt, typeof(ResourceConsumer).GetMethod("Show"));
        ilgen.Emit(OpCodes.Nop);
        ilgen.Emit(OpCodes.Ret);
        tb.CreateType();

        //
        //***** Play on the AssemblyBuilder *****
        //

        // Link "managed resource"
        IResourceWriter rw = asmb.DefineResource("LinkedResInMod1.resources", "Resource defined by AssemblyBuilder.DefineResource", "LinkedResInMod1.resources");
        rw.AddResource("name1", new byte[] { (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o' });
        rw.AddResource("name2", "value");
        rw.AddResource("name3", typeof(string));

        // Link "resource blob": 
        CreateFile("LinkedBlobInMod1.any", "Linked resource blob by AssemblyBuilder.AddResourceFile");
        asmb.AddResourceFile("LinkedBlobInMod1.any", "LinkedBlobInMod1.any");

        // link "resource blob" which is .resources format 
        CreateResourceFile("PreparedForLink.resources");
        asmb.AddResourceFile("PreparedForLink.resources", "PreparedForLink.resources");

        // 
        //***** Play on the first ModuleBuilder *****
        //

        // Embed "managed resource"
        rw = mod1.DefineResource("EmbeddedResInMod1.resources", "Resource defined by ModuleBuilder.DefineResource");
        rw.AddResource("name1", new byte[] { (byte)'f', (byte)'i', (byte)'r', (byte)'s', (byte)'t' });
        rw.AddResource("name2", "first");
        rw.AddResource("name3", typeof(string));

        // Embed "resource blob"
        CreateFile("EmbeddedBlobInMod1.any", "Embedded resource blob by ModuleBuilder.DefineManifestResource");
        mod1.DefineManifestResource("EmbeddedBlobInMod1.any", new FileStream("EmbeddedBlobInMod1.any", FileMode.Open), ResourceAttributes.Public);

        // Embed "resource blob" which is .resources format 
        CreateResourceFile("PreparedForEmbed.resources");
        mod1.DefineManifestResource("PreparedForEmbed.resources", new FileStream("PreparedForEmbed.resources", FileMode.Open), ResourceAttributes.Public);

        //// Create a second module
        ModuleBuilder mod2 = asmb.DefineDynamicModule("SecondMod", "second.netmodule");
        TypeBuilder tb2 = mod2.DefineType("TypeInModule2");
        tb2.CreateType();

        // 
        //***** Play on the second ModuleBuilder *****
        //

        // Embed "managed resource"
        rw = mod2.DefineResource("EmbeddedResInMod2.resources", "Resource defined by second ModuleBuilder.DefineResource");
        rw.AddResource("name1", "second");
        rw.AddResource("name2", typeof(int));
        rw.AddResource("name3", new byte[] { (byte)'s', (byte)'e', (byte)'c', (byte)'o', (byte)'n', (byte)'d' });

        // Embed "resource blob"
        CreateFile("EmbeddedBlobInMod2.any");
        mod2.DefineManifestResource("EmbeddedBlobInMod2.any", new FileStream("EmbeddedBlobInMod2.any", FileMode.Open), ResourceAttributes.Public);

        asmb.Save(assemblyName + ".exe");
    }

    // 2 helper methods to create text file and resources file

    public static void CreateResourceFile(string filename) {
        using (ResourceWriter rw = new ResourceWriter(filename)) {
            rw.AddResource("name1", typeof(int));
            rw.AddResource("name2", new byte[] { (byte)'a', (byte)'h', (byte)'e', (byte)'a', (byte)'d' });
            rw.AddResource("name3", "prepared ahead");
        }
    }

    public static void CreateFile(string filename, params string[] contents) {
        using (TextWriter tw = new StreamWriter(filename)) {
            foreach (string s in contents)
                tw.WriteLine(s);
        }
    }
}