public MainForm()
        {
            //
            // The InitializeComponent() call is required for Windows Forms designer support.
            //
            InitializeComponent();

             CodeCompileUnit cu = GeneraCodigo();
             CodeDomProvider dp = CodeDomProvider.CreateProvider("CSharp");
             //Imprimir el código
             StringWriter sw = new StringWriter();
             System.CodeDom.Compiler.IndentedTextWriter itw = new IndentedTextWriter(sw);
             CodeGeneratorOptions go = new CodeGeneratorOptions();
             go.BlankLinesBetweenMembers = false;
             dp.GenerateCodeFromCompileUnit(cu,sw,go);
             this.tbFuenteGenerado.Text = sw.ToString();

             //Compilar desde dom
             CompilerParameters cp = new CompilerParameters(new string[]{},"borrame.dll");
             CompilerResults cr = dp.CompileAssemblyFromDom(cp,cu);
             tbErrores.Text = "";
             foreach(CompilerError ce in cr.Errors){
             	tbErrores.Text += String.Format("{0}){1} in {2} at line {3} column {4} isWarning{5}",ce.ErrorNumber,ce.ErrorText,ce.FileName,ce.Line,ce.Column,ce.IsWarning);
             }
        }

 public TypescriptSnippetTypeMember(
     CodeSnippetTypeMember member,
     CodeGeneratorOptions options)
 {
     _member = member;
     _options = options;
 }

        public void Build(DataStructure dataStructure, string rendererFilename = "")
        {
            if (string.IsNullOrEmpty(rendererFilename)) { rendererFilename = this.GetFilename(dataStructure); }

            var rendererType = new CodeTypeDeclaration(dataStructure.RendererName);
            rendererType.IsClass = true;
            rendererType.IsPartial = true;
            rendererType.BaseTypes.Add(typeof(Renderer));
            rendererType.Comments.Add(new CodeCommentStatement("<summary>", true));
            rendererType.Comments.Add(new CodeCommentStatement(string.Format("Renderer of {0}", dataStructure.TargetName), true));
            rendererType.Comments.Add(new CodeCommentStatement("</summary>", true));
            BuildCreate(rendererType, dataStructure);
            BuildConstructor(rendererType, dataStructure);
            BuildDoInitialize(rendererType, dataStructure);
            BuildDoRender(rendererType, dataStructure);

            var parserNamespace = new CodeNamespace("CSharpGL");
            parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Object).Namespace));
            parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Collections.Generic.List<int>).Namespace));
            parserNamespace.Types.Add(rendererType);

            //生成代码
            using (var stream = new StreamWriter(rendererFilename, false))
            {
                CSharpCodeProvider codeProvider = new CSharpCodeProvider();
                CodeGeneratorOptions opentions = new CodeGeneratorOptions();//代码生成选项
                opentions.BlankLinesBetweenMembers = true;
                opentions.BracingStyle = "C";
                opentions.ElseOnClosing = false;
                opentions.IndentString = "    ";
                opentions.VerbatimOrder = true;

                codeProvider.GenerateCodeFromNamespace(parserNamespace, stream, opentions);
            }
        }

		public void Deny_Unrestricted ()
		{
			VBCodeProvider vbprov = new VBCodeProvider ();
			Assert.AreEqual ("vb", vbprov.FileExtension, "FileExtension");
			Assert.AreEqual (LanguageOptions.CaseInsensitive, vbprov.LanguageOptions, "LanguageOptions");
			Assert.IsNotNull (vbprov.CreateCompiler (), "CreateCompiler");
			Assert.IsNotNull (vbprov.CreateGenerator (), "CreateGenerator");
			try {
				Assert.IsNotNull (vbprov.GetConverter (typeof (string)), "GetConverter");
			}
			catch (NotImplementedException) {
				// mono
			}
#if NET_2_0
			CodeTypeMember ctm = new CodeTypeMember ();
			StringWriter sw = new StringWriter ();
			CodeGeneratorOptions cgo = new CodeGeneratorOptions ();
			try {
				vbprov.GenerateCodeFromMember (ctm, sw, cgo);
			}
			catch (NotImplementedException) {
				// mono
			}
#endif
		}

        /// <summary>
        /// Writes the code to the disk according to the given options.
        /// </summary>
        private void WriteCodeFiles()
        {
            // Ensure the output directory exist in the file system.
            EnsureDirectoryExists(options.OutputLocation);

            // Create the CodeGenerationOptions instance.
            codeGenerationOptions = CodeWriter.CreateCodeGeneratorOptions();

            // Do we have to generate separate files?
            if (options.GenerateSeparateFiles)
            {
                // Write the code into separate files.
                WriteSeparateCodeFiles();
            }
            else
            {
                // Write the code into a singl file.
                WriteSingleCodeFile();
            }

            // Finally write the configuration file.
			if (configuration != null)
			{
				WriteConfigurationFile();				
			}
			WriteTextFiles();	
        }

		private void GenerateHelper()
		{
			using (GenParamsForm gpf = new GenParamsForm())
			{
				gpf.Namespace = _rootCategory.Name;
				if (gpf.ShowDialog(this) == DialogResult.OK)
				{
					CodeCompileUnit ccu = HelperGenerator.Generate(_rootCategory,
						gpf.Namespace, gpf.IsInternal);
					CSharpCodeProvider cscp = new CSharpCodeProvider();
					CodeGeneratorOptions cgo = new CodeGeneratorOptions();
					cgo.BracingStyle = "C";
					using (StreamWriter sw = new StreamWriter(
							Path.Combine(_directory, _rootCategory.TreeName + ".cs")))
						cscp.GenerateCodeFromCompileUnit(ccu, sw, cgo);
					if (gpf.ShowResult)
						using (ShowResultForm srf = new ShowResultForm())
						using (StringWriter strW = new StringWriter())
						{
							cscp.GenerateCodeFromCompileUnit(ccu, strW, cgo);
							srf.Result = strW.ToString();
							srf.ShowDialog(this);
						}
				}
			}
		}

        static void Main(string[] args)
        {
            // 输出所有支持生成代码的语言
            foreach (CompilerInfo ci in CodeDomProvider.GetAllCompilerInfo())
            {
                foreach (var language in ci.GetLanguages())
                {
                    Console.Write("{0}    ", language);
                }
                Console.WriteLine();
            }

            CodeNamespace prgNamespace = BuildProgram();
            var compilerOptions = new CodeGeneratorOptions()
            {
                IndentString = "  ",
                BracingStyle = "C",  // 花括号的风格
                BlankLinesBetweenMembers = false
            };
            var codeText = new StringBuilder();
            using (var codeWriter = new StringWriter(codeText))
            {
                CodeDomProvider.CreateProvider("c#").GenerateCodeFromNamespace(
                    prgNamespace, codeWriter, compilerOptions);
            }
            var script = codeText.ToString();
            Console.WriteLine(script);

            Console.Read();
        }

		public void CodeSnippetBlankLines ()
		{
			var opt = new CodeGeneratorOptions () {
				BlankLinesBetweenMembers = false,
				VerbatimOrder = false
			};

			var ccu = new CodeCompileUnit ();
			var ns = new CodeNamespace ("Foo");
			ccu.Namespaces.Add (ns);
			var t = new CodeTypeDeclaration ("Bar");
			ns.Types.Add (t);

			t.Members.Add (new CodeSnippetTypeMember ("#line hidden"));
			t.Members.Add (new CodeSnippetTypeMember ("#line hidden2"));
	
			t.Members.Add (new CodeMemberMethod () { Name = "Foo" });

			using (var sw = new StringWriter ()) {
				new CSharpCodeProvider ().GenerateCodeFromCompileUnit (ccu, sw, opt);
				var str = sw.ToString ();

				Assert.IsFalse (str.Contains ("hidden2private"), "#0");
				Assert.IsTrue (str.Contains( "#line hidden#line hidden2"), "#1");
			}
		}

        private void GenerateCS()
        {
            using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
            {
                CodeGeneratorOptions opts = new CodeGeneratorOptions();
                StringWriter sw = new StringWriter();
                provider.GenerateCodeFromMember(_method, sw, opts);
                StringReader sr = new StringReader(sw.GetStringBuilder().ToString());
                string line = sr.ReadLine();
                while (string.IsNullOrEmpty(line))
                    line = sr.ReadLine();
                int idx = line.IndexOf(" " + _method.Name + "(");
                idx = line.LastIndexOf(' ', idx - 1);

                if (_method.Statements.Count > 0)
                {
                    Text = "partial" + line.Remove(0, idx);
                    Text = sw.GetStringBuilder().Replace(line, Text).ToString();
                }
                else
                {
                    line = "partial" + line.Remove(0, idx);
                    idx = line.LastIndexOf(')');
                    Text = line.Remove(idx + 1) + ";" + Environment.NewLine;
                }
            }
        }

 /// <summary>
 /// Generate the actual code to the given writer.
 /// </summary>
 public void Generate(TextWriter writer)
 {
     var provider = CodeDomProvider.CreateProvider("CSharp");
     var options = new CodeGeneratorOptions { BracingStyle = "C" };
     provider.GenerateCodeFromCompileUnit(codeCompileUnit, writer, options);
     writer.Flush();
 }

        public void Build(DataStructure dataStructure, string modelFilename = "")
        {
            if (string.IsNullOrEmpty(modelFilename)) { modelFilename = this.GetFilename(dataStructure); }

            // public class DemoModel : IBufferable { }
            var modelType = new CodeTypeDeclaration(dataStructure.ModelName);
            modelType.IsClass = true;
            modelType.IsPartial = true;
            modelType.BaseTypes.Add(typeof(IBufferable));
            modelType.Comments.Add(new CodeCommentStatement("<summary>", true));
            modelType.Comments.Add(new CodeCommentStatement(string.Format("Model of {0}", dataStructure.TargetName), true));
            modelType.Comments.Add(new CodeCommentStatement("</summary>", true));
            BuildFields(modelType, dataStructure);
            BuildGetVertexAttributeBuffer(modelType, dataStructure);
            BuildGetIndex(modelType, dataStructure);

            var parserNamespace = new CodeNamespace("CSharpGL");
            parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Object).Namespace));
            parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Collections.Generic.List<int>).Namespace));
            parserNamespace.Types.Add(modelType);

            //生成代码
            using (var stream = new StreamWriter(modelFilename, false))
            {
                CSharpCodeProvider codeProvider = new CSharpCodeProvider();
                CodeGeneratorOptions opentions = new CodeGeneratorOptions();//代码生成选项
                opentions.BlankLinesBetweenMembers = true;
                opentions.BracingStyle = "C";
                opentions.ElseOnClosing = false;
                opentions.IndentString = "    ";
                opentions.VerbatimOrder = true;

                codeProvider.GenerateCodeFromNamespace(parserNamespace, stream, opentions);
            }
        }

		public void Nullify ()
		{
			CodeGeneratorOptions cgo = new CodeGeneratorOptions ();
			cgo.BlankLinesBetweenMembers = false;
			Assert.IsFalse (cgo.BlankLinesBetweenMembers, "BlankLinesBetweenMembers-1");
			cgo["BlankLinesBetweenMembers"] = null;
			Assert.IsTrue (cgo.BlankLinesBetweenMembers, "BlankLinesBetweenMembers-2");

			cgo.BracingStyle = "C";
			Assert.AreEqual ("C", cgo.BracingStyle, "BracingStyle-1");
			cgo["BracingStyle"] = null;
			Assert.AreEqual ("Block", cgo.BracingStyle, "BracingStyle-2");

			cgo.ElseOnClosing = true;
			Assert.IsTrue (cgo.ElseOnClosing, "ElseOnClosing-1");
			cgo["ElseOnClosing"] = null;
			Assert.IsFalse (cgo.ElseOnClosing, "ElseOnClosing-2");

			cgo.IndentString = "\t";
			Assert.AreEqual ("\t", cgo.IndentString, "IndentString-1");
			cgo["IndentString"] = null;
			Assert.AreEqual ("    ", cgo.IndentString, "IndentString-2");
			cgo.VerbatimOrder = true;
			Assert.IsTrue (cgo.VerbatimOrder, "VerbatimOrder-1");
			cgo["VerbatimOrder"] = null;
			Assert.IsFalse (cgo.VerbatimOrder, "VerbatimOrder-2");
		}

        public override void GenerateCodeFromStatement(CodeStatement statement, 
                                                       TextWriter writer, 
                                                       CodeGeneratorOptions options)
        {
            var codeExpressionStatement = statement as CodeExpressionStatement;
            if (codeExpressionStatement != null)
            {
                var methodInvokeExpression =
                    codeExpressionStatement.Expression as CodeMethodInvokeExpression;
                if (methodInvokeExpression != null)
                {
                    if (methodInvokeExpression.Method.MethodName == "Write"
                        && methodInvokeExpression.Parameters.Count == 1)
                    {
                        var parameter = methodInvokeExpression.Parameters[0] as CodeSnippetExpression;
                        if ((parameter != null) && (!string.IsNullOrEmpty(parameter.Value)))
                        {
                            // Appears to be a candidate for rewriting
                            string originalValue = parameter.Value;
                            var processor =
                                SnippetModifiers.OfType<ICodeSnippetTextModifier>()
                                    .FirstOrDefault(m => m.CanProcessString(originalValue));

                            if (processor != null)
                                originalValue = processor.ProcessString(originalValue);
                            parameter.Value =
                                "global::" + GetType().FullName + ".PreProcessObject(this, "
                                + originalValue + ")";
                        }
                    }
                }
            }

            base.GenerateCodeFromStatement(statement, writer, options);
        }

        public string CreateSpecs(out int specCount)
        {
            var files = FindSpecFiles().ToArray();
            specCount = files.Length;
            if (specCount < 1)
                return string.Empty;

            var compile = new CodeCompileUnit();

            var globalns = new CodeNamespace();
            globalns.Imports.Add(new CodeNamespaceImport("NUnit.Framework"));
            globalns.Imports.Add(new CodeNamespaceImport(config.MyNamespace));
            compile.Namespaces.Add(globalns);
            var specNamespace = new CodeNamespace(config.TargetNamespace + ".ChutzpahSpecs");
            compile.Namespaces.Add(specNamespace);

            foreach (var fileInfo in files)
            {
                AddSpec(specNamespace, fileInfo);
            }
            //specNamespace.Types.AddRange(files.Select(CreateSpec).ToArray());

            var provider = CreateProvider();
            var options = new CodeGeneratorOptions { BracingStyle = "C", BlankLinesBetweenMembers = false };
            var stringBuilder = new StringBuilder();
            using (var writer = new StringWriter(stringBuilder))
            {
                provider.GenerateCodeFromCompileUnit(compile, writer, options);
                writer.Flush();
                writer.Close();
            }
            var result = stringBuilder.ToString();
            return result;
        }

 public GeneratorResults ParseToCode(string TemplateCode, string defaultnamespace, string defaultclassname, string baseClassFullName)
 {
     GeneratorResults razorResults;
     var host = new RazorEngineHost(new CSharpRazorCodeLanguage());
     host.DefaultBaseClass = baseClassFullName;//typeof(BulaqTemplateForRazorBase).FullName;
     host.DefaultNamespace = defaultnamespace;
     host.DefaultClassName = defaultclassname;
     host.NamespaceImports.Add("System");
     host.NamespaceImports.Add("BulaqCMS.Models");
     host.GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral");
     var engine = new RazorTemplateEngine(host);
     using (var reader = new StringReader(TemplateCode))
     {
         razorResults = engine.GenerateCode(reader);
         CSharpCodeProvider codeProvider = new CSharpCodeProvider();
         CodeGeneratorOptions options = new CodeGeneratorOptions();
         options.BracingStyle = "C";
         using (StringWriter writer = new StringWriter())
         {
             IndentedTextWriter indentwriter = new IndentedTextWriter(writer, "    ");
             codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, indentwriter, options);
             indentwriter.Flush();
             indentwriter.Close();
             LastGeneratedCode = writer.GetStringBuilder().ToString();
             string codePath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\code.cs";
             File.WriteAllText(codePath, LastGeneratedCode, Encoding.UTF8);
         }
     }
     return razorResults;
 }

 /// <summary>
 /// Generates CSharp text from a compile unit and writes it to a text writer with the given options.
 /// </summary>
 /// <param name="compileUnit">The compile unit to generate text from.</param>
 /// <param name="writer">The text writer to write to.</param>
 /// <param name="options">The generation options.</param>
 public static void GenerateCSharpTo(this CodeCompileUnit compileUnit, TextWriter writer, CodeGeneratorOptions options)
 {
     using (var provider = new CSharpCodeProvider())
     {
         provider.GenerateCodeFromCompileUnit(compileUnit, writer, options);
     }
 }

        public static string CreatePublicApiForAssembly(Assembly assembly)
        {
            var publicApiBuilder = new StringBuilder();
            var cgo = new CodeGeneratorOptions
            {
                BracingStyle = "C",
                BlankLinesBetweenMembers = false
            };

            using (var provider = new CSharpCodeProvider())
            {
                var publicTypes = assembly.GetTypes()
                    .Where(t => t.IsPublic && t.Name != "GeneratedInternalTypeHelper") //GeneratedInternalTypeHelper seems to be a r# runner side effect
                    .OrderBy(t => t.FullName);
                foreach (var publicType in publicTypes)
                {
                    var writer = new StringWriter();
                    var genClass = CreateClassDeclaration(publicType);
                    foreach (var memberInfo in publicType.GetMembers().Where(m => !IsDotNetTypeMember(m)).OrderBy(m => m.Name))
                    {
                        AddMemberToClassDefinition(genClass, memberInfo);
                    }
                    provider.GenerateCodeFromType(genClass, writer, cgo);
                    var gennedClass = GenerateClassCode(writer);
                    publicApiBuilder.AppendLine(gennedClass);
                }
            }
            var publicApi = publicApiBuilder.ToString();
            return publicApi.Trim();
        }

        /// <summary>
        /// Generates code from the specified <paramref name="constructor"/>.
        /// </summary>
        /// <param name="constructor">Class constructor for which code needs to be generated.</param>
        /// <param name="type">Type declaration.</param>
        /// <param name="namespace">Namespace declaration.</param>
        /// <param name="options">Code generation options.</param>
        /// <remarks>
        /// This method is a workaround for <see cref="CodeDomProvider.GenerateCodeFromMember"/> 
        /// not generating constructors properly.
        /// </remarks>
        private void GenerateCodeFromConstructor(
            CodeConstructor constructor,
            CodeTypeDeclaration type,
            CodeNamespace @namespace,
            CodeGeneratorOptions options)
        {
            const string StartMarker = "___startMarker___";
            const string EndMarker = "___endMarker___";

            // Insert marker fields around the target constructor
            int indexOfMember = type.Members.IndexOf(constructor);
            type.Members.Insert(indexOfMember + 1, new CodeMemberField(typeof(int), EndMarker));
            type.Members.Insert(indexOfMember, new CodeMemberField(typeof(int), StartMarker));

            using (StringWriter buffer = new StringWriter(CultureInfo.InvariantCulture))
            {
                // Generate type declaration in verbatim order to preserve placement of marker fields
                options = options ?? new CodeGeneratorOptions();
                options.VerbatimOrder = true;
                this.LanguageProvider.GenerateCodeFromNamespace(@namespace, buffer, options);

                // Extract constructor code from the generated type code
                const string ConstructorCode = "constructor";
                Regex regex = new Regex(
                    @"^[^\r\n]*" + StartMarker + @"[^\n]*$" +
                    @"(?<" + ConstructorCode + @">.*)" +
                    @"^[^\r\n]*" + EndMarker + @"[^\n]*$",
                    RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
                string code = regex.Match(buffer.ToString()).Groups[ConstructorCode].Value;

                // Write constructor code to the output buffer
                this.ClassCode.Write(code);
            }
        }

		public void Write(TranslateAttribute attr, string pathName)
		{
			using (var writer = new StreamWriter(pathName, false))
			{
				var options = new CodeGeneratorOptions {
					BracingStyle = "C",
					IndentString = "\t",
				};

				var codeNamespace = new CodeNamespace(attr.SourceType.Namespace);

				codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
				codeNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));

				var declaration = DeclareType(attr.SourceType);
				codeNamespace.Types.Add(declaration);

				declaration.Members.Add(ConvertToTargetMethod(attr));
				declaration.Members.Add(ConvertToTargetsMethod(attr));
				declaration.Members.Add(UpdateTargetMethod(attr));
				declaration.Members.Add(ConvertToSourceMethod(attr));
				declaration.Members.Add(ConvertToSourcesMethod(attr));

				generator.GenerateCodeFromNamespace(codeNamespace, writer, options);

			}
		}

        public override SyntaxTree GetSyntaxTree(string sourcePath, Stream sourceStream)
        {
            try
            {
                var viewFullPath = sourcePath;
                var viewVirtualPath = GetRelativeUri(sourcePath, Compilation.CurrentDirectory.FullName);
                var viewConfig = WebConfigurationManager.OpenMappedWebConfiguration(_configMap, viewVirtualPath);
                var razorConfig = viewConfig.GetSectionGroup("system.web.webPages.razor") as RazorWebSectionGroup;
                var host = razorConfig == null
                    ? WebRazorHostFactory.CreateDefaultHost(viewVirtualPath, viewFullPath)
                    : WebRazorHostFactory.CreateHostFromConfig(razorConfig, viewVirtualPath, viewFullPath);

                using (var rdr = new StreamReader(sourceStream, Compilation.Encoding, detectEncodingFromByteOrderMarks: true))
                using (var provider = CodeDomProvider.CreateProvider("csharp"))
                using (var generatedStream = new MemoryStream())
                using (var generatedWriter = new StreamWriter(generatedStream, Compilation.Encoding))
                {
                    var engine = new RazorTemplateEngine(host);
                    var razorOut = engine.GenerateCode(rdr, null, null, viewFullPath);
                    var codeGenOptions = new CodeGeneratorOptions { VerbatimOrder = true, ElseOnClosing = false, BlankLinesBetweenMembers = false };
                    provider.GenerateCodeFromCompileUnit(razorOut.GeneratedCode, generatedWriter, codeGenOptions);

                    // rewind
                    generatedWriter.Flush();
                    generatedStream.Position = 0;

                    return base.GetSyntaxTree(sourcePath, generatedStream);
                }
            }
            catch (Exception ex)
            {
                Compilation.Diagnostics.Add(Diagnostic.Create(Compilation.ViewGenerationFailed, Compilation.AsLocation(sourcePath), ex.ToString()));
                return null;
            }
        }