internal static bool CompileCode(CodeDomProvider provider, Assembly userAssembly, string[] generatedSrcFiles) { // Parameters for compilation String[] referenceAssemblies = { "System.dll", "System.ServiceModel.dll", "System.Configuration.dll", userAssembly.Location }; string compiledFile = "temp.dll"; CompilerParameters cp = new CompilerParameters(referenceAssemblies, compiledFile, false); cp.GenerateExecutable = false; Console.WriteLine("Compiling files: "); foreach (string fileName in generatedSrcFiles) { Console.WriteLine(fileName); } CompilerResults cr = provider.CompileAssemblyFromFile(cp, generatedSrcFiles); if (cr.Errors.Count > 0) { Console.WriteLine("Please investigate. The tool encountered errors during compilation"); foreach (CompilerError ce in cr.Errors) Console.WriteLine(ce.ToString()); return false; } else { Console.WriteLine("No errors encountered during compilation"); File.Delete(compiledFile); } return true; }
/// <summary> /// Compile a set of source files with a specific provider /// </summary> /// <param name="files">Array of source files</param> /// <param name="referencedAssemblies">Array of referenced assemblies</param> /// <param name="outputFilePath">Output assembly file path</param> /// <param name="provider">Code dom provider</param> /// <returns>Compiler results</returns> public static CompilerResults Compile(List<string> files, List<string> referencedAssemblies, List<string> embeddedResourcesFiles, string outputFilePath, CodeDomProvider provider) { // Configure parameters CompilerParameters parms = new CompilerParameters(); parms.GenerateExecutable = false; parms.GenerateInMemory = false; parms.OutputAssembly = outputFilePath; parms.IncludeDebugInformation = false; if (provider.Supports(GeneratorSupport.Resources)) parms.EmbeddedResources.AddRange(embeddedResourcesFiles.ToArray()); parms.ReferencedAssemblies.AddRange(referencedAssemblies.ToArray()); // Compile return provider.CompileAssemblyFromFile(parms, files.ToArray()); }
private static Type CreateCodeGeneratorType(System.CodeDom.Compiler.CodeDomProvider compilerProvider, string resourceName, string typeName) { string sourceCode = null; using (Stream sourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName)) using (StreamReader reader = new StreamReader(sourceStream)) { sourceCode = reader.ReadToEnd(); } CompilerParameters compilerParams = new CompilerParameters(); compilerParams.CompilerOptions = "/d:PREPROCESSED_TEMPLATE"; compilerParams.GenerateInMemory = true; compilerParams.GenerateExecutable = false; // grab the assemblies by location so that we don't compile against one that we didn't reference compilerParams.ReferencedAssemblies.AddRange(new string[] { typeof(System.CodeDom.Compiler.CodeDomProvider).Assembly.Location, // System.dll typeof(System.Linq.Enumerable).Assembly.Location, // System.Core.dll typeof(System.Data.Objects.ObjectContext).Assembly.Location, // System.Data.Entity.dll typeof(System.Data.Entity.Design.EntityCodeGenerator).Assembly.Location, // System.Data.Entity.Design.dll typeof(System.Data.DbType).Assembly.Location, // System.Data.dll typeof(System.Xml.XmlAttribute).Assembly.Location, // System.Xml.dll typeof(System.Xml.Linq.XElement).Assembly.Location, // System.Xml.Linq.dll }); #if !ENABLE_TEMPLATE_DEBUGGING CompilerResults results = compilerProvider.CompileAssemblyFromSource(compilerParams, sourceCode); #else // enables debugging compilerParams.GenerateInMemory = false; compilerParams.IncludeDebugInformation = true; string baseName = Path.GetFileNameWithoutExtension(Path.GetTempFileName()) + "."; compilerParams.OutputAssembly = Path.Combine(Path.GetTempPath(), baseName + typeName + ".Assembly.dll"); string sourceFileName = Path.Combine(Path.GetTempPath(), baseName + typeName + ".Source." + compilerProvider.FileExtension); File.WriteAllText(sourceFileName, sourceCode); CompilerResults results = compilerProvider.CompileAssemblyFromFile(compilerParams, sourceFileName); #warning DO NOT CHECK IN LIKE THIS, Dynamic Assembly Debugging is enabled #endif if (results.Errors.HasErrors) { string message = results.Errors.OfType <CompilerError>().Aggregate(string.Empty, (accumulated, input) => accumulated == string.Empty ? input.ToString() : accumulated + Environment.NewLine + input.ToString()); throw EDesignUtil.InvalidOperation(message); } return(results.CompiledAssembly.GetType(typeName)); }
private CompilerResults CompileAll(CodeDomProvider provider, List<string> sourceFile) { String lib = System.Configuration.ConfigurationManager.AppSettings["CSFolder"] + @"/CS4BBLib.dll"; if (!File.Exists(lib)) throw new ArgumentException("Unable to find '" + lib + "' Please make sure that the library exists. "); CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add("System.dll"); cp.ReferencedAssemblies.Add(lib); cp.TreatWarningsAsErrors = true; CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceFile.ToArray()); return cr; }
Assembly CompileFromSource(CodeDomProvider provider, string searchPattern) { var compilerParameters = new CompilerParameters(); compilerParameters.GenerateExecutable = false; // Necessary for stack trace line numbers etc compilerParameters.IncludeDebugInformation = true; compilerParameters.GenerateInMemory = false; #if RELEASE if(!compilationParameters.ForceDebugInformation) { compilerParameters.GenerateInMemory = true; compilerParameters.IncludeDebugInformation = false; } #endif if(!compilerParameters.GenerateInMemory) { var assemblyPath = Path.Combine(PathUtils.TempFolder, string.Format("CompiledScripts_{0}.dll", searchPattern.Replace("*.", ""))); if(File.Exists(assemblyPath)) { try { File.Delete(assemblyPath); } catch(Exception ex) { if(ex is UnauthorizedAccessException || ex is IOException) assemblyPath = Path.ChangeExtension(assemblyPath, "_" + Path.GetExtension(assemblyPath)); else throw; } } compilerParameters.OutputAssembly = assemblyPath; } var scripts = new List<string>(); var scriptsDirectory = PathUtils.ScriptsFolder; if(Directory.Exists(scriptsDirectory)) { foreach (var script in Directory.GetFiles(scriptsDirectory, searchPattern, SearchOption.AllDirectories)) scripts.Add(script); } else Debug.LogAlways("Scripts directory could not be located"); CompilerResults results; using(provider) { var referenceHandler = new AssemblyReferenceHandler(); compilerParameters.ReferencedAssemblies.AddRange(referenceHandler.GetRequiredAssembliesFromFiles(scripts)); results = provider.CompileAssemblyFromFile(compilerParameters, scripts.ToArray()); } return ScriptCompiler.ValidateCompilation(results); }
private static CompilerResults CompileLanguage(string[] sourceFiles, CodeDomProvider provider, CompilerParameters options) { options.EmbeddedResources.Clear(); options.LinkedResources.Clear(); int codeFileCount = 0; List<String> files = new List<String>(); foreach (string file in sourceFiles) { string ext = Path.GetExtension(file); if (String.Compare(ext, "." + provider.FileExtension, StringComparison.InvariantCultureIgnoreCase) == 0) { files.Add(file); codeFileCount++; } else if (ext.ToLowerInvariant() == ".resx") { options.EmbeddedResources.Add(file); } } if (codeFileCount > 0) { try { return provider.CompileAssemblyFromFile(options, files.ToArray()); } catch (Exception ex) { Trace.WriteLine("Unexpected error during compilation:\n" + ex.ToString(), "Runtime"); } } return null; }
/// <summary> /// Function to compile .Net C#/VB source codes at runtime /// Adapted from: /// (http://www.digitalcoding.com/Code-Snippets/C-Sharp/C-Code-Snippet-Compile-C-or-VB-source-code-run-time.html) /// </summary> /// <param name="codeProvider">Base class for compiler provider</param> /// <param name="sourceCode">C# or VB source code as a string</param> /// <param name="sourceFile">External file containing C# or VB source code</param> /// <param name="exeFile">File path to create external executable file</param> /// <param name="assemblyName">File path to create external assembly file</param> /// <param name="resourceFiles">Required resource files to compile the code</param> /// /// <param name="errors">String variable to store any errors occurred during the process</param> /// <returns>Return TRUE if successfully compiled the code, else return FALSE</returns> public static bool CompileCode(CodeDomProvider codeProvider, string sourceCode, string sourceFile, string exeFile, string assemblyName, string[] resourceFiles, string[] referencedAssemblies, out string errors, out CompilerResults compilerResults) { // Define parameters to invoke a compiler CompilerParameters compilerParameters = new CompilerParameters(); if (exeFile != null) { // Set the assembly file name to generate. compilerParameters.OutputAssembly = exeFile; // Generate an executable instead of a class library. compilerParameters.GenerateExecutable = true; compilerParameters.GenerateInMemory = false; } else if (assemblyName != null) { // Set the assembly file name to generate. compilerParameters.OutputAssembly = assemblyName; // Generate a class library instead of an executable. compilerParameters.GenerateExecutable = false; compilerParameters.GenerateInMemory = false; } else { // Generate an in-memory class library instead of an executable. compilerParameters.GenerateExecutable = false; compilerParameters.GenerateInMemory = true; } // Generate debug information. compilerParameters.IncludeDebugInformation = true; // Should start displaying warnings. compilerParameters.WarningLevel = 2; // Set whether to treat all warnings as errors. compilerParameters.TreatWarningsAsErrors = false; // Set compiler argument to optimize output. compilerParameters.CompilerOptions = "/optimize"; // Add referenced assemblies if (referencedAssemblies != null) compilerParameters.ReferencedAssemblies.AddRange(referencedAssemblies); // Set a temporary files collection. // The TempFileCollection stores the temporary files // generated during a build in the current directory, // and does not delete them after compilation. //compilerParameters.TempFiles = new TempFileCollection(".", true); compilerParameters.TempFiles = new TempFileCollection(".", false); if (resourceFiles != null && resourceFiles.Length > 0) { foreach (string _ResourceFile in resourceFiles) { // Set the embedded resource file of the assembly. compilerParameters.EmbeddedResources.Add(_ResourceFile); } } try { // Invoke compilation if (sourceFile != null && System.IO.File.Exists(sourceFile)) // source code in external file compilerResults = codeProvider.CompileAssemblyFromFile(compilerParameters, sourceFile); else // source code pass as a string compilerResults = codeProvider.CompileAssemblyFromSource(compilerParameters, sourceCode); if (compilerResults.Errors.Count > 0) { // Return compilation errors errors = ""; foreach (CompilerError compErr in compilerResults.Errors) { errors += "Line number " + compErr.Line + ", Column number " + compErr.Column + ", Error Number: " + compErr.ErrorNumber + ", '" + compErr.ErrorText + ";\r\n\r\n"; } // Return the results of compilation - Failed return false; } else { // no compile errors errors = null; } } catch (Exception exception) { // Error occurred when trying to compile the code errors = exception.Message; compilerResults = null; return false; } // Return the results of compilation - Success return true; }
public static bool CompileCode(CodeDomProvider provider, String[] sourceFile, String exeFile) { CompilerParameters cp = new CompilerParameters(); // Generate an executable instead of // a class library. cp.GenerateExecutable = true; // Set the assembly file name to generate. cp.OutputAssembly = exeFile; // Generate debug information. cp.IncludeDebugInformation = true; // Add an assembly reference. cp.ReferencedAssemblies.Add("Onyx.JS.api.dll"); // Save the assembly as a physical file. cp.GenerateInMemory = false; // Set the level at which the compiler // should start displaying warnings. cp.WarningLevel = 3; // Set whether to treat all warnings as errors. cp.TreatWarningsAsErrors = false; // Set compiler argument to optimize output. //cp.CompilerOptions = "/optimize"; // Set a temporary files collection. // The TempFileCollection stores the temporary files // generated during a build in the current directory, // and does not delete them after compilation. cp.TempFiles = new TempFileCollection(".", true); //if (provider.Supports(GeneratorSupport.EntryPointMethod)) //{ // // Specify the class that contains // // the main method of the executable. // cp.MainClass = "Samples.Class1"; //} if (Directory.Exists("Resources")) { if (provider.Supports(GeneratorSupport.Resources)) { // Set the embedded resource file of the assembly. // This is useful for culture-neutral resources, // or default (fallback) resources. cp.EmbeddedResources.Add("Resources\\Default.resources"); // Set the linked resource reference files of the assembly. // These resources are included in separate assembly files, // typically localized for a specific language and culture. cp.LinkedResources.Add("Resources\\nb-no.resources"); } } // Invoke compilation. CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceFile); if (cr.Errors.Count > 0) { // Display compilation errors. Console.WriteLine("Errors building {0} into {1}", sourceFile, cr.PathToAssembly); foreach (CompilerError ce in cr.Errors) { Console.WriteLine(" {0}", ce.ToString()); Console.WriteLine(); } } else { Console.WriteLine("Source {0} built into {1} successfully.", sourceFile, cr.PathToAssembly); Console.WriteLine("{0} temporary files created during the compilation.", cp.TempFiles.Count.ToString()); } // Return the results of compilation. if (cr.Errors.Count > 0) { return false; } else { return true; } }
protected Assembly CompileScript(string[] Source, CodeDomProvider Provider, IEnumerable<string> ReferencedAssemblies) { if (Source.Length == 0) { WriteInformation("ScriptCompiler", "No scripts to compile"); return null; } CompilerResults results; CompilerParameters parms = getCompilerParameters(ReferencedAssemblies); results = Provider.CompileAssemblyFromFile(parms, Source); int tempCount = 0; if (results.Errors.Count > 0) { foreach (CompilerError error in results.Errors) { if (error.IsWarning == false) { //throw new CompileException(string.Format("Error {0} on file {1} on line {2}", error.ErrorText, error.FileName, error.Line)) WriteError("ScriptCompiler", "Error {0} on file {1} on line {2}", error.ErrorText, error.FileName, error.Line); tempCount++; } else { WriteWarning("ScriptCompiler", "Error {0} on file {1} on line {2}", error.ErrorText, error.FileName, error.Line); } } if (tempCount > 0) return null; } else { WriteInformation("ScriptCompiler", "Scripts compiled no errors"); } return results.CompiledAssembly; }
private void Compile(bool file) { System.CodeDom.Compiler.CodeDomProvider CodeDomProvider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("CSharp"); System.CodeDom.Compiler.CompilerParameters CompilerParameters = new System.CodeDom.Compiler.CompilerParameters(); CompilerParameters.ReferencedAssemblies.Add("System.dll"); CompilerParameters.ReferencedAssemblies.Add("System.Data.dll"); CompilerParameters.ReferencedAssemblies.Add("System.Xml.dll"); CompilerParameters.ReferencedAssemblies.Add("System.Linq.dll"); CompilerParameters.ReferencedAssemblies.Add("RakNetSwig.dll"); CompilerParameters.ReferencedAssemblies.Add("GMP_Server.exe"); foreach (String str in Program.serverOptions.AdditionalLibs) { CompilerParameters.ReferencedAssemblies.Add(str); } CompilerParameters.CompilerOptions = "/t:library";///debug:full for (int i = 0; i < Program.serverOptions.AdditionalSymbols.Count; i++) { String str = Program.serverOptions.AdditionalSymbols[i]; if (i == 0) { CompilerParameters.CompilerOptions += "/define: "; } CompilerParameters.CompilerOptions += str; if (i != Program.serverOptions.AdditionalLibs.Count - 1) { CompilerParameters.CompilerOptions += ";"; } } CompilerParameters.IncludeDebugInformation = true; if (!file) { CompilerParameters.GenerateInMemory = true; } else { CompilerParameters.GenerateInMemory = false; CompilerParameters.OutputAssembly = "scripts/_compiled/ServerScripts.dll"; } List <String> fileList = new List <string>(); GetFileList(fileList, "scripts/server"); //getFileList(fileList, "scripts/both"); System.CodeDom.Compiler.CompilerResults CompilerResults = CodeDomProvider.CompileAssemblyFromFile(CompilerParameters, fileList.ToArray()); if (CompilerResults.Errors.Count > 0) { foreach (CompilerError col in CompilerResults.Errors) { Log.Logger.log(Log.Logger.LOG_ERROR, col.FileName + ":" + col.Line + " \t" + col.ErrorText); } return; } m_Assembly = CompilerResults.CompiledAssembly; }
private static Assembly CompileInternal(String outputAssembly, IEnumerable<String> references, CodeDomProvider provider, CompilerErrorCollection Errors, Template tmp) { var options = new CompilerParameters(); foreach (var str in references) { options.ReferencedAssemblies.Add(str); } options.WarningLevel = 4; CompilerResults results = null; if (Debug) { #region 调试状态,把生成的类文件和最终dll输出到XTemp目录下 var tempPath = XTrace.TempPath; //if (!String.IsNullOrEmpty(outputAssembly)) tempPath = Path.Combine(tempPath, Path.GetFileNameWithoutExtension(outputAssembly)); if (!String.IsNullOrEmpty(outputAssembly) && !outputAssembly.Equals(".dll")) tempPath = Path.Combine(tempPath, Path.GetFileNameWithoutExtension(outputAssembly)); if (!String.IsNullOrEmpty(tempPath) && !Directory.Exists(tempPath)) Directory.CreateDirectory(tempPath); var files = new List<String>(); foreach (var item in tmp.Templates) { if (item.Included) continue; String name = item.Name.EndsWith(".cs", StringComparison.OrdinalIgnoreCase) ? item.Name : item.ClassName; // 猜测后缀 Int32 p = name.LastIndexOf("_"); if (p > 0 && name.Length - p <= 5) name = name.Substring(0, p) + "." + name.Substring(p + 1, name.Length - p - 1); else if (!name.EndsWith(".cs", StringComparison.OrdinalIgnoreCase)) name += ".cs"; name = Path.Combine(tempPath, name); File.WriteAllText(name, item.Source, Encoding.UTF8); files.Add(name); } #endregion if (!String.IsNullOrEmpty(outputAssembly) && !outputAssembly.Equals(".dll")) { options.TempFiles = new TempFileCollection(tempPath, false); options.OutputAssembly = Path.Combine(tempPath, outputAssembly); options.GenerateInMemory = true; options.IncludeDebugInformation = true; } results = provider.CompileAssemblyFromFile(options, files.ToArray()); } else { List<String> sources = new List<String>(); foreach (var item in tmp.Templates) { sources.Add(item.Source); } options.GenerateInMemory = true; results = provider.CompileAssemblyFromSource(options, sources.ToArray()); } #region 编译错误处理 if (results.Errors.Count > 0) { Errors.AddRange(results.Errors); var sb = new StringBuilder(); CompilerError err = null; foreach (CompilerError error in results.Errors) { error.ErrorText = error.ErrorText; //if (String.IsNullOrEmpty(error.FileName)) error.FileName = inputFile; if (!error.IsWarning) { String msg = error.ToString(); if (sb.Length < 1) { String code = null; // 屏蔽因为计算错误行而导致的二次错误 try { code = tmp.FindBlockCode(error.FileName, error.Line); } catch { } if (code != null) { msg += Environment.NewLine; msg += code; } err = error; } else sb.AppendLine(); sb.Append(msg); } } if (sb.Length > 0) { TemplateException ex = new TemplateException(sb.ToString()); ex.Error = err; throw ex; } } else { try { options.TempFiles.Delete(); } catch { } } #endregion if (!results.Errors.HasErrors) { try { return results.CompiledAssembly; } catch { } } return null; }
/// <summary> /// Compiles a file to an assembly using specified compiler. /// </summary> Assembly Compile( PluginInfo pi, CodeDomProvider cdp ) { // Compile //ICodeCompiler compiler = cdp.CreateCompiler(); if(cdp is Microsoft.JScript.JScriptCodeProvider) // JSCript doesn't support unsafe code cp.CompilerOptions = ""; else cp.CompilerOptions = "/unsafe"; // Add references cp.ReferencedAssemblies.Clear(); foreach( string reference in m_worldWindReferencesList) cp.ReferencedAssemblies.Add(reference); // Add reference to core functions for VB.Net users if(cdp is Microsoft.VisualBasic.VBCodeProvider) cp.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll"); // Add references specified in the plugin foreach( string reference in pi.References.Split(',')) AddCompilerReference( pi.FullPath, reference.Trim() ); CompilerResults cr = cdp.CompileAssemblyFromFile( cp, pi.FullPath ); if(cr.Errors.HasErrors || cr.Errors.HasWarnings) { // Handle compiler errors StringBuilder error = new StringBuilder(); foreach (CompilerError err in cr.Errors) { string type = (err.IsWarning ? "Warning" : "Error"); if(error.Length>0) error.Append(Environment.NewLine); error.AppendFormat("{0} {1}: Line {2} Column {3}: {4}", type, err.ErrorNumber, err.Line, err.Column, err.ErrorText ); } Log.Write(Log.Levels.Error, LogCategory, error.ToString()); if(cr.Errors.HasErrors) throw new Exception( error.ToString() ); } // Success, return our new assembly return cr.CompiledAssembly; }
Assembly CompileFromSource(CodeDomProvider provider, string searchPattern) { var compilerParameters = new CompilerParameters(); compilerParameters.GenerateExecutable = false; // Necessary for stack trace line numbers etc compilerParameters.IncludeDebugInformation = true; compilerParameters.GenerateInMemory = false; #if RELEASE if(!compilationParameters.ForceDebugInformation) { compilerParameters.GenerateInMemory = true; compilerParameters.IncludeDebugInformation = false; } #endif if (!compilerParameters.GenerateInMemory) { var assemblyPath = Path.Combine(ProjectSettings.TempDirectory, string.Format("CompiledScripts_{0}.dll", searchPattern.Replace("*.", ""))); if (File.Exists(assemblyPath)) { try { File.Delete(assemblyPath); } catch (Exception ex) { if (ex is UnauthorizedAccessException || ex is IOException) { int num = 1; var split = assemblyPath.Split(new string[] { ".dll" }, StringSplitOptions.None); while (File.Exists(assemblyPath)) { assemblyPath = split.First() + num.ToString() + ".dll"; num++; } } else throw; } } compilerParameters.OutputAssembly = assemblyPath; } var scripts = new List<string>(); var scriptsDirectory = CryPak.ScriptsFolder; CVar cvar; if (CVar.TryGet("mono_scriptDirectory", out cvar)) { var alternateScriptsDir = cvar.String; if (!string.IsNullOrEmpty(alternateScriptsDir)) scriptsDirectory = alternateScriptsDir; } if (Directory.Exists(scriptsDirectory)) { foreach (var script in Directory.GetFiles(scriptsDirectory, searchPattern, SearchOption.AllDirectories)) scripts.Add(script); } else Debug.LogAlways("Scripts directory could not be located"); if (scripts.Count == 0) return null; CompilerResults results; using (provider) { var referenceHandler = new AssemblyReferenceHandler(); compilerParameters.ReferencedAssemblies.AddRange(referenceHandler.GetRequiredAssembliesFromFiles(scripts)); results = provider.CompileAssemblyFromFile(compilerParameters, scripts.ToArray()); } return ValidateCompilation(results); }
private string CompileModule( CodeDomProvider codeProvider, string targetDirectory, List<AspViewFile> files, ReferencedAssembly[] references, bool createAssembly, string[] modulesToAdd) { string prefix = string.IsNullOrEmpty(options.GeneratedAssemblyNamePrefix) ? null : options.GeneratedAssemblyNamePrefix + "."; if (!createAssembly) { parameters.CompilerOptions = "/t:module"; parameters.OutputAssembly = Path.Combine(targetDirectory, string.Format("{0}CompiledViews.{1}.netmodule", prefix, codeProvider.FileExtension)); } else parameters.OutputAssembly = Path.Combine(targetDirectory, prefix + "CompiledViews.dll"); List<ReferencedAssembly> actualReferences = new List<ReferencedAssembly>(); if (options.References != null) actualReferences.AddRange(options.References); if (references != null) actualReferences.AddRange(references); foreach (ReferencedAssembly reference in actualReferences) { string assemblyName = reference.Name; if (reference.Source == ReferencedAssembly.AssemblySource.BinDirectory) assemblyName = Path.Combine(targetDirectory, assemblyName); parameters.CompilerOptions += " /r:\"" + assemblyName + "\""; } if (modulesToAdd != null && modulesToAdd.Length > 0) { StringBuilder sb = new StringBuilder(); sb.Append(" /addmodule: "); foreach (string moduleToAdd in modulesToAdd) sb.Append(Path.Combine(targetDirectory, moduleToAdd)); parameters.CompilerOptions += "\"" + sb.ToString() + "\""; } CompilerResults results; if (options.KeepTemporarySourceFiles) { string targetTemporarySourceFilesDirectory = Path.Combine(targetDirectory, options.TemporarySourceFilesDirectory); List<string> fileNames = new List<string>(files.Count); foreach (AspViewFile file in files) fileNames.Add(Path.Combine(targetTemporarySourceFilesDirectory, file.FileName)); results = codeProvider.CompileAssemblyFromFile(parameters, fileNames.ToArray()); } else { List<string> sources = new List<string>(files.Count); foreach (AspViewFile file in files) sources.Add(file.ConcreteClass); results = codeProvider.CompileAssemblyFromSource(parameters, sources.ToArray()); } if (results.Errors.Count > 0) { StringBuilder message = new StringBuilder(); foreach (CompilerError err in results.Errors) message.AppendLine(err.ToString()); throw new Exception(string.Format( "Error while compiling'':\r\n{0}", message.ToString())); } return results.PathToAssembly; }
///<remarks>Brendan Ingram has greatly improved this method.</remarks> private static object LoadClass(CodeDomProvider codeProvider, string targetClassName, string source, bool sourceIsString) { CompilerParameters compilerParameters = new CompilerParameters(); compilerParameters.GenerateExecutable = false; compilerParameters.GenerateInMemory = Compilation.GenerateInMemoryAssembly; compilerParameters.IncludeDebugInformation = true; compilerParameters.TreatWarningsAsErrors = false; compilerParameters.CompilerOptions = compilerOptions; // Chuck Cross has vastly improved the loading of NxBRE DLL reference mechanism bool nxbreAssemblyLoaded = false; // Add all implicitly referenced assemblies if ((ReferenceLinkMode == ReferenceLinkModes.CurrentDomain) || (ReferenceLinkMode == ReferenceLinkModes.Full)) { foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) { // do not add AssemblyBuilders (bug 1482753), thanks to Bob Brumfield // handle .NET4 dynamic assemblies correctly, thanks to Nich if (!(assembly is AssemblyBuilder) && (assembly.ManifestModule.GetType().Namespace != "System.Reflection.Emit")) { AddReferencedAssembly(compilerParameters, assembly.Location); if(assembly.ManifestModule.ScopeName.Equals(NXBRE_DLL)) nxbreAssemblyLoaded = true; } } } // Add NxBRE DLL reference only if not already added through implicit references. if (!nxbreAssemblyLoaded && ((ReferenceLinkMode == ReferenceLinkModes.NxBRE) || (ReferenceLinkMode == ReferenceLinkModes.Full))) { AddReferencedAssembly(compilerParameters, NxBREAssemblyLocation); } // Add any extra DLL listed in the application configuration String extraReferences = Parameter.GetString("extraReferences"); if (extraReferences != null) { foreach(String dllToReference in extraReferences.Split(';')) { AddReferencedAssembly(compilerParameters, dllToReference); } } CompilerResults cr; if (sourceIsString) { cr = codeProvider.CompileAssemblyFromSource(compilerParameters, source); } else { cr = codeProvider.CompileAssemblyFromFile(compilerParameters, source); } if (cr.Errors.Count != 0) { throw new BREException(GetCompilerErrors(cr)); } // Marcin Kielar - zorba128 // Under some (strange?) conditions, compilation finishes without errors, // but assembly cannot be loaded: // - any of Assembly's methods (here - GetTypes) throws exception // - CreateInstance returns null try { cr.CompiledAssembly.GetTypes(); } catch(Exception e) { throw new BREException("Unable to create evaluator class instance - assembly loading problem", e); } object evaluatorInstance = cr.CompiledAssembly.CreateInstance(targetClassName); if(evaluatorInstance == null) { throw new BREException("Unable to create evaluator class instance"); } return evaluatorInstance; }
public static bool CompileCode(CodeDomProvider provider, String sourceFile,List<string> filesToEmbed, String exeFile) { CompilerParameters cp = new CompilerParameters(); // Generate an executable instead of // a class library. cp.GenerateExecutable = true; // Set the assembly file name to generate. cp.OutputAssembly = exeFile; // Generate debug information. cp.IncludeDebugInformation = true; // Add an assembly reference. cp.ReferencedAssemblies.Add("System.dll"); cp.ReferencedAssemblies.Add("System.Core.dll"); cp.ReferencedAssemblies.Add("mscorlib.dll"); cp.ReferencedAssemblies.Add("System.Drawing.dll"); cp.ReferencedAssemblies.Add("System.Windows.Forms.dll"); // Save the assembly as a physical file. cp.GenerateInMemory = false; // Set the level at which the compiler // should start displaying warnings. cp.WarningLevel = 3; // Set whether to treat all warnings as errors. cp.TreatWarningsAsErrors = false; // Set compiler argument to optimize output. cp.CompilerOptions = "/debug- /optimize+ /target:winexe";// "/optimize"; // Set a temporary files collection. // The TempFileCollection stores the temporary files // generated during a build in the current directory, // and does not delete them after compilation. cp.TempFiles = new TempFileCollection(".", true); if (provider.Supports(GeneratorSupport.EntryPointMethod)) { // Specify the class that contains // the main method of the executable. cp.MainClass = "skeleton.Program"; } //if (Directory.Exists("Resources")) //{ if (provider.Supports(GeneratorSupport.Resources)) { // Set the embedded resource file of the assembly. // This is useful for culture-neutral resources, // or default (fallback) resources. // cp.EmbeddedResources.Add(@"D:\PROJECTS\Tests\R_N_D\CompileCode\CompileCode\Extractor\CCD.resource"); cp.EmbeddedResources.AddRange(filesToEmbed.ToArray()); // cp.EmbeddedResources.Add("enc_1097421_JOHN_30-01-12_05-50-13.xml"); // Set the linked resource reference files of the assembly. // These resources are included in separate assembly files, // typically localized for a specific language and culture. // cp.LinkedResources.Add("Resources\\nb-no.resources"); } // } // Invoke compilation. CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceFile); if (cr.Errors.Count > 0) { // Display compilation errors. //Console.WriteLine("Errors building {0} into {1}", // sourceFile, cr.PathToAssembly); //foreach (CompilerError ce in cr.Errors) //{ // Console.WriteLine(" {0}", ce.ToString()); // Console.WriteLine(); //} } else { //Console.WriteLine("Source {0} built into {1} successfully.", // sourceFile, cr.PathToAssembly); //Console.WriteLine("{0} temporary files created during the compilation.", // cp.TempFiles.Count.ToString()); } // Return the results of compilation. if (cr.Errors.Count > 0) { return false; } else { return true; } }
/// <summary> /// Compiles the given source code file into an exe assembly or class library and saves it to the given file name. /// </summary> /// <param name="srcFile">A string value indicating the source file to compile from.</param> /// <param name="exeFile">A string value indicating the assembly to to create.</param> /// <param name="Provider">An object of type CodeDomProvider that can be used to compile the code.</param> /// <param name="createExe">A bool value indicating whether the CodeProvider should compile an exe file or class library.</param> /// <param name="includeDebugInfo">A bool value indicating whether or not to include debug information.</param> /// <returns>A CompilerResults object indicating the results of the compile operation.</returns> public static CompilerResults CompileCode(string[] srcFile, string exeFile, CodeDomProvider Provider, bool createExe, bool includeDebugInfo) { foreach (string file in srcFile) { if (!File.Exists(file)) throw new Exception("One or more source files could not be found."); } // Link the 'system.dll' file to the executable string[] refAsm ={ "System.dll" }; CompilerParameters cp = new CompilerParameters(refAsm, exeFile, false); // Tell the Compiler whether or not we're building an exe or class library. cp.GenerateExecutable = createExe; // Start the compiler. CompilerResults cr = Provider.CompileAssemblyFromFile(cp, srcFile); // Return the results of the compilation. return cr; }