C# CSharpCodeProvider.Dispose方法代码示例

        public static string compilerte(string outputname, string sourcecode)
        {
            var codeProvider = new CSharpCodeProvider();
            var provider = CodeDomProvider.CreateProvider("CSharp");

            var exeName = outputname;

            var cp = new CompilerParameters
            {
                GenerateExecutable = true,
                OutputAssembly = exeName,
                GenerateInMemory = false,
                TreatWarningsAsErrors = false
            };

            var cr = provider.CompileAssemblyFromSource(cp, translatetocsharp(sourcecode));

            if (cr.Errors.Count > 0)
            {
                var builder = new StringBuilder();
                builder.Append("Cehape broke our codes that were supposed to be compiled here: " + cr.PathToAssembly);
                foreach (CompilerError ce in cr.Errors)
                {
                    builder.Append(Environment.NewLine + ce.ToString());
                }
                codeProvider.Dispose();
                return builder.ToString();
            }
            else
            {
                codeProvider.Dispose();
                return ("We were able to compile {0} successfully without cehape messing with it.".Replace("{0}", cr.PathToAssembly));
            }
        }

        private CompilerResults Compile(string code, CompilerParameters compilerParameters)
        {
            CSharpCodeProvider codeProvider = new CSharpCodeProvider(new Dictionary<String, String> { { "CompilerVersion", "v4.0" } });

            CompilerResults results = codeProvider.CompileAssemblyFromSource(compilerParameters, new string[] { code });

            codeProvider.Dispose();

            return results;
        }

        internal static async Task<LiveCodeCompilationResult> Compile(IEnumerable<string> sourceFilesPaths, string projectName, IEnumerable<string> references, bool createAssemblyFiles = false)
        {
            string[] filesPaths = sourceFilesPaths as string[] ?? sourceFilesPaths.ToArray();
            string[] sourceFiles = filesPaths.ToArray();
            string location = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            string assemblyName = GetNewAssemblyName(projectName, location);

            // clean up previous assemblies

            DeletePreviousAssemblies(projectName, location);

            // setup compilation parameters

            var options = SetupCompilationParameters(createAssemblyFiles, assemblyName, sourceFiles, location, references);

            // compile

            var cSharpCodeProvider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } });
            CompilerResults results = await cSharpCodeProvider.CompileAsync(options, sourceFiles);
            cSharpCodeProvider.Dispose();

            var errorMessage = new StringBuilder();
            if (results.Errors.HasErrors)
            {
                errorMessage.Append(string.Format("Compilation errors for {0}", projectName));
                foreach (CompilerError error in results.Errors)
                {
                    errorMessage.Append(string.Format("{0}({1},{2}): {3}", error.FileName, error.Line, error.Column, error.ErrorText));
                }

                return new LiveCodeCompilationResult{ ErrorMessage = errorMessage.ToString() };
            }
            
            // load compiled assembly

            if (createAssemblyFiles)
            {
                // load from disk
                return await LoadAssemblyFromDisk(assemblyName);
            }
            
            // load from memory 
            return new LiveCodeCompilationResult { Assembly = results.CompiledAssembly, HasSucceed = true };
        }

 /* From http://www.codeproject.com/Articles/9019/Compiling-and-Executing-Code-at-Runtime */
 public Assembly BuildAssembly(string[] Code, string[] ReferencedAssemblies)
 {
     Microsoft.CSharp.CSharpCodeProvider Compiler = new CSharpCodeProvider();
     CompilerParameters CompilerParams = new CompilerParameters();
     CompilerParams.GenerateExecutable = false;
     CompilerParams.GenerateInMemory = true;
     CompilerParams.IncludeDebugInformation = false;
     CompilerParams.ReferencedAssemblies.AddRange(ReferencedAssemblies);
     CompilerResults Results = Compiler.CompileAssemblyFromSource(CompilerParams, Code);
     Compiler.Dispose();
     if (Results.Errors.HasErrors)
     {
         StringBuilder Errors = new StringBuilder("Compiler Errors :\r\n");
         foreach (CompilerError Error in Results.Errors)
         {
             Errors.AppendFormat("Line {0},{1}\t: {2}\n", Error.Line, Error.Column, Error.ErrorText);
         }
         throw new Exception(Errors.ToString());
     }
     else
     {
         return Results.CompiledAssembly;
     }
 }

            public DynamicAssembly(string nameWithoutExtension, DynamicAssembly[] references = null, Version version = null, bool fakeIdentity = false)
            {
                if (version == null)
                {
                    version = new Version(1, 0, 0, 0);
                }

                if (references == null)
                {
                    references = new DynamicAssembly[0];
                }

                Name = nameWithoutExtension;
                Namespace = nameWithoutExtension;
                FileName = $"{Namespace}{Path.GetFileNameWithoutExtension(Path.GetRandomFileName())}{Interlocked.Increment(ref dynamicAssemblyId)}.dll";
                DynamicName = Path.GetFileNameWithoutExtension(FileName);

                var builder = new StringBuilder();
                builder.AppendLine("using System.Reflection;");
                builder.AppendLine($"[assembly: AssemblyVersion(\"{version}\")]");
                builder.AppendLine($"[assembly: AssemblyFileVersion(\"{version}\")]");

                builder.AppendFormat("namespace {0} {{ ", Namespace);

                var provider = new CSharpCodeProvider();
                var param = new CompilerParameters(new string[]
                {
                }, FileName);
                param.GenerateExecutable = false;
                param.GenerateInMemory = false;
                param.OutputAssembly = FilePath = Path.Combine(TestAssemblyDirectory, FileName);
                param.TempFiles = new TempFileCollection(TestAssemblyDirectory, false);

                foreach (var reference in references)
                {
                    builder.AppendLine($"using {reference.Namespace};");
                    param.ReferencedAssemblies.Add(reference.FilePath);
                }

                builder.AppendLine("public class Foo { public Foo() {");
                foreach (var reference in references)
                {
                    builder.AppendLine($"new {reference.Namespace}.Foo();");
                }
                builder.AppendLine("} } }");

                var result = provider.CompileAssemblyFromSource(param, builder.ToString());
                ThrowIfCompilationWasNotSuccessful(result);

                provider.Dispose();

                if (fakeIdentity)
                {
                    var reader = AssemblyDefinition.ReadAssembly(FilePath);
                    reader.Name.Name = nameWithoutExtension;
                    reader.MainModule.Name = nameWithoutExtension;
                    reader.Write(FilePath);
                }

                Assembly = result.CompiledAssembly;
            }

        public void CompilePlugins(PermissionSet pluginSandboxPermissions, List<String> ignoredPluginClassNames = null) {
            try {

                if (File.Exists(Path.Combine(this.PluginBaseDirectory, "PluginCache.xml")) == true) {
                    WritePluginConsole("Loading plugin cache..");

                    try {
                        this.PluginCache = XDocument.Load(Path.Combine(this.PluginBaseDirectory, "PluginCache.xml")).Root.FromXElement<PluginCache>();
                    }
                    catch (Exception e) {
                        WritePluginConsole("Error loading plugin cache: {0}", e.Message);
                    }
                }

                // Recover from exceptions or logic errors if the document parsed correctly, but didn't deserialize correctly.
                if (this.PluginCache == null) {
                    this.PluginCache = new PluginCache();
                }

                // Make sure we ignore any plugins passed in. These won't even be loaded again.
                if (ignoredPluginClassNames != null) {
                    IgnoredPluginClassNames = ignoredPluginClassNames;
                }

                // Clear out all invocations if this is a reload.
                Invocations.Clear();

                WritePluginConsole("Preparing plugins directory..");
                PreparePluginsDirectory();

                WritePluginConsole("Moving legacy plugins..");
                MoveLegacyPlugins();

                WritePluginConsole("Creating compiler..");
                // CodeDomProvider pluginsCodeDomProvider = CodeDomProvider.CreateProvider("CSharp");
                var providerOptions = new Dictionary<String, String>();
                providerOptions.Add("CompilerVersion", "v3.5");
                CodeDomProvider pluginsCodeDomProvider = new CSharpCodeProvider(providerOptions);

                WritePluginConsole("Configuring compiler..");
                CompilerParameters parameters = GenerateCompilerParameters();
                // AppDomainSetup domainSetup = new AppDomainSetup() { ApplicationBase = this.PluginBaseDirectory };
                // Start of XpKillers mono workaround

                AppDomainSetup domainSetup = null;
                Type t = Type.GetType("Mono.Runtime");
                if (t != null) {
                    //Console.WriteLine("You are running with the Mono VM");
                    WritePluginConsole("Running with Mono VM..");
                    //AppDomain.CurrentDomain.BaseDirectory
                    domainSetup = new AppDomainSetup() {
                        ApplicationBase = AppDomain.CurrentDomain.BaseDirectory
                    };
                    domainSetup.PrivateBinPath = PluginBaseDirectory;
                }
                else {
                    // Console.WriteLine("You are running something else (native .Net)");
                    WritePluginConsole("Running with native .Net..");
                    domainSetup = new AppDomainSetup() {
                        ApplicationBase = PluginBaseDirectory
                    };
                }
                // Workaround end

                WritePluginConsole("Building sandbox..");
                var hostEvidence = new Evidence();
                hostEvidence.AddHost(new Zone(SecurityZone.MyComputer));

                AppDomainSandbox = AppDomain.CreateDomain(ProconClient.HostName + ProconClient.Port + "Engine", hostEvidence, domainSetup, pluginSandboxPermissions);

                WritePluginConsole("Configuring sandbox..");
                // create the factory class in the secondary app-domain
                PluginFactory = (CPRoConPluginLoaderFactory) AppDomainSandbox.CreateInstance("PRoCon.Core", "PRoCon.Core.Plugin.CPRoConPluginLoaderFactory").Unwrap();
                PluginCallbacks = new CPRoConPluginCallbacks(ProconClient.ExecuteCommand, ProconClient.GetAccountPrivileges, ProconClient.GetVariable, ProconClient.GetSvVariable, ProconClient.GetMapDefines, ProconClient.TryGetLocalized, RegisterCommand, UnregisterCommand, GetRegisteredCommands, ProconClient.GetWeaponDefines, ProconClient.GetSpecializationDefines, ProconClient.Layer.GetLoggedInAccounts, RegisterPluginEvents);

                WritePluginConsole("Compiling and loading plugins..");


                var pluginsDirectoryInfo = new DirectoryInfo(PluginBaseDirectory);

                foreach (FileInfo pluginFile in pluginsDirectoryInfo.GetFiles("*.cs")) {
                    string className = Regex.Replace(pluginFile.Name, "\\.cs$", "");

                    if (IgnoredPluginClassNames.Contains(className) == false) {
                        CompilePlugin(pluginFile, className, pluginsCodeDomProvider, parameters);

                        LoadPlugin(className, PluginFactory, pluginSandboxPermissions.IsUnrestricted());
                    }
                    else {
                        WritePluginConsole("Compiling {0}... ^1^bIgnored", className);
                    }
                }

                XDocument pluginCacheDocument = new XDocument(this.PluginCache.ToXElement());

                pluginCacheDocument.Save(Path.Combine(this.PluginBaseDirectory, "PluginCache.xml"));

                pluginsCodeDomProvider.Dispose();
            }
            catch (Exception e) {
//.........这里部分代码省略.........

        public void CompilePlugins(PermissionSet pluginSandboxPermissions, List<String> ignoredPluginClassNames = null) {

            try {

                // Make sure we ignore any plugins passed in. These won't even be loaded again.
                if (ignoredPluginClassNames != null) {
                    this.IgnoredPluginClassNames = ignoredPluginClassNames;
                }

                // Clear out all invocations if this is a reload.
                this.Invocations.Clear();

                this.WritePluginConsole("Preparing plugins directory..");
                this.PreparePluginsDirectory();
                this.CleanPlugins();

                this.WritePluginConsole("Moving legacy plugins..");
                this.MoveLegacyPlugins();

                this.WritePluginConsole("Creating compiler..");
                // CodeDomProvider pluginsCodeDomProvider = CodeDomProvider.CreateProvider("CSharp");
                Dictionary<String, String> providerOptions = new Dictionary<String, String>();
                providerOptions.Add("CompilerVersion", "v3.5");
                CodeDomProvider pluginsCodeDomProvider = new CSharpCodeProvider(providerOptions);

                this.WritePluginConsole("Configuring compiler..");
                CompilerParameters parameters = GenerateCompilerParameters();
                // AppDomainSetup domainSetup = new AppDomainSetup() { ApplicationBase = this.PluginBaseDirectory };
                // Start of XpKillers mono workaround

                AppDomainSetup domainSetup = null;
                Type t = Type.GetType("Mono.Runtime");
                if (t != null)
                {
                    //Console.WriteLine("You are running with the Mono VM");
                    this.WritePluginConsole("Running with Mono VM..");
                    //AppDomain.CurrentDomain.BaseDirectory
                    domainSetup = new AppDomainSetup() { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory };
                    domainSetup.PrivateBinPath = this.PluginBaseDirectory;
                }
                else
                {
                    // Console.WriteLine("You are running something else (native .Net)");
                    this.WritePluginConsole("Running with native .Net..");
                    domainSetup = new AppDomainSetup() { ApplicationBase = this.PluginBaseDirectory };
                }
                // Workaround end

                this.WritePluginConsole("Building sandbox..");
                Evidence hostEvidence = new Evidence();
                hostEvidence.AddHost(new Zone(SecurityZone.MyComputer));

                this.m_appDomainSandbox = AppDomain.CreateDomain(this.m_client.HostName + this.m_client.Port + "Engine", hostEvidence, domainSetup, pluginSandboxPermissions);

                this.WritePluginConsole("Configuring sandbox..");
                // create the factory class in the secondary app-domain
                CPRoConPluginLoaderFactory pluginFactory = (CPRoConPluginLoaderFactory)this.m_appDomainSandbox.CreateInstance("PRoCon.Core", "PRoCon.Core.Plugin.CPRoConPluginLoaderFactory").Unwrap();
                this.m_cpPluginCallbacks = new CPRoConPluginCallbacks(this.m_client.ExecuteCommand, this.m_client.GetAccountPrivileges, this.m_client.GetVariable, this.m_client.GetSvVariable, this.m_client.GetMapDefines, this.m_client.TryGetLocalized, this.RegisterCommand, this.UnregisterCommand, this.GetRegisteredCommands, this.m_client.GetWeaponDefines, this.m_client.GetSpecializationDefines, this.m_client.Layer.GetLoggedInAccounts, this.RegisterPluginEvents);

                this.WritePluginConsole("Compiling and loading plugins..");


                DirectoryInfo pluginsDirectoryInfo = new DirectoryInfo(this.PluginBaseDirectory);
                FileInfo[] a_pluginsFileInfo = pluginsDirectoryInfo.GetFiles("*.cs");

                foreach (FileInfo pluginFile in a_pluginsFileInfo) {

                    string className = Regex.Replace(pluginFile.Name, "\\.cs$", "");

                    if (this.IgnoredPluginClassNames.Contains(className) == false) {
                        this.CompilePlugin(pluginFile, className, pluginsCodeDomProvider, parameters);

                        this.LoadPlugin(className, pluginFactory, pluginSandboxPermissions.IsUnrestricted());
                    }
                    else {
                        this.WritePluginConsole("Compiling {0}... ^1^bIgnored", className);
                    }
                }

                pluginsCodeDomProvider.Dispose();
            }
            catch (Exception e) {
                this.WritePluginConsole(e.Message);
            }
        }

		private void ThrowIfErrorsIn(CompilerResults results, IEnumerable<SourceFile> files)
		{
			if (results.Errors.Count > 0)
			{
				StringBuilder message = new StringBuilder();
				CodeDomProvider cSharpCodeProvider;
				try
				{
					cSharpCodeProvider = CodeDomProvider.GetCompilerInfo("csharp").CreateProvider();
				}
				catch (SecurityException)
				{
					cSharpCodeProvider = new CSharpCodeProvider();
				}
				catch (ConfigurationException)
				{
					cSharpCodeProvider = new CSharpCodeProvider();
				}

				try
				{
					foreach (SourceFile file in files)
					{
						CompilerResults result = cSharpCodeProvider.CompileAssemblyFromSource(parameters, file.ConcreteClass);
						if (result.Errors.Count > 0)
							foreach (CompilerError err in result.Errors)
								message.AppendLine(string.Format(@"
On '{0}' (class name: {1}) Line {2}, Column {3}, {4} {5}:
{6}
========================================",
								file.ViewName,
								file.ClassName,
								err.Line,
								err.Column,
								err.IsWarning ? "Warning" : "Error",
								err.ErrorNumber,
								err.ErrorText));
					}
				}
				finally
				{
					cSharpCodeProvider.Dispose();
				}
				throw new Exception("Error while compiling views: " + message);
			}
		}

        internal static Assembly GetProxyAssembly(string wsdlUri, string codeNamespace)
        {
            var provider = new CSharpCodeProvider();
            var client = new WebClient();
            var referenceAssemblies = new[] { "system.dll", "System.Xml.dll", "System.Web.Services.dll" };
            var wsdlStream = client.OpenRead(wsdlUri);

            var wsdl = ServiceDescription.Read(wsdlStream);
            var wsdlImport = new ServiceDescriptionImporter();
            wsdlImport.AddServiceDescription(wsdl, null, null);

            var proxyClassNamespace = new CodeNamespace(codeNamespace);
            var codeCompileUnit = new CodeCompileUnit();
            codeCompileUnit.Namespaces.Add(proxyClassNamespace);

            var warnings = wsdlImport.Import(proxyClassNamespace, codeCompileUnit);
            if (warnings != 0)
            {
                throw new ApplicationException("SOAPHTTPRequestResponseStep experienced problems while importing the WSDL!");
            }

            var compileParam = new CompilerParameters(referenceAssemblies)
                                   {
                                       GenerateInMemory = false,
                                       OutputAssembly = GetProxyFileName()
                                   };

            CompilerResults compilerResults = provider.CompileAssemblyFromDom(compileParam, codeCompileUnit);

            if (compilerResults.Errors.HasErrors)
            {
                throw new ApplicationException("SOAPHTTPRequestResponseStep experienced problems while executing CompileAssemblyFromDom");
            }

            provider.Dispose();

            return compilerResults.CompiledAssembly;
        }

        /// <summary>
        /// Compile Script -> Return Assembly
        /// </summary>
        public Assembly CompileScript(IRefObject ScriptObject, out CompilerResults Result, String script, bool ClientSide = false)
        {
            String ClassName, PrefixName, AssemblyName = "";

            switch (ScriptObject.Type)
            {
                case IRefObject.ScriptType.WEAPON:
                    ClassName = "ScriptWeapon";
                    PrefixName = "WeaponPrefix";
                    ServerWeapon tempWeap = (ServerWeapon)ScriptObject;
                    AssemblyName = tempWeap.Name.Replace("-", "weapon").Replace("*", "weapon");
                    break;
                case IRefObject.ScriptType.CLASS:
                    PrefixName = "NpcClass";
                    ServerClass tempClass = (ServerClass)ScriptObject;
                    ClassName = tempClass.Name;
                    AssemblyName = "NpcClass." + tempClass.Name + ".dll";
                    break;
                default:
                    ClassName = "ScriptLevelNpc";
                    PrefixName = "LevelNpcPrefix";
                    //ScriptLevelNpc tempNpc = (ScriptLevelNpc)ScriptObject;
                    AssemblyName = "";
                    break;
            }

            // Setup our options
            CompilerParameters options = new CompilerParameters();
            options.GenerateExecutable = false;

            if (ClientSide || ScriptObject.Type == IRefObject.ScriptType.CLASS)
                options.GenerateInMemory = false;
            else
                options.GenerateInMemory = true;

            if (!ClientSide)
                options.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
            options.ReferencedAssemblies.Add("System.dll");
            options.ReferencedAssemblies.Add("System.Core.dll");
            options.ReferencedAssemblies.Add("OpenGraal.Core.dll");
            options.ReferencedAssemblies.Add("OpenGraal.Common.dll");
            options.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
            options.ReferencedAssemblies.Add("MonoGame.Framework.dll");
            if (this.GetClasses() != null)
            {
                foreach (KeyValuePair<string, ServerClass> npcClass in this.GetClasses())
                {
                    if (npcClass.Value.Asm != null)
                        options.ReferencedAssemblies.Add(npcClass.Value.Asm);
                }
            }

            //options.ReferencedAssemblies.
            options.CompilerOptions = "/optimize";

            if (AssemblyName == "")
                AssemblyName = PrefixName + NextId[(int)ScriptObject.Type];

            if (ClientSide)
                options.OutputAssembly = AssemblyName + "_ClientSide.dll";

            if (ScriptObject.Type == IRefObject.ScriptType.CLASS)
                options.OutputAssembly = AssemblyName;

            // Compile our code
            CSharpCodeProvider csProvider = new Microsoft.CSharp.CSharpCodeProvider();

            string usingNamespace = "";
            usingNamespace = "using Microsoft.Xna.Framework.Input;";
            string[] CompileData = new string[1];
            if (ScriptObject.Type != IRefObject.ScriptType.CLASS)
                CompileData.SetValue("using System;" + usingNamespace + "using OpenGraal; using OpenGraal.Core; using OpenGraal.Common.Levels; using OpenGraal.Common.Players; using OpenGraal.Common.Scripting; " + (this.GetClasses() != null && this.GetClasses().Count > 0 ? "using OpenGraal.Common.Scripting.NpcClass;" : "") + " public class " + PrefixName + NextId[(int)ScriptObject.Type] + " : " + ClassName + " { public " + PrefixName + NextId[(int)ScriptObject.Type] + "(CSocket Server, IRefObject Ref) : base(Server, Ref) { } " + script + " } ", 0);
            else
                CompileData.SetValue("using System;" + usingNamespace + "using OpenGraal; using OpenGraal.Core; using OpenGraal.Common.Levels; using OpenGraal.Common.Players; using OpenGraal.Common.Scripting; namespace OpenGraal.Common.Scripting.NpcClass { public class " + ClassName + " { " + script + "\n } }", 0);

            Result = null;
            try
            {
                Result = csProvider.CompileAssemblyFromSource(options, CompileData);
            }
            catch (Exception e)
            {
                return null;
            }
            csProvider.Dispose();

            NextId[(int)ScriptObject.Type]++;
            return (Result.Errors.HasErrors ? null : Result.CompiledAssembly);
        }

        /// <exception cref="Exception"><c>Exception</c>.</exception>
        public void CreateLauncher(bool retributionLauncher)
        {
            LoggingManager.SendMessage("ModPacker - Generating launcher for mod " + ModManager.ModName);

            string outputPath = m_sOutputDirectory + "Launch " + ModManager.ModName + ".exe";
            CodeDomProvider provider = null;
            try
            {
                var provOpts = new Dictionary<string, string> { { "CompilerVersion", "v2.0" } };
                provider = new CSharpCodeProvider(provOpts);
                var compilerParams = new CompilerParameters
                {
                    GenerateExecutable = true,
                    IncludeDebugInformation = false,
                    OutputAssembly = outputPath
                };
                compilerParams.ReferencedAssemblies.Add("System.dll");

                // set an icon if the user wishes to include one
                if (m_sIconPath != string.Empty && File.Exists(m_sIconPath))
                    compilerParams.CompilerOptions = "/win32icon:\"" + m_sIconPath + "\"";
                string tmp = Resources.CrudeLauncherSource.Replace("_MODNAME_", ModManager.ModName);
                tmp = tmp.Replace("_APPID_", retributionLauncher ? GameConstants.RETRIBUTION_APP_ID : GameConstants.CR_APP_ID);
                provider.CompileAssemblyFromSource(compilerParams, tmp);
                provider.Dispose();
            }
            catch (Exception ex)
            {
                if (provider != null)
                    provider.Dispose();
                LoggingManager.SendMessage("ModPacker - Failed to create launcher for mod " + ModManager.ModName);
                LoggingManager.HandleException(ex);
                throw;
            }
            LoggingManager.SendMessage("ModPacker - Successfully created launcher for mod " + ModManager.ModName);
        }

  public static ValuesPair<CodeQuery, List<String>> GetCodeQuery(Type type, string typeWrapperCode)
  {
   CSharpCodeProvider cscp = null;

   try
   {
    cscp = new CSharpCodeProvider();
    ValuesPair<CodeQuery, List<String>> res = 
    new ValuesPair<CodeQuery, List<string>>(null, new List<string>());
    CodeQuery query = new CodeQuery();
    query.CodeText = typeWrapperCode;
    query.ObjectType = type.FullName;

    CompilerParameters cp = new CompilerParameters();
    cp.GenerateInMemory = true;
    cp.TreatWarningsAsErrors = false;
    foreach(Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
     if(asm.IsDynamic == false)
      cp.ReferencedAssemblies.Add(asm.Location);
    CompilerResults cr = cscp.CompileAssemblyFromSource(cp, typeWrapperCode);
    if(cr.Errors.Count > 0)
    {
     foreach(CompilerError err in cr.Errors)
      res.Value2.Add(String.Format("[{0},{1}] {2} {3}: {4}",
       err.Line, err.Column, err.IsWarning ? "Warning" : "Error", err.ErrorNumber, err.ErrorText));
    }
    if(cr.Errors.HasErrors)
     return res;

    MethodInfo mi = cr.CompiledAssembly.GetType(type.Name).GetMethod("DynamicMethod",
                                                                     BindingFlags.NonPublic | BindingFlags.Instance);
    MethodBody mb = mi.GetMethodBody();
    query.MaxStackSize = mb.MaxStackSize;
    query.Body = mb.GetILAsByteArray();
    query.Schema = Discover(query.Body, mi, type);

    if(mb.LocalVariables.Count > 0)
    {
     query.LocalVariables = new List<KeyValuePair<Type, bool>>(mb.LocalVariables.Count);
     foreach(LocalVariableInfo lvi in mb.LocalVariables)
      query.LocalVariables.Add(new KeyValuePair<Type, bool>(lvi.LocalType, lvi.IsPinned));
    }
    res.Value1 = query;

    return res;
   }
   finally
   {
    if(cscp != null)
     cscp.Dispose();
   }
  }

        public List<string> AnswerCheck(int id, string source)
        {
            string fileName = @"c:\Test\"+DateTime.Now.Ticks+".dll";

            Task task = new Task(id);

            //Configure compiler
            Dictionary<string, string> CompilerOptions = new Dictionary<string, string>
            {
                {"CompilerVersion", "v3.5" }
            };

            CSharpCodeProvider provider = new CSharpCodeProvider(CompilerOptions);

            CompilerParameters compileParam = new CompilerParameters
            {
                OutputAssembly = fileName,
                GenerateExecutable = false
            };

            CompilerResults result = provider.CompileAssemblyFromSource(compileParam, source);
            provider.Dispose();

            //check result of compile
            if (result.Errors.Count != 0)
            {
                List<string> list = new List<string>();
                foreach (CompilerError err in result.Errors)
                    list.Add(err.ToString());
                return list;
            }

            //Invoke user method
            Assembly assembly = result.CompiledAssembly;
            Type type = assembly.GetType("Task.User");
            if (type == null)
            {
                throw new Exception("Type not found!");
            }
            MethodInfo method = type.GetMethod(task.MethodName);
            if (method != null)
            {
                //Check answer
                int res = (int)method.Invoke(null, null);
                if (res == task.Answer)
                    return new List<string> { "true" };
                else
                    return new List<string> { "false" };
            }
            else
                throw new Exception("method not found!");
        }