Click here to Skip to main content
15,171,993 members
Articles / Programming Languages / C#
Posted 6 May 2002


170 bookmarked


Rate me:
Please Sign up or sign in to vote.
4.86/5 (55 votes)
6 May 2002Public Domain3 min read
Compile C# code on-the-fly. Usage in a plug-in / plug-out component model.

Sample Image - livecodedotnet.jpg

Disclaimer: The information in this article & source code is published in accordance with the final (V1) bits of the .NET Framework



This sample shows how to compile C# source-code on-the-fly, and how to use this in a plug-in / plug-out component model.


The namespace Microsoft.CSharp located in the .NET component "Managed C# Compiler" (cscompmgd.dll) has a Compiler class with the Compile() method to parse C# code in-process:

public static CompilerError[] Compile(
   string[] sourceTexts,
   string[] sourceTextNames,
   string target,
   string[] imports,
   IDictionary options

The LiveApp Windows Forms sample shows a TextBox control where the user can enter the C# source. Later we simply pass the TextBox.Text string to Compile().


To make the plug-in as flexible as possible, we only use a predefined interface ILiveInterface for any communications between the host and the plug-in. Note we don't use any late-binding, reflection or Invoke mechanics, but true interfaces!

This interface is compiled into a separate .NET library assembly, LiveInterface.dll. To keep our example as simple as possible, this interface has just one method:

public interface ILiveInterface
  string ModifyString( string inpString );

With ModifyString() we pass in a string and get the modified string back.

But note, the interface can have any number of methods with any kind of parameters and return values. Although there may be some limitations for cross app-domain communications.


Once loaded in an application, a .NET assembly is kept in memory. There is no possibility to release just one single assembly. The only way to get this effect is to unload the complete AppDomain.

This limitation forces us to use some techniques:

  • We have to create a separate (secondary) AppDomain to be unloaded later.
  • Unfortunately, there is no activation method to create a class instance in another AppDomain and to only return just a specific interface to this instance. We always get back an object reference, and this would force the plug-in-assembly to be attached to our primary AppDomain! If this happens, there is no way to "plug-out" the plug-in-assembly later.
  • To workaround this, I used a class-factory approach.

The class-factory is just a simple class also located in the same assembly LiveInterface.dll like ILiveInterface is. It provides one Create() method as a wrapper for the .NET Activator.CreateInstanceFrom() call:

public class LiveInterfaceFactory : MarshalByRefObject
  public ILiveInterface Create( string assemblyFile, string typeName, 
      object[] constructArgs )
    return (ILiveInterface) Activator.CreateInstanceFrom(
         assemblyFile, typeName, false, bfi, null, constructArgs,
         null, null, null ).Unwrap();

The most important feature of the Create() method is to only return our interface, but NOT the object! This way, the only real connection between the two app-domains is our well-known interface.

Finally, this lets us to unload an app-domain like:

AppDomain.Unload( secDom );

Sample App

The LiveCode.NET example solution contains this two projects:

  • LiveInterface: interface & class-factory only assembly
  • LiveApp: sample Windows Forms application for hosting plug-ins

You can see the LiveApp GUI on the screenshot at the top of this page.

The initial plug-in source-code is loaded from file InitialLiveClass.cs into the TextBox. The user can now modify this code, as long as the interface and class-name is unchanged.

Another TextBox lets the user type the string for the class constructor parameter, and one more is for the ModifyString() method parameter.

If the user hits the Run! button, this executes these two steps:

private void btnRun_Click(object sender, System.EventArgs e)
    DoCompile();        // compile the C# source
    DoRun();            // execute live!
  catch( Exception )

DoCompile() just compiles passing the C# source, the referenced assemblies and compiler options:

private void DoCompile()
  string[] srcCodes = new string[] { textSourceCode.Text };    
      // the source code
  string[] referAsm = new string[] { "LiveInterface.dll" };    
      // referencing assembly
  string outFile    = "LiveAssembly.dll";                      
      // the assembly to create
  ListDictionary cplOpts = new ListDictionary();               
      // compiler parameters
  cplOpts.Add( "target", "library" );
  CompilerError[] ces = Microsoft.CSharp.Compiler.Compile( srcCodes,
                                  srcNames, outFile, referAsm, cplOpts );

DoRun() loads the new assembly into a secondary app-domain and executes the method:

private void DoRun()
  // create a secondary app-domain
  AppDomain secDom = AppDomain.CreateDomain( "SecondaryDomain" );

  // create the factory class in the secondary app-domain
  LiveInterfaceFactory factory = (LiveInterfaceFactory) secDom.CreateInstance(
      "LiveInterface", "LiveCode.LiveInterface.LiveInterfaceFactory" ).Unwrap();

  // with the help of this factory, we can now create a real 'LiveClass' instance
  object[] constructArgs = new object[] { textConstruct.Text };
  ILiveInterface ilive = factory.Create( "LiveAssembly.dll",
      "LiveCode.LiveSample.LiveClass", constructArgs );

  // finally, we call the 'LiveClass' instance method using our ILiveInterface
  textReturned.Text = ilive.ModifyString( textParam.Text );

  // release all references to the factory and ILiveInterface
  factory = null;
  ilive = null;

  // unload the complete secondary app-domain
  AppDomain.Unload( secDom );

The string returned by ModifyString() is made visible in the bottommost TextBox. All source code is included in the download. With VS.NET, just load the solution \LiveApp.sln

MultiPlug sample

Another sample is included to show a generic use of plug-ins. It is just a visualisation of the presented component concept. You can interactively create application domains, load assemblies and instantiate plug-in classes. Finally, you could release the instances and unload a complete AppDomain.

MultiPlug Sample Screenshot

An important hint if you extend the component model: Please be sure to specify the class interface inheritance list by placing the plug-in interfaces at the beginning:

public class YourPluginClass : MarshalByRefObject, IPlugInterface,

If you write the wrong order:

public class YourPluginClass : MarshalByRefObject, IYourLocalInterface,

your plugin-assembly will be attached to the primary domain and thus be locked.


  • Microsoft.CSharp.Compiler.Compile needs the multithreaded apartment => [MTAThread]
  • plugin namespace- and class names have to be fixed or e.g. 'registered' in any way.


This article, along with any associated source code and files, is licensed under A Public Domain dedication


About the Author

Web Developer
Switzerland Switzerland
No Biography provided

Comments and Discussions

GeneralMy vote of 5 Pin
Manoj Kumar Choubey26-Feb-12 19:22
professionalManoj Kumar Choubey26-Feb-12 19:22 
GeneralMy vote of 5 Pin
Matt Esterak17-Mar-11 2:47
MemberMatt Esterak17-Mar-11 2:47 
GeneralQuestion to NETMaster Pin
salieri119-Jul-06 0:12
Membersalieri119-Jul-06 0:12 
QuestionCan't compile two times Pin
fluminis26-Nov-05 0:08
Memberfluminis26-Nov-05 0:08 
AnswerRe: Can't compile two times Pin
nuki0713-Jun-06 3:42
Membernuki0713-Jun-06 3:42 
GeneralRe: Can't compile two times Pin
Rafael Nicoletti25-Jul-06 4:27
MemberRafael Nicoletti25-Jul-06 4:27 
GeneralThreading Pin
Jonas Beckeman4-Aug-05 11:56
MemberJonas Beckeman4-Aug-05 11:56 
GeneralRe: Threading Pin
Jonas Beckeman4-Aug-05 12:57
MemberJonas Beckeman4-Aug-05 12:57 
GeneralObsolete DLL Pin
NETMaster4-Jun-05 22:26
MemberNETMaster4-Jun-05 22:26 
Generalquestion of globalization Pin
lein0012-Feb-05 10:41
susslein0012-Feb-05 10:41 
GeneralWhy the Factory Pin
mikeperetz11-Jan-05 13:06
Membermikeperetz11-Jan-05 13:06 
GeneralRe: Why the Factory Pin
NETMaster12-Jan-05 10:03
MemberNETMaster12-Jan-05 10:03 
GeneralRe: Why the Factory Pin
Tomerland18-Apr-07 4:49
MemberTomerland18-Apr-07 4:49 
Generalproblem using this idea in a plugin Pin
whatever1192613-Jan-04 7:06
Memberwhatever1192613-Jan-04 7:06 
GeneralRe: problem using this idea in a plugin Pin
Anonymous14-Jan-04 10:20
MemberAnonymous14-Jan-04 10:20 
GeneralUsing in ASP.Net Pin
LPLMG8-Dec-03 15:22
MemberLPLMG8-Dec-03 15:22 
Generalvs process Pin
osto5-Dec-03 19:51
Memberosto5-Dec-03 19:51 
GeneralRe: vs process Pin
Nahor22-Dec-03 11:43
MemberNahor22-Dec-03 11:43 
GeneralRe: vs process Pin
chriskoiak16-Feb-04 5:39
Memberchriskoiak16-Feb-04 5:39 
GeneralIs there another way Pin
neutral7-Nov-03 13:25
Memberneutral7-Nov-03 13:25 
GeneralGlobalization Pin
Member 52106017-Aug-03 22:34
MemberMember 52106017-Aug-03 22:34 
GeneralTranslation to VB.NET Pin
Luharhar15-Jul-03 14:02
MemberLuharhar15-Jul-03 14:02 
GeneralRe: Translation to VB.NET Pin
aaava15-Nov-07 12:02
Memberaaava15-Nov-07 12:02 
GeneralExcellent article but... what about Windows Forms? II Pin
Anonymous11-Jun-03 2:46
MemberAnonymous11-Jun-03 2:46 
GeneralEmulate a Mouse event Pin
Amauw Scritz7-Apr-03 9:25
MemberAmauw Scritz7-Apr-03 9:25 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.