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); } } } }
public override string CreateOutput() { RemoveComments = Generators.Any(p => !p.AlwaysRegenerate); Namespace = new CodeNamespace(NamespaceName); Unit = new CodeCompileUnit(); Unit.Namespaces.Add(Namespace); foreach (var codeGenerator in Generators.Where(p=>p.IsValid())) { // UnityEngine.Debug.Log(codeGenerator.GetType().Name + " is generating"); codeGenerator.Initialize(this); } var provider = new CSharpCodeProvider(); var sb = new StringBuilder(); var tw1 = new IndentedTextWriter(new StringWriter(sb), " "); provider.GenerateCodeFromCompileUnit(Unit, tw1, new CodeGeneratorOptions()); tw1.Close(); if (RemoveComments) { var removedLines = sb.ToString().Split(new string[] { Environment.NewLine }, StringSplitOptions.None).Skip(10).ToArray(); return string.Join(Environment.NewLine, removedLines); } return sb.ToString(); }
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; }
public void GenerateCode(State rootState, TextWriter output, string namespaceName, UsingList usings, string[] genericArguments) { _syntaxTypes.Clear(); var code = new CodeCompileUnit(); var ns = new CodeNamespace(namespaceName); code.Namespaces.Add(ns); ns.Imports.Add(new CodeNamespaceImport("System")); foreach (var u in usings) { ns.Imports.Add(new CodeNamespaceImport(u.Namespace)); } GenerateCode(t => ns.Types.Add(t), rootState, new HashSet<string>(), genericArguments); ns.Types.Add(new CodeTypeDeclaration(_syntaxEnd) { Attributes = MemberAttributes.Public, TypeAttributes = TypeAttributes.Interface | TypeAttributes.Public, IsPartial = true, }); var codeProvider = new CSharpCodeProvider(); codeProvider.GenerateCodeFromCompileUnit(code, output, new CodeGeneratorOptions { BracingStyle = "C", IndentString = "\t", }); }
internal static TemplateCompilationResult Compile(Type templateType, string templateBody, IEnumerable<string> namespaces, string tempDirectory) { LoadRuntimeBinder(); string className; var compileUnit = GetCodeCompileUnit(templateType, namespaces, templateBody, out className); string sourceCode; var codeProvider = new CSharpCodeProvider(); var builder = new StringBuilder(); using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture)) { codeProvider.GenerateCodeFromCompileUnit(compileUnit, writer, new CodeGeneratorOptions()); sourceCode = builder.ToString(); } var parameters = CreateComplilerParameters(tempDirectory); var compileResult = codeProvider.CompileAssemblyFromDom(parameters, compileUnit); if (compileResult.Errors != null && compileResult.Errors.Count > 0) throw new TemplateCompilationException(compileResult.Errors, sourceCode, templateBody); var fullClassName = TEMPLATES_NAMESPACE + "." + className; return new TemplateCompilationResult { Type = compileResult.CompiledAssembly.GetType(fullClassName), SourceCode = sourceCode }; }
public void Run() { var compileUnit = new CodeCompileUnit(); var myNamespace = new CodeNamespace("MyNamespace"); myNamespace.Imports.Add(new CodeNamespaceImport("System")); var myClass = new CodeTypeDeclaration("MyClass"); var start = new CodeEntryPointMethod(); var cs1 = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Hello World!")); compileUnit.Namespaces.Add(myNamespace); myNamespace.Types.Add(myClass); myClass.Members.Add(start); start.Statements.Add(cs1); var provider = new CSharpCodeProvider(); using (var sw = new StreamWriter("HelloWorld.cs", false)) { var tw = new IndentedTextWriter(sw, " "); provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions()); tw.Close(); } }
static void Main(string[] args) { CodeCompileUnit compileUnit = new CodeCompileUnit(); CodeNamespace myNamespace = new CodeNamespace("MyNamespace"); myNamespace.Imports.Add(new CodeNamespaceImport("System")); CodeTypeDeclaration myClass = new CodeTypeDeclaration("MyClass"); CodeEntryPointMethod start = new CodeEntryPointMethod(); CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Hello World")); compileUnit.Namespaces.Add(myNamespace); myNamespace.Types.Add(myClass); myClass.Members.Add(start); start.Statements.Add(cs1); CSharpCodeProvider provider = new CSharpCodeProvider(); using(StreamWriter sw = new StreamWriter("HelloWorld.cs", false)) { IndentedTextWriter tw = new IndentedTextWriter(sw, " "); provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions()); tw.Close(); } Console.WriteLine("HelloWorld.cs generated in .../bin/Debug or .../bin/Release project folders."); Console.Write("Press a key to exit"); Console.ReadKey(); }
/// <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 GenerateCSharpCode(CodeCompileUnit compileunit) { // Generate the code with the C# code provider. CSharpCodeProvider provider = new CSharpCodeProvider(); // Build the output file name. String sourceFile; if (provider.FileExtension[0] == '.') { sourceFile = "HelloWorld" + provider.FileExtension; } else { sourceFile = "HelloWorld." + provider.FileExtension; } // Create a TextWriter to a StreamWriter to the output file. IndentedTextWriter tw = new IndentedTextWriter( new StreamWriter(sourceFile, false), " "); // Generate source code using the code provider. provider.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions()); // Close the output file. tw.Close(); return sourceFile; }
/// <summary> /// This method Parses and compiles the source code into an Assembly and returns it /// </summary> /// <param name="baseClassType">The Type of the Base class the generated class descends from</param> /// <param name="namespaceOfGeneratedClass">The Namespace of the generated class</param> /// <param name="generatedClassName">The Class Name of the generated class</param> /// <param name="sourceCodeReader">A Text reader that is a warpper around the "Template" that is to be parsed and compiled</param> /// <returns>An instance of a generated assembly that contains the generated class</returns> public Assembly ParseAndCompileTemplate(Type baseClassType, string namespaceOfGeneratedClass, string generatedClassName, TextReader sourceCodeReader) { RazorTemplateEngine engine = InitializeRazorEngine(baseClassType, namespaceOfGeneratedClass, generatedClassName); GeneratorResults razorResults = engine.GenerateCode(sourceCodeReader); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); string generatedCode = null; using (StringWriter writer = new StringWriter()) { codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, writer, options); generatedCode = writer.GetStringBuilder().ToString(); } var outputAssemblyName = Path.GetTempPath() + Guid.NewGuid().ToString("N") + ".dll"; CompilerParameters compilerParameters = new CompilerParameters(new string[]{}, outputAssemblyName); compilerParameters.ReferencedAssemblies.Add("System.dll"); compilerParameters.ReferencedAssemblies.Add("System.Core.dll"); compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().CodeBase.Substring(8)); compilerParameters.GenerateInMemory = false; CompilerResults compilerResults = codeProvider.CompileAssemblyFromDom(compilerParameters, razorResults.GeneratedCode); if (compilerResults.Errors.Count > 0) { var compileErrors = new StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError compileError in compilerResults.Errors) compileErrors.Append(String.Format("Line: {0}\t Col: {1}\t Error: {2}\r\n", compileError.Line, compileError.Column, compileError.ErrorText)); throw new Exception(compileErrors.ToString() + generatedCode); } return compilerResults.CompiledAssembly; }
private async Task<CompilationResult> CompileCore(IFileInfo file) { var host = new MvcRazorHost(); var engine = new RazorTemplateEngine(host); GeneratorResults results; using (TextReader rdr = new StreamReader(file.CreateReadStream())) { results = engine.GenerateCode(rdr, '_' + Path.GetFileNameWithoutExtension(file.Name), "Asp", file.PhysicalPath ?? file.Name); } string generatedCode; using (var writer = new StringWriter()) using (var codeProvider = new CSharpCodeProvider()) { codeProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, new CodeGeneratorOptions()); generatedCode = writer.ToString(); } if (!results.Success) { return CompilationResult.Failed(generatedCode, results.ParserErrors.Select(e => new CompilationMessage(e.Message))); } Directory.CreateDirectory(_tempPath); string tempFile = Path.Combine(_tempPath, Path.GetRandomFileName() + ".cs"); File.WriteAllText(tempFile, generatedCode); _tempFileSystem.TryGetFileInfo(tempFile, out file); return await _baseCompilationService.Compile(file); }
private static string GenerateCodeFromRazorTemplate(WebPageRazorHost host, string virtualPath) { // Create Razor engine and use it to generate a CodeCompileUnit var engine = new RazorTemplateEngine(host); GeneratorResults results = null; VirtualFile file = HostingEnvironment.VirtualPathProvider.GetFile(virtualPath); using (var stream = file.Open()) { using (TextReader reader = new StreamReader(stream)) { results = engine.GenerateCode(reader, className: null, rootNamespace: null, sourceFileName: host.PhysicalPath); } } if (!results.Success) { throw CreateExceptionFromParserError(results.ParserErrors.Last(), virtualPath); } // Use CodeDom to generate source code from the CodeCompileUnit var codeDomProvider = new CSharpCodeProvider(); var srcFileWriter = new StringWriter(); codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, srcFileWriter, new CodeGeneratorOptions()); return srcFileWriter.ToString(); }
static void Main(string[] args) { Uri wsdlLocation = new Uri(Directory.GetCurrentDirectory() + "\\..\\..\\..\\OrderService.wsdl"); Console.WriteLine("Beginning schema import."); Console.WriteLine(); DiscoveryClientProtocol client = new DiscoveryClientProtocol(); client.AllowAutoRedirect = true; DiscoveryDocument doc = client.DiscoverAny(wsdlLocation.ToString()); client.ResolveAll(); WebReferenceCollection references = new WebReferenceCollection(); //add 1st web reference document WebReference wr = new WebReference(client.Documents, new CodeNamespace("Microsoft.Samples")); references.Add(wr); //add other web reference documents if needed CodeDomProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider(); CodeCompileUnit Ccu = new CodeCompileUnit(); Ccu.Namespaces.Add(wr.ProxyCode); try { //This is the new API call ServiceDescriptionImporter.GenerateWebReferences( references, codeProvider, Ccu, new WebReferenceOptions()); } catch (Exception ex) { //do exception handling Console.WriteLine("An exception occured during importation:\n {0}", ex.ToString()); } StreamWriter writer = new StreamWriter("OrderProxy.cs", false, new System.Text.UTF8Encoding(true)); codeProvider.GenerateCodeFromCompileUnit(Ccu, writer, new CodeGeneratorOptions()); writer.Close(); // importer.Import(new CodeNamespace("Microsoft.Samples"), compileUnit); Console.WriteLine(); Console.WriteLine("Schema import completed."); //reader.Close(); Console.WriteLine("Finished. Press any key to continue..."); Console.ReadLine(); System.Diagnostics.Process.Start("notepad", "OrderProxy.cs"); }
private static string DeclToString(CodeCompileUnit decl) { var provider = new CSharpCodeProvider(); var opts = new CodeGeneratorOptions { IndentString = " ", BracingStyle = "C" }; var writer = new StringWriter(); provider.GenerateCodeFromCompileUnit(decl, writer, opts); return writer.GetStringBuilder().ToString(); }
public string Generate(GenerationOptions options) { var compileUnit = this.GenerateUnit(options); var provider = new CSharpCodeProvider(); using (var sw = new StringWriter()) { provider.GenerateCodeFromCompileUnit(compileUnit, sw, new CodeGeneratorOptions {}); string codeText = sw.GetStringBuilder().ToString(); return SugarUp(codeText.Substring(codeText.IndexOf("using", System.StringComparison.Ordinal))); } }
public static void Main() { CSharpCodeProvider cs = new CSharpCodeProvider(); CodeGenerator cg = new CodeGenerator(); using (StreamWriter sw=new StreamWriter("HelloWorld.cs",false)) { IndentedTextWriter tw = new IndentedTextWriter(sw, " "); cs.GenerateCodeFromCompileUnit(cg.GetCompierUnit(), tw, new CodeGeneratorOptions()); tw.Close(); } }
private void GenerateFile() { CSharpCodeProvider provider = new CSharpCodeProvider(); using (StreamWriter sw = new StreamWriter("HelloWorld.cs", false)) { IndentedTextWriter tw = new IndentedTextWriter(sw, " "); provider.GenerateCodeFromCompileUnit(GenerateHelloWorldCode(), tw, new CodeGeneratorOptions()); tw.Close(); } }
public static string ToCSharp(this CodeCompileUnit unit) { using (var stream = new MemoryStream()) { var csharp = new CSharpCodeProvider(); var writer = new IndentedTextWriter(new StreamWriter(stream)); csharp.GenerateCodeFromCompileUnit(unit, writer, new CodeGeneratorOptions()); writer.Flush(); return stream.ReadToEnd(); } }
public void Parse() { string testScript = "alias test {\n echo -a Hallo $left($me, 1) $+ .\n }\nalias -l coolHu { echo -a private! }"; StringBuilder csharpCode = new StringBuilder(); TextReader reader = new StringReader(testScript); TextWriter writer = new StringWriter(csharpCode); Parser p = new Parser(); CodeCompileUnit result = p.Parse(reader); ICodeGenerator csharpGen = new CSharpCodeProvider().CreateGenerator(writer); csharpGen.GenerateCodeFromCompileUnit(result, writer, null); Console.WriteLine(csharpCode.ToString()); Console.Out.Flush(); }
static void Main(string[] args) { CodeCompileUnit ccu = HelloWorldCodeDOM(); CSharpCodeProvider provider = new CSharpCodeProvider(); using(StreamWriter sw = new StreamWriter("HelloWorld.cs", false)) { IndentedTextWriter tw = new IndentedTextWriter(sw, " "); provider.GenerateCodeFromCompileUnit(ccu, tw, new CodeGeneratorOptions()); tw.Close(); } }
private static string generateCSharpCode(CodeCompileUnit compileunit) { var provider = new CSharpCodeProvider(); var stream = new MemoryStream(); using (var sw = new StreamWriter(stream)) { var tw = new IndentedTextWriter(sw, " "); provider.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions()); sw.Flush(); stream.Position = 0; return new StreamReader(stream).ReadToEnd(); } }
/// <summary> /// Load a new engine instance and setup it up, parse template and generate code /// on a string form (only to get the source) /// </summary> /// <param name="template"></param> /// <returns></returns> public static string GenerateSourceCode(string template) { GeneratorResults razorResult = GenerateSourceCodeResult(template); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); string result = string.Empty; using (StringWriter sw = new StringWriter()) { codeProvider.GenerateCodeFromCompileUnit(razorResult.GeneratedCode, sw, new CodeGeneratorOptions()); result = sw.GetStringBuilder().ToString(); } return result; }
/// <summary> /// 创建类实体文件 /// </summary> /// <param name="table">数据表实体</param> /// <param name="codeEntParam">实体参数</param> public void CreateCodeFile(Table table, CodeEntityParameter codeEntParam) { string className = string.Empty; CodeDomHelper codeDomHelper = new CodeDomHelper(); className = GetClassName(table, codeEntParam); var codeCompileUnit = codeDomHelper.GetCodeCompileUnit(codeEntParam.NameSpace, className, string.IsNullOrWhiteSpace(table.Comment) ? table.Name : table.Comment); var codeTypeDeclaration = codeCompileUnit.Namespaces[0].Types[0]; foreach (var column in table.Columns) { codeTypeDeclaration.Members.Add(codeDomHelper.CreateAutoProperty(column.Type, column.Name, column.Comment)); } CodeDomProvider provider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; var stringBuilder = new StringBuilder(); using (provider) { var stringWriter = new StringWriter(stringBuilder); provider.GenerateCodeFromCompileUnit(codeCompileUnit, stringWriter, new CodeGeneratorOptions()); } string tmpPath = string.IsNullOrWhiteSpace(codeEntParam.Suffix) ? "Entity" : codeEntParam.Suffix; string path = codeEntParam.SavePath; if (! codeEntParam.SavePath.EndsWith(tmpPath)) { path = Path.Combine(codeEntParam.SavePath, tmpPath); } try { if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } string filePath = Path.Combine(path, className + ".cs"); File.WriteAllText(filePath, CleanupCode(stringBuilder.ToString()), Encoding.UTF8); } catch (IOException ioEx) { throw ioEx; } catch (Exception ex) { throw ex; } }
public void ShouldCreateCompleteCompileUnit() { var applicationPreferences = new ApplicationPreferences { NameSpace = "someNamespace", TableName = "someTableName" }; var codeGenerator = new CodeGenerator(applicationPreferences, new ColumnDetails()); CodeCompileUnit pkClass; var codeCompileUnit = codeGenerator.GetCompileUnit(out pkClass); var cSharpCodeProvider = new CSharpCodeProvider(); var stringBuilder = new StringBuilder(); cSharpCodeProvider.GenerateCodeFromCompileUnit(codeCompileUnit, new StringWriter(stringBuilder), new CodeGeneratorOptions()); Assert.IsTrue(stringBuilder.ToString().Contains("namespace someNamespace")); Assert.IsTrue(stringBuilder.ToString().Contains("public class someTableName")); Assert.IsTrue(stringBuilder.ToString().Contains("public someTableName()")); }
string GenerateCode(CodeCompileUnit compileUnit) { CSharpCodeProvider provider = new CSharpCodeProvider(); TextWriter stringWriter = new StringWriter(); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BlankLinesBetweenMembers = true; options.BracingStyle = "C"; options.ElseOnClosing = true; options.IndentString = "\t"; options.VerbatimOrder = true; provider.GenerateCodeFromCompileUnit(compileUnit, stringWriter, options); return stringWriter.ToString(); }
public static string CreatePublicApiForAssembly(AssemblyDefinition assembly, Func<TypeDefinition, bool> shouldIncludeType, bool shouldIncludeAssemblyAttributes) { var publicApiBuilder = new StringBuilder(); var cgo = new CodeGeneratorOptions { BracingStyle = "C", BlankLinesBetweenMembers = false, VerbatimOrder = false, IndentString = " " }; using (var provider = new CSharpCodeProvider()) { var compileUnit = new CodeCompileUnit(); if (shouldIncludeAssemblyAttributes && assembly.HasCustomAttributes) { PopulateCustomAttributes(assembly, compileUnit.AssemblyCustomAttributes); } var publicTypes = assembly.Modules.SelectMany(m => m.GetTypes()) .Where(t => !t.IsNested && ShouldIncludeType(t) && shouldIncludeType(t)) .OrderBy(t => t.FullName); foreach (var publicType in publicTypes) { var @namespace = compileUnit.Namespaces.Cast<CodeNamespace>() .FirstOrDefault(n => n.Name == publicType.Namespace); if (@namespace == null) { @namespace = new CodeNamespace(publicType.Namespace); compileUnit.Namespaces.Add(@namespace); } var typeDeclaration = CreateTypeDeclaration(publicType); @namespace.Types.Add(typeDeclaration); } using (var writer = new StringWriter()) { provider.GenerateCodeFromCompileUnit(compileUnit, writer, cgo); var typeDeclarationText = NormaliseGeneratedCode(writer); publicApiBuilder.AppendLine(typeDeclarationText); } } return NormaliseLineEndings(publicApiBuilder.ToString().Trim()); }
private string GetSourceFromCCU(CodeCompileUnit CCU) { CSharpCodeProvider cscp = new CSharpCodeProvider(); StringBuilder sb = new StringBuilder(); System.IO.StringWriter sw = new System.IO.StringWriter(sb); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; options.BlankLinesBetweenMembers = false; if (Generated) { cscp.GenerateCodeFromCompileUnit(CCU, sw, options); } else { cscp.GenerateCodeFromNamespace(CCU.Namespaces[0], sw, options); } return sb.ToString(); }
public static void GenerateCode(string xsdFilepath, string codeOutPath, string nameSpace) { FileStream stream = File.OpenRead(xsdFilepath); XmlSchema xsd = XmlSchema.Read(stream, ValidationCallbackOne); // Remove namespaceattribute from schema xsd.TargetNamespace = null; XmlSchemas xsds = new XmlSchemas { xsd }; XmlSchemaImporter imp = new XmlSchemaImporter(xsds); //imp.Extensions.Add(new CustomSchemaImporterExtension()); CodeNamespace ns = new CodeNamespace(nameSpace); XmlCodeExporter exp = new XmlCodeExporter(ns); foreach (XmlSchemaObject item in xsd.Items) { if (!(item is XmlSchemaElement)) continue; XmlSchemaElement xmlSchemaElement = (XmlSchemaElement)item; XmlQualifiedName xmlQualifiedName = new XmlQualifiedName(xmlSchemaElement.Name, xsd.TargetNamespace); XmlTypeMapping map = imp.ImportTypeMapping(xmlQualifiedName); exp.ExportTypeMapping(map); } // Remove all the attributes from each type in the CodeNamespace, except // System.Xml.Serialization.XmlTypeAttribute RemoveAttributes(ns); ToProperties(ns); CodeCompileUnit compileUnit = new CodeCompileUnit(); compileUnit.Namespaces.Add(ns); CSharpCodeProvider provider = new CSharpCodeProvider(); using (StreamWriter sw = new StreamWriter(codeOutPath, false)) { CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions(); provider.GenerateCodeFromCompileUnit(compileUnit, sw, codeGeneratorOptions); } }
static void Main (string[] args) { CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions (); codeGeneratorOptions.BlankLinesBetweenMembers = true; codeGeneratorOptions.BracingStyle = "C"; codeGeneratorOptions.ElseOnClosing = false; codeGeneratorOptions.IndentString = "\t"; // create the root of our compilation graph CodeCompileUnit ccu = new CodeCompileUnit (); // prepare the main namespace for the classes to generate CodeNamespace cn = new CodeNamespace ("MyNamespace"); cn.Imports.Add (new CodeNamespaceImport ("System")); cn.Imports.Add (new CodeNamespaceImport ("System.Collections.Generic")); cn.Imports.Add (new CodeNamespaceImport ("System.Data")); // now link our namespace to the root of the compilation unit ccu.Namespaces.Add (cn); // prepare a test class CodeTypeDeclaration testClass = new CodeTypeDeclaration ("MyClass"); testClass.IsClass = true; // prepare a field CodeMemberField field = new CodeMemberField (typeof (int?), "myField"); testClass.Members.Add (field); cn.Types.Add (testClass); // now prepare the writer CSharpCodeProvider provider = new CSharpCodeProvider (); StreamWriter sw = new StreamWriter ("test-generated.cs"); provider.GenerateCodeFromCompileUnit (ccu, sw, codeGeneratorOptions); sw.Close (); }
public Assembly BuildAssembly() { GetReferencedTypes().ForEach(AddAssemblyReference); CSharpCodeProvider provider = new CSharpCodeProvider(); ICodeCompiler compiler = provider.CreateCompiler(); CompilerResults results = compiler.CompileAssemblyFromDom(CompilerParameters, this); 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); } var buffer = new StringBuilder(); using(var writer = new StringWriter(buffer)) { using (var textWriter = new IndentedTextWriter(writer)) { provider.GenerateCodeFromCompileUnit(this, textWriter, new CodeGeneratorOptions()); textWriter.Close(); } } var source = new StringBuilder(); var lines = buffer.ToString().Split(new string[] {Environment.NewLine}, StringSplitOptions.None); for(int i = 0; i < lines.Length; i++) { source.AppendLine(i + lines[i]); } throw new Exception( errors.ToString() + Environment.NewLine + Environment.NewLine + "CODE:" + Environment.NewLine + source); } return results.CompiledAssembly; }
public static void Main(string[] args) { Console.WriteLine("Hello World!"); CSharpCodeProvider provider = new CSharpCodeProvider(); using (StreamWriter sw = new StreamWriter("HelloWorld.cs", false)) { IndentedTextWriter tw = new IndentedTextWriter(sw, " "); provider.GenerateCodeFromCompileUnit(GetCode(), tw, new CodeGeneratorOptions()); tw.Close(); } Func<int, int, int> addFunc = (x, y) => x + y; Console.WriteLine(addFunc(2, 3)); Console.Write("Press any key to continue . . . "); Console.ReadKey(true); }
static void ImportSchemas(XmlSchemaSet schemas) { Console.WriteLine("Now doing schema import."); // The following code demonstrates schema import with // a surrogate. The surrogate is used to indicate that // the Person class already exists and that there is no // need to generate a new class when importing the // PersonSurrogated data contract. If the surrogate // was not used, schema import would generate a // PersonSurrogated class, and the person field // of Employee would be imported as // PersonSurrogated and not Person. XsdDataContractImporter xsdimp = new XsdDataContractImporter(); xsdimp.Options = new ImportOptions(); xsdimp.Options.DataContractSurrogate = new LegacyPersonTypeSurrogate(); xsdimp.Import(schemas); // Write out the imported schema to a C-Sharp file. // The code contains data contract types. FileStream fs4 = new FileStream("sample.cs", FileMode.Create); try { StreamWriter tw = new StreamWriter(fs4); Microsoft.CSharp.CSharpCodeProvider cdp = new Microsoft.CSharp.CSharpCodeProvider(); cdp.GenerateCodeFromCompileUnit(xsdimp.CodeCompileUnit, tw, null); tw.Flush(); } finally { fs4.Dispose(); } Console.WriteLine("\t To see the results of schema export and import,"); Console.WriteLine(" see SAMPLE.XSD and SAMPLE.CS."); Console.WriteLine(" Press ENTER to terminate the sample."); Console.ReadLine(); }
public void SaveDesignerClass(string outdir, string className, string ns) { var designerCsPath = Path.Combine(outdir, $"{className}.Designer.cs"); string[] errors; var codeProvider = new Microsoft.CSharp.CSharpCodeProvider(); var data = _data.ToDictionary(d => d.Key, d => d.Value.Value); var code = StronglyTypedResourceBuilder.Create(data, className, ns, codeProvider, false, out errors); if (errors.Length > 0) { foreach (var error in errors) { Console.WriteLine(error); } } using (StreamWriter writer = new StreamWriter(designerCsPath, false, System.Text.Encoding.UTF8)) { codeProvider.GenerateCodeFromCompileUnit(code, writer, new CodeGeneratorOptions()); } }
public void Test() { //声明代码的部分 CodeCompileUnit compunit = new CodeCompileUnit(); CodeNamespace sample = new CodeNamespace("WorpClasses"); compunit.Namespaces.Add(sample); //引用命名空间 sample.Imports.Add(new CodeNamespaceImport("System")); //导入System命名空间 sample.Imports.Add(new CodeNamespaceImport("System.Linq")); //导入System.Linq命名空间 //在命名空间下添加一个类 CodeTypeDeclaration wrapProxyClass = new CodeTypeDeclaration("类名"); //wrapProxyClass.BaseTypes.Add(baseType);// 如果需要的话 在这里声明继承关系 (基类 , 接口) wrapProxyClass.CustomAttributes.Add(new CodeAttributeDeclaration("Serializable")); //添加一个Attribute到class上 sample.Types.Add(wrapProxyClass); //把这个类添加到命名空间 ,待会儿才会编译这个类 //为这个类添加一个无参构造函数 其实不添加也没事的, 只是做个demo而已 CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; wrapProxyClass.Members.Add(constructor); //为这个类添加一个方法 public override int 方法名(string str); CodeMemberMethod method = new CodeMemberMethod(); method.Name = "方法名"; method.Attributes = MemberAttributes.Override | MemberAttributes.Public; //声明方法是公开 并且override的 method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "str")); //这个方法添加一个输入参数 method.ReturnType = new CodeTypeReference(typeof(int)); //声明返回值的类型 method.Statements.Add(new CodeSnippetStatement(" return 1; ")); //方法体里面很简单 直接返回 一个1; Microsoft.CSharp.CSharpCodeProvider cprovider = new Microsoft.CSharp.CSharpCodeProvider(); StringBuilder fileContent = new StringBuilder(); using (StringWriter sw = new StringWriter(fileContent)) { cprovider.GenerateCodeFromCompileUnit(compunit, sw, new System.CodeDom.Compiler.CodeGeneratorOptions());//想把生成的代码保存为cs文件 } }
public static object GetDbInfo(System.Data.DataSet ds) { // Get a code provider object. System.CodeDom.Compiler.CodeDomProvider cdp = new Microsoft.CSharp.CSharpCodeProvider(); // Create the namespace and import the default "System" namespace. System.CodeDom.CodeNamespace nmspc = new System.CodeDom.CodeNamespace("DataExplorer"); nmspc.Imports.Add(new System.CodeDom.CodeNamespaceImport("System")); nmspc.Imports.Add(new System.CodeDom.CodeNamespaceImport("System.ComponentModel")); // Create a class object. System.CodeDom.CodeTypeDeclaration clsDbInfo = new System.CodeDom.CodeTypeDeclaration("DbInfo"); clsDbInfo.IsClass = true; nmspc.Types.Add(clsDbInfo); // Add fields to the class for each value returned. List <string> fldNms = new List <string>(); for (int i = 0; i < ds.Tables.Count; i++) { for (int j = 0; j < ds.Tables[i].Columns.Count; j++) { string fldNm = "_" + ds.Tables[i].Columns[j].ColumnName.ToLower(); if (!fldNms.Contains(fldNm)) { System.CodeDom.CodeMemberField fld = new System.CodeDom.CodeMemberField(typeof(System.String), fldNm); fld.Attributes = System.CodeDom.MemberAttributes.Public; clsDbInfo.Members.Add(fld); fldNms.Add(fldNm); } } } // Add properties for the class to access each field. List <string> propNms = new List <string>(); for (int i = 0; i < ds.Tables.Count; i++) { for (int j = 0; j < ds.Tables[i].Columns.Count; j++) { string fldNm = "_" + ds.Tables[i].Columns[j].ColumnName.ToLower(), propNm = ds.Tables[i].Columns[j].ColumnName; if (!propNms.Contains(propNm)) { System.CodeDom.CodeMemberProperty prop = new System.CodeDom.CodeMemberProperty(); prop.Attributes = System.CodeDom.MemberAttributes.Public; prop.Name = propNm; prop.Type = new System.CodeDom.CodeTypeReference(typeof(System.String)); System.CodeDom.CodeVariableReferenceExpression retExp = new System.CodeDom.CodeVariableReferenceExpression(fldNm); System.CodeDom.CodeMethodReturnStatement getReturn = new System.CodeDom.CodeMethodReturnStatement(retExp); prop.GetStatements.Add(getReturn); prop.HasGet = true; prop.HasSet = false; string catName = (ds.Tables[i].TableName.EndsWith("1")) ? "File Group" : "Database"; System.CodeDom.CodeAttributeDeclaration attrCat = new System.CodeDom.CodeAttributeDeclaration("Category", new System.CodeDom.CodeAttributeArgument(new System.CodeDom.CodePrimitiveExpression(catName))); prop.CustomAttributes.Add(attrCat); // Add the property to our class. clsDbInfo.Members.Add(prop); propNms.Add(propNm); } } } // Add a constructor to the class System.CodeDom.CodeConstructor clsDbInfoConstr = new System.CodeDom.CodeConstructor(); clsDbInfoConstr.Attributes = System.CodeDom.MemberAttributes.Public; clsDbInfo.Members.Add(clsDbInfoConstr); // Create a CompileUnit for this new type. System.CodeDom.CodeCompileUnit cu = new System.CodeDom.CodeCompileUnit(); cu.ReferencedAssemblies.Add("system.dll"); cu.Namespaces.Add(nmspc); // Now, we're ready to generate some code! #if DEBUG // If we're running in DEBUG mode, I want to see the generated code. using (System.IO.FileStream fs = new System.IO.FileStream("dbinfo.cs", System.IO.FileMode.Create, System.IO.FileAccess.Write)) using (System.IO.StreamWriter sr = new System.IO.StreamWriter(fs)) cdp.GenerateCodeFromCompileUnit(cu, sr, null); #endif System.CodeDom.Compiler.CompilerParameters cp = new System.CodeDom.Compiler.CompilerParameters(); cp.ReferencedAssemblies.Add("system.dll"); cp.GenerateExecutable = false; cp.IncludeDebugInformation = false; cp.GenerateInMemory = false; //cp.OutputAssembly = _outputName; System.CodeDom.Compiler.CompilerResults cr = cdp.CompileAssemblyFromDom(cp, cu); if (!cr.Errors.HasErrors) { System.Reflection.Assembly asm = cr.CompiledAssembly; object dbInfo = asm.CreateInstance("DataExplorer.DbInfo"); return(dbInfo); } else { return(null); } }