Assembly not saving correctly

Question

I have some very simple code to generate an assembly and invoke a method on a contained type. The method gets called and runs correctly, however when I view the generated assembly using Reflector, I don't see the type.

Below is the sample code:

namespace ConsoleApplication2
{
    class Proggy
    {
     public static void Main(string[] args)
     {
      var ab = AppDomain.CurrentDomain.DefineDynamicAssembly(
          new AssemblyName() { Name = "MyAssembly" },
          AssemblyBuilderAccess.RunAndSave);
      var module = ab.DefineDynamicModule(ab.GetName().Name);
      var typeBuilder = module.DefineType("MyType");
      var ctr = typeBuilder.DefineConstructor(MethodAttributes.Public, 
          CallingConventions.Standard, Type.EmptyTypes);
      var ilgc = ctr.GetILGenerator();
      ilgc.Emit(OpCodes.Ldarg_0);
      ilgc.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
      ilgc.Emit(OpCodes.Ret);
      var method = typeBuilder.DefineMethod("MyMethod", MethodAttributes.Public,
          typeof(int), new[] { typeof(string) });
      var ilg = method.GetILGenerator();
      ilg.Emit(OpCodes.Ldarg_1);
      ilg.EmitCall(OpCodes.Callvirt, typeof(string).GetProperty("Length").GetGetMethod(),
          null);
      ilg.Emit(OpCodes.Ret);
      var type = typeBuilder.CreateType();
      ab.Save("mytestasm.dll");
      var inst = Activator.CreateInstance(type);
      Console.WriteLine(type.InvokeMember("MyMethod", BindingFlags.InvokeMethod, null, inst,
          new[] { "MyTestString" }));
      Console.ReadLine();
     }
    }
}

and here is the corresponding disassembly from Reflector:

.assembly MyAssembly
{
    .ver 0:0:0:0
    .hash algorithm 0x00008004
}
.module RefEmit_OnDiskManifestModule
// MVID: {0B944140-58D9-430E-A867-DE0AD0A8701F}
// Target Runtime Version: v2.0.50727

... and ...

{
    .class private auto ansi <Module>
    {
    }
}

Can anyone help me with getting the assembly properly saved?

Answer 1

I am not sure why the type is not getting added.

Another way of doing this however is to dynamically create code by just passing in a string which contains your class code. I think this is a bit easier than the above way of doing it as you can just build up the code using a string builder and test in studio.

Here is the code i use to generate a dll:

print(" Microsoft.CSharp.CSharpCodeProvider objCodeProvider = new Microsoft.CSharp.CSharpCodeProvider();
        string strCode = "using System;" + Environment.NewLine + "using System.Data;" + Environment.NewLine + "using DC.Common;" + Environment.NewLine + "" + Environment.NewLine + "using System.Data.SqlClient;" + Environment.NewLine + "using System.Configuration;" + Environment.NewLine + "" + Environment.NewLine + Environment.NewLine + BaseClassFile + Environment.NewLine + BaseManagerFile + Environment.NewLine;
        string strSourceModule = BuilderSettings.ExportDir + "/" + BuilderSettings.ProjectName + "/" +  "BaseFile.cs";

        FileHelper.WriteAllText(strSourceModule, strCode);
        FileHelper.WriteAllText(BuilderSettings.ExportDir + "/" + BuilderSettings.ProjectName + "/" + "test.txt", strCode);

        ICodeCompiler icc = objCodeProvider.CreateCompiler();
        string OutputPath = BuilderSettings.ExportDir + "/" + BuilderSettings.ProjectName + "/" + BuilderSettings.ProjectName + ".dll";
        CompilerParameters parameters = new CompilerParameters();
        CompilerResults results;

        parameters.GenerateExecutable = false;
        parameters.OutputAssembly = OutputPath;
        parameters.GenerateInMemory = false;
        parameters.IncludeDebugInformation = false;

        //Add required assemblies
        DynamicLinkLibraries.Clear();

        //User defined
        DynamicLinkLibraries.Add(@"d:\wwwroot\\DC.Common\bin\Debug\DC.Common.dll");

        //System
        DynamicLinkLibraries.Add("System.dll");
        DynamicLinkLibraries.Add("System.Data.dll");
        DynamicLinkLibraries.Add("mscorlib.dll");
        DynamicLinkLibraries.Add("System.xml.dll");
        DynamicLinkLibraries.Add("System.web.dll");
        DynamicLinkLibraries.Add("System.configuration.dll");

        //Any dynamic assembly adding must be done here
        foreach (string strLibrary in DynamicLinkLibraries)
        {
            parameters.ReferencedAssemblies.Add(strLibrary);
        }

            results = icc.CompileAssemblyFromSource(parameters, strCode);

            if (results.Errors.Count > 0)
            {
                //report any compilation errors
                string strErrors = "Compilation failed:" + Environment.NewLine;

                foreach (CompilerError oError in results.Errors)
                {
                    strErrors = strErrors + "Line number " + oError.Line + ", Error Number: " + oError.ErrorNumber + ", '" + oError.ErrorText + ";";

                }

                throw new Exception("Error in CompileSourceCode(): " + Environment.NewLine + strErrors);
            }

            objCodeProvider = null;
            icc = null;
            parameters = null;");

Answer 2

The trick is to use a "persistable module" version of DefineDynamicModule method on the AssemblyBuilder instance. That is, instead of:

var module = ab.DefineDynamicModule(ab.GetName().Name);

use something like:

var module = ab.DefineDynamicModule(ab.GetName().Name, ab.GetName().Name + ".mod");

Thereafter the corresponding module appears in the assembly after saving.