C# CompilerErrorCollection.Add方法代码示例

        public override CompilerResults CompileAssemblyFromFile(CompilerParameters options, params string[] fileNames)
        {
            var units = new CodeCompileUnit[fileNames.Length];
            var errors = new CompilerErrorCollection();
            var syntax = new Parser(options);

            for (int i = 0; i < fileNames.Length; i++)
            {
                try
                {
                    units[i] = syntax.Parse(new StreamReader(fileNames[i]), fileNames[i]);
                }
            #if !DEBUG
                catch (ParseException e)
                {
                    errors.Add(new CompilerError(e.Source, e.Line, 0, e.Message.GetHashCode().ToString(), e.Message));
                }
                catch (Exception e)
                {
                    errors.Add(new CompilerError { ErrorText = e.Message });
                }
            #endif
                finally
                {
                }
            }

            var results = CompileAssemblyFromDom(options, units);
            results.Errors.AddRange(errors);

            return results;
        }

		private void HandleException(Exception ex, ProjectFile file, SingleFileCustomToolResult result)
		{
			if (ex is SpecFlowParserException)
			{
				SpecFlowParserException sfpex = (SpecFlowParserException) ex;
			                
				if (sfpex.ErrorDetails == null || sfpex.ErrorDetails.Count == 0)
				{
					result.UnhandledException = ex;
				}
				else
				{
					var compilerErrors = new CompilerErrorCollection();
					
					foreach (var errorDetail in sfpex.ErrorDetails)
					{
						var compilerError = new CompilerError(file.Name, errorDetail.ForcedLine, errorDetail.ForcedColumn, "0", errorDetail.Message);
						compilerErrors.Add(compilerError);
					}
							
					result.Errors.AddRange(compilerErrors);
				}
			}
			else
			{
				result.UnhandledException = ex;
			}
		}

            public override void Done(CompilerErrorCollection result)
            {
                if (!FileSystemHelper.FileCompare(TempFilePath, FilePath))
                {
                    string message = String.Format("Error during file generation. The target file '{0}' is read-only, but different from the transformation result. This problem can be a sign of an inconsistent source code package. Compile and check-in the current version of the file from the development environment or remove the read-only flag from the generation result. To compile a solution that contains messaging project on a build server, you can also exclude the messaging project from the build-server solution or set the <OverwriteReadOnlyFiles> msbuild project parameter to 'true' in the messaging project file.", 
                        Path.GetFullPath(FilePath));
                    result.Add(new CompilerError(String.Empty, 0, 0, null, message));
                }

                base.Done(result);
            }

        /// <summary>
        /// Creates an Assembly from DynamicAssembly definition
        /// </summary>
        /// <param name="assemblyDefinition">assembly description</param>
        /// <returns>result with assembly or error info</returns>
        public static CompileResult CompileDynamicAssembly(DynamicAssembly assemblyDefinition)
        {
            CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider("CSharp");
            CompilerParameters compilerParameters = new CompilerParameters();
            compilerParameters.CompilerOptions = "/t:library /platform:anycpu /lib:" + "\"" + 
                (String.IsNullOrWhiteSpace(assemblyDefinition.ReferencesPath) ? GetCurrentPath() : assemblyDefinition.ReferencesPath) + "\"";
            compilerParameters.IncludeDebugInformation = false;
            //compilerParameters.OutputAssembly = assemblyDefinition.Name;
            compilerParameters.GenerateInMemory = true;
            compilerParameters.GenerateExecutable = false;   
            
            foreach (var item in assemblyDefinition.References)
                compilerParameters.ReferencedAssemblies.Add(item);

            List<string> codeModules = new List<string>();
            foreach (DynamicClass item in assemblyDefinition.Classes)
            {
                string code = DynamicClass.Template;
                code = DynamicClass.AddUsingsToTemplate(item, code);
                code = DynamicClass.AddInterfacesToTemplate(item, code);
                code = DynamicClass.AddNamespaceToTemplate(String.IsNullOrWhiteSpace(item.Namespace) ? assemblyDefinition.Name : item.Namespace, code);
                code = DynamicClass.AddNameToTemplate(item, code);
                code = DynamicClass.AddPropertiesToTemplate(item, code);
                code = DynamicClass.AddMethodsToTemplate(item, code);
                codeModules.Add(code);
            }

            foreach (DynamicCustomClass item in assemblyDefinition.CustomClasses)
                codeModules.Add(item.Code);

            // we dont allow empty class definitions(fun fact: its okay for the c# compiler)
            foreach (DynamicCustomClass item in assemblyDefinition.CustomClasses)
            {
                if (String.IsNullOrWhiteSpace(item.Code))
                {
                    CompilerErrorCollection collection = new CompilerErrorCollection();
                    CompilerError customError = new CompilerError("CustomClass", 0, 0, "Custom", "Unable to compile an empty code module.");
                    collection.Add(customError);
                    return new CompileResult(codeModules.ToArray(), collection, null);
                }
            }

            CompilerResults compilerResults = codeDomProvider.CompileAssemblyFromSource(compilerParameters, codeModules.ToArray());
            codeDomProvider.Dispose();

            return new CompileResult(codeModules.ToArray(), compilerResults.Errors, compilerResults.Errors.Count > 0 ? null : compilerResults.CompiledAssembly);
        }

		public void Constructor0_Deny_Unrestricted ()
		{
			CompilerErrorCollection coll = new CompilerErrorCollection ();
			Assert.AreEqual (0, coll.Add (ce), "Add");
			Assert.AreSame (ce, coll[0], "this[int]");
			coll[0] = ce;
			coll.CopyTo (array, 0);
			coll.AddRange (array);
			coll.AddRange (coll);
			Assert.IsTrue (coll.Contains (ce), "Contains");
			Assert.AreEqual (0, coll.IndexOf (ce), "IndexOf");
			coll.Insert (0, ce);
			coll.Remove (ce);
			ce.IsWarning = false;
			Assert.IsTrue (coll.HasErrors, "HasErrors");
			Assert.IsFalse (coll.HasWarnings, "HasWarnings");
		}

		public string GenerateCode (out CompilerErrorCollection errors)
		{
			errors = new CompilerErrorCollection ();

			// Create the engine
			RazorTemplateEngine engine = new RazorTemplateEngine(this);

			// Generate code
			GeneratorResults results = null;
			try
			{
				Stream stream = File.OpenRead(_fullPath);
				using (var reader = new StreamReader(stream, Encoding.Default, detectEncodingFromByteOrderMarks: true))
				{
					results = engine.GenerateCode(reader, className: DefaultClassName, rootNamespace: DefaultNamespace, sourceFileName: _fullPath);
				}
			} catch (Exception e) {
				errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
				//Returning null signifies that generation has failed
				return null;
			}

			// Output errors
			foreach (RazorError error in results.ParserErrors) {
				errors.Add (new CompilerError (FullPath, error.Location.LineIndex + 1, error.Location.CharacterIndex + 1, null, error.Message));
			}

			try
			{
				using (StringWriter writer = new StringWriter()) {
					//Generate the code
					writer.WriteLine("#pragma warning disable 1591");
					_codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, _codeGeneratorOptions);
					writer.WriteLine("#pragma warning restore 1591");
					return writer.ToString();
				}
			} catch (Exception e) {
				errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
				//Returning null signifies that generation has failed
				return null;
			}
		}

		public string GenerateCode (out CompilerErrorCollection errors)
		{
			errors = new CompilerErrorCollection ();

			var engine = new RewritingRazorTemplateEngine (this, new PreprocessedAttributeRewriter ());

			// Generate code
			GeneratorResults results;
			try {
				Stream stream = File.OpenRead (FullPath);
				using (var reader = new StreamReader (stream, Encoding.Default, true)) {
					results = engine.GenerateCode (reader, DefaultClassName, DefaultNamespace, FullPath);
				}
			} catch (Exception e) {
				errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
				//Returning null signifies that generation has failed
				return null;
			}

			// Output errors
			foreach (RazorError error in results.ParserErrors) {
				errors.Add (new CompilerError (FullPath, error.Location.LineIndex + 1, error.Location.CharacterIndex + 1, null, error.Message));
			}

			try {
				using (var writer = new StringWriter ()) {
					writer.WriteLine ("#pragma warning disable 1591");
					_codeDomProvider.GenerateCodeFromCompileUnit (results.GeneratedCode, writer, codeGeneratorOptions);
					writer.WriteLine ("#pragma warning restore 1591");
					string s = writer.ToString ();
					return MakeLineDirectivePathsRelative (Path.GetDirectoryName (FullPath), s);
				}
			} catch (Exception e) {
				errors.Add (new CompilerError (FullPath, 1, 1, null, e.ToString ()));
				//Returning null signifies that generation has failed
				return null;
			}
		}

        public static void OnTransformationEnded(TextTransformation transformation)
        {
            try
            {
                if (transformation == null)
                {
                    throw new ArgumentNullException("transformation");
                }

                if (TransformationContext.transformation != null && !TransformationContext.Errors.HasErrors)
                {
                    //Update the files in the default AppDomain to avoid remoting errors on Database projects
                    //BindingFlags invokeInternalStaticMethod = BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.NonPublic;
                    //AppDomain defaultDomain = (AppDomain)typeof(AppDomain).InvokeMember("GetDefaultDomain", invokeInternalStaticMethod, null, null, null, CultureInfo.InvariantCulture);

                    //var bd1 = defaultDomain.BaseDirectory;

                    //var setup = new AppDomainSetup();
                    //setup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
                    //AppDomain serverAppDomain = AppDomain.CreateDomain("ServerAppDomain", null, setup);

                    //var udf = TransformationContext.outputManager;
                    //defaultDomain.DoCallBack(udf.UpdateFiles);

                    OutputProcessor.Host = Host;
                    outputManager.UpdateFiles();
                }

                TransformationContext.transformation = null;
                TransformationContext.outputManager = null;
                TransformationContext.project = null;
                TransformationContext.projectItem = null;
                TransformationContext.dte = null;

                if (TransformationContext.TransformationEnded != null)
                {
                    TransformationContext.TransformationEnded(null, EventArgs.Empty);
                }
            }
            catch (TransformationException e)
            {
                // Display expected errors in the Error List window without the call stack
                CompilerErrorCollection errors = new CompilerErrorCollection();
                CompilerError error = new CompilerError();
                error.ErrorText = e.Message;
                error.FileName = Host.TemplateFile;
                errors.Add(error);
                TransformationContext.Host.LogErrors(errors);
            }
            finally
            {
                DestroyTraceListener();
            }
        }

		public bool Run(string sourceCode, out CompilerErrorCollection compilationErrors)
		{
			bool compilationSucceeded = true;
			compilationErrors = new CompilerErrorCollection();
			CSharpCodeProvider provider = new CSharpCodeProvider();

			// Build the parameters for source compilation.
			CompilerParameters cp = new CompilerParameters();
			cp.TreatWarningsAsErrors = false;

			// Add assembly references.
			cp.ReferencedAssemblies.AddRange(DEFAULT_ASSEMBLIES);
			//cp.ReferencedAssemblies.AddRange(ReferencedAssemblies.ToArray());

			cp.GenerateInMemory = true;

			// Add using statements.
			StringBuilder script = new StringBuilder();
			foreach (var usingNamespace in DEFAULT_NAMESPACES)
				script.AppendFormat("using {0};\n", usingNamespace);

//			foreach (var additionalUsingNamespace in UsingNamespaces)
//				script.AppendFormat("using {0};\n", additionalUsingNamespace);

			// Create the script.
			script.AppendLine();
			script.AppendLine("namespace ScriptEngine");
			script.AppendLine("{");
			script.AppendLine("    public class Program");
			script.AppendLine("    {");
			script.AppendLine("        public void Run()");
			script.AppendLine("        {");
			script.AppendLine("            try");
			script.AppendLine("            {");
			script.AppendFormat("              {0}\n", sourceCode);
			script.AppendLine("            }");
			script.AppendLine("            catch (Exception e)");
			script.AppendLine("            {");
//			script.AppendLine("                Context.Error = _compilationException;");
			script.AppendLine("            }");
			script.AppendLine("        }");
			script.AppendLine("    }");
			script.AppendLine("}");

			// Invoke compilation.
			CompilerResults cr = provider.CompileAssemblyFromSource(cp, script.ToString());

			if (cr.Errors.Count > 0)
			{
				foreach (CompilerError ce in cr.Errors)
				{
					#if DEBUG
					Console.WriteLine("  {0}", ce.ToString());
					Console.WriteLine();
					#endif
					ce.Line = ce.Line - 13;
					compilationErrors.Add(ce);

					if (!ce.IsWarning)
						compilationSucceeded = false;
				}
			}

			if (compilationSucceeded)
			{
				var ass = cr.CompiledAssembly;
				var execInstance = ass.CreateInstance("ScriptEngine.Program");

				var type = execInstance.GetType();
				var methodInfo = type.GetMethod("Run");

				// Execute the code.
//				methodInfo.Invoke(execInstance, new object[] { context });
				methodInfo.Invoke(execInstance, new object[] {});
			}

			return compilationSucceeded;
		}

        public CompilerErrorCollection RunSource( string source, ref ScriptContext context )
        {
            bool compilationSucceeded = true;
            CompilerErrorCollection compilationErrors = new CompilerErrorCollection ( );
            CSharpCodeProvider provider = new CSharpCodeProvider ( );

            // Build the parameters for source compilation.
            CompilerParameters cp = new CompilerParameters ( );
            cp.TreatWarningsAsErrors = false;

            // Add assembly references.
            cp.ReferencedAssemblies.AddRange ( DEFAULT_ASSEMBLIES );
            cp.ReferencedAssemblies.AddRange ( ReferencedAssemblies.ToArray ( ) );

            cp.GenerateInMemory = true;

            // Add using statements.
            StringBuilder script = new StringBuilder ( );
            foreach ( var usingNamespace in DEFAULT_NAMESPACES )
                script.AppendFormat ( "using {0};\r\n", usingNamespace );

            foreach ( var additionalUsingNamespace in UsingNamespaces )
                script.AppendFormat ( "using {0};\r\n", additionalUsingNamespace );

            // Create the script.
            script.AppendLine ( );
            script.AppendLine ( "namespace BlizzetaZero.Kernel.Scripts" );
            script.AppendLine ( "{" );
            script.AppendFormat ( "\t{0}", source );
            script.AppendLine ( "}" );

            Console.WriteLine ( script.ToString ( ) );

            // Invoke compilation.
            CompilerResults cr = provider.CompileAssemblyFromSource ( cp, script.ToString ( ) );

            if ( cr.Errors.Count > 0 )
            {
                foreach ( CompilerError ce in cr.Errors )
                {
            #if DEBUG
                    Console.WriteLine ( "->\t{0}", ce.ToString ( ) );
                    Console.WriteLine ( );
            #endif
                    ce.Line = ce.Line - 13;
                    compilationErrors.Add ( ce );

                    if ( !ce.IsWarning )
                        compilationSucceeded = false;
                }
            }

            if ( compilationSucceeded )
            {
                var ass = cr.CompiledAssembly;
                var execInstance = ass.CreateInstance ( "BlizzetaZero.Kernel.Scripts.Script" );

                var type = execInstance.GetType ( );
                var methodInfo = type.GetMethod ( "Load" );

                // Execute the code.
                methodInfo.Invoke ( execInstance, new object[] { context } );
            }

            return compilationErrors;
        }