using System.CodeDom.Compiler;
    using Microsoft.CSharp;
    using Microsoft.VisualBasic;

 CompilerParameters cparams = new CompilerParameters();
 
 cparams.GenerateInMemory = false;
 cparams.IncludeDebugInformation = true;
 cparams.CompilerOptions += " /debug:pdbonly";
 
 cparams.TreatWarningsAsErrors = false;
 cparams.GenerateExecutable = false;

CodeDomProvider provider = CSharpCodeProvider();
CompilerResults result = provider.CompileAssemblyFromFile(cparams, script);

using System;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
using Microsoft.VisualBasic;
using System.Reflection;
using System.IO;
 
namespace ScriptingExample
{
    public class Script
    {
        public LoadedType LoadScript<LoadedType>(string script, string referenceString) where LoadedType:class
        {
            // this will load/compile the script source file, "script", and return a type of LoadedType
            // it is assumed that a type of "LoadedType" is defined in the script
            // the referenceString is a comma delimited string identifying all references needed by the script
            // e.g. "System.dll,System.Windows.Forms.dll"
            // either the VB or C# compiler will be invoked, based upon the file extenstion .vb or .cs
 
            // try and compile the script
            CompilerParameters cparams = CreateCompilerParameters(referenceString);
            CompilerResults results = CompileScript(script, cparams);
 
            // check for errors
            if (results.Errors.HasErrors)
            {
                string e = "";
                foreach (CompilerError error in results.Errors)
                    e += (error.ErrorText + Environment.NewLine);
 
                throw new Exception("ERROR IN SCRIPT: " + Environment.NewLine + e);
            }
 
            // find the "exported" type to load
            LoadedType scriptObject = FindScriptObject<LoadedType>(results.CompiledAssembly);
 
            if (scriptObject == null)
                throw new Exception("CAN'T LOAD SCRIPT, TARGET TYPE NOT IMPLEMENTED IN SCRIPT.");
            else
                return scriptObject;
        }
 
        private CompilerResults CompileScript(string script, CompilerParameters cparams)
        {
            // compiles the script using the specified parameters
            // either the VB or C# compiler will be invoked, based upon the file extenstion .vb or .cs
            CodeDomProvider provider = GetCompiler(script);
            CompilerResults result = provider.CompileAssemblyFromFile(cparams, script);
 
            return result;
        }
 
        CodeDomProvider GetCompiler(string script)
        {
            // returns the correct compiler to use based on the file extension of the script
            string extension = Path.GetExtension(script);
 
            if (extension == ".vb")
                return new VBCodeProvider();
            else if (extension == ".cs")
                return new CSharpCodeProvider();
            else
                throw new Exception("UNKNOWN SCRIPT TYPE");
        }
 
        private LoadedType FindScriptObject<LoadedType>(Assembly assembly) where LoadedType : class
        {
            // attempts to locate the type "LoadedType" within the assembly that was created from the "script"
            foreach (Type t in assembly.GetTypes())
                if (typeof(LoadedType).IsAssignableFrom(t))
                    return Activator.CreateInstance(t) as LoadedType;
 
            return default(LoadedType);
        }
 
        private CompilerParameters CreateCompilerParameters(string referenceString)
        {
            // creates compiler parameters to generate an in memory assembly, with debug
            // symbols if this is a debug build
            // the referenceString is a comma delimited string identifying all references needed by the script
            CompilerParameters cparams = new CompilerParameters();
 
            cparams.GenerateInMemory = true;
 
            #if DEBUG
                // create debug symbols if this is a debug build
                cparams.IncludeDebugInformation = true;
                cparams.CompilerOptions += " /debug:pdbonly";
            #endif
 
            cparams.TreatWarningsAsErrors = false;
            cparams.GenerateExecutable = false; 
 
            // seperate reference string
            string[] references = referenceString.Split(',');
 
            foreach (string reference in references)
                cparams.ReferencedAssemblies.Add(reference);
 
            return cparams;
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
 
namespace ScriptingExample
{
    // we have to define an interface so we know how to "talk" to
    // the script, that is, there must be a type that we *know* the
    // script implements so we can call methods on it
    public interface MyScript
    {
        void Execute();
    }
 
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            // just populate the combo box with all "scripts" located in the directory "Scripts"
            foreach (string file in Directory.GetFiles("Scripts"))
                comboBox1.Items.Add(file);
 
            if (comboBox1.Items.Count > 0)
                comboBox1.SelectedIndex = 0;
            else
            {
                button1.Enabled = false;
                comboBox1.Enabled = false;
            }
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            // load the script, which contains a type that implements MyScript
            // and call the execute method on it
            Script s = new Script();
 
            // these are the references the script will need, we must reference this executable
            // because the script needs to see the MyScript data type
            // this is just a sample, in a real application such types would be defined in an assembly dll
            // that is shared between the app consuming the script and the script itself
            string references = "System.dll,System.Windows.Forms.dll," + Directory.GetCurrentDirectory() + "\\ScriptingExample.exe";
 
            MyScript script = s.LoadScript<MyScript>(comboBox1.SelectedItem as string, references);
 
            script.Execute();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
 
namespace ScriptingExample.Scripts
{
    public class CSharpScript : MyScript
    {
        public void Execute()
        {
            MessageBox.Show("I AM A C# SCRIPT");
        }
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.Windows.Forms
 
Namespace ScriptingExample.Scripts
    Public Class VBScript
        Implements MyScript
        Public Sub Execute() Implements MyScript.Execute
            MessageBox.Show("I AM A VB SCRIPT!!")
        End Sub
    End Class
End Namespace