Specifying memory-based assemblies for CompileAssemblyFromSource

It should work (at least it did for me)... Here is a sample application:

  using System.CodeDom.Compiler;
 
  class Program
  {
    static void Main(string[] args)
    {
      Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider();

      ICodeCompiler compiler = codeProvider.CreateCompiler();

      CompilerParameters parameters = new System.CodeDom.Compiler.CompilerParameters();
     
      parameters.ReferencedAssemblies.Add("System.dll");
      parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
     
      parameters.CompilerOptions = "/t:exe";

      parameters.GenerateExecutable = false;
      parameters.GenerateInMemory = true;
     
      string source = "";
      source += "class MyProgram {";
      source += " static void Main() {";
      source += " System.Windows.Forms.Form myForm = new System.Windows.Forms.Form();";
      source += " myForm.Text = \"Assembly Location: \" + System.Reflection.Assembly.GetExecutingAssembly().Location;";
      source += " System.Windows.Forms.Application.Run(myForm);";
      source += " }";
      source += "}";

      System.CodeDom.Compiler.CompilerResults results = compiler.CompileAssemblyFromSource(parameters, source);

      results.CompiledAssembly.EntryPoint.Invoke(null, null);
    }
  }

eternal_21, I think you misunderstood me. I already have working what you're written there.

My problem is with adding memory-based references. The references in your code (System.dll and System.Windows.Forms.dll) are DLL files, not memory-based assemblies. By memory-based assemblies I mean assemblies compiled directly into memory just like the one that ends up in your results.CompiledAssembly - in these cases there is no DLL that could be added to ReferencedAssemblies.

What I wanted to know is whether adding a reference to a memory-based assembly is possible or not, and if it is, how to do it.

I'll give you an example of what I'm trying to do here. In the below code, how would I add "myfirstclasslibrary" as a reference when I compile "mysecondclasslibrary"? I can't add myfirstclasslibrary.Location to ReferencedAssemblies since it's empty.

---

////////////////////////////////////////////
// We need a C# compiler first - this provider can do that for us

Microsoft.CSharp.CSharpCodeProvider csharp = new Microsoft.CSharp.CSharpCodeProvider();


////////////////////////////////////////////
// The first class library out of two

string code = "class MyClass { void MyMethod() { System.Windows.Forms.MessageBox.Show("It works"); } }";
System.CodeDom.Compiler.CompilerParameters parms = new System.CodeDom.Compiler.CompilerParameters();
parms.GenerateExecutable = false;
parms.GenerateInMemory = true;
parms.ReferencedAssemblies.Add("System.dll"); // Basic stuff
parms.ReferencedAssemblies.Add("System.Windows.Forms.dll"); // MessageBox
System.CodeDom.Compiler.CompilerResults results = csharp.CompileAssemblyFromSource(parms, code);
if (results.Errors.HasErrors)
{
      // Here I would be handling errors...
}

System.Reflection.Assembly myfirstclasslibrary = results.CompiledAssembly;


////////////////////////////////////////////
// The second class library, which depends on the first

code = "class MyOtherClass { void MyOtherMethod() { (new MyClass()).MyMethod(); } }";
parms = new System.CodeDom.Compiler.CompilerParameters();
parms.GenerateExecutable = false;
parms.GenerateInMemory = true;
parms.ReferencedAssemblies.Add("System.dll"); // Basic stuff

//////////////////////////////////
// --- THE PROBLEM ---

// The following would work if I had a DLL, but myfirstclasslibrary.Location
// is empty because myfirstclasslibrary is memory-based.

parms.ReferencedAssemblies.Add(myfirstclasslibrary.Location);

//////////////////////////////////

System.CodeDom.Compiler.CompilerResults results = csharp.CompileAssemblyFromSource(parms, code);
if (results.Errors.HasErrors)
{
      // Here I would be handling errors...
}

System.Reflection.Assembly mysecondclasslibrary = results.CompiledAssembly;

---

Sorry CyberSwine, your are correct: I did not understand the problem.  It is certainly an interesting one!  Just a first thought, since all assemblies are being compiled in memory, why bother creating descrete assemblies (i.e.: why not put all the code together and compile just one)?

I think gregoryyoung had it to start with...  I can't see any way to do reference an assembly that is not on disk.

It *is* possible. A friend suggested I try the following, which actually worked (apparently it was a lucky guess):

1. When the first assembly is compiled, set the OutputAssembly property of the CompilerParams object to a string of your choice (any string seems to be fine as long as it's unique for this assembly).

2. Add that name to the ReferencedAssemblies property when the second assembly is compiled.

It works like a charm. The name is also available from asm.GetName().Name, where asm is the assembly whose name you want.

I've noticed that even if I don't set a name in OutputAssembly, GetName().Name still returns one that seems to be a random set of eight characters. Unfortunately using that name as a reference won't work, so setting the name explicitly is necessary. I'm now using Guid.NewGuid() to generate names on the fly.




Moderators: Please close and refund this question.

You know, I tried that, and it didn't work... I don't know what I was doing wrong..!

If you would like to have this question refunded, you should post a note in Community Support.

I have made a post there, don't worry about it. :)

I have posted a solution above, which has been tested and works perfectly on my end.