public Assembly CompileSource(params string[] references) { try { //CodeDomProvider cpd = new CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", "v4.0" } }); CodeDomProvider cpd = new CSharpCodeProvider(); ICodeGenerator codeGenerator = cpd.CreateGenerator(); StringBuilder generateCode = new StringBuilder(); StringWriter codeWriter = new StringWriter(generateCode); CodeGeneratorOptions options = new CodeGeneratorOptions { BracingStyle = "C" }; codeGenerator.GenerateCodeFromCompileUnit(TargetUnit, codeWriter, options); string thisCode = generateCode.ToString(); CompilerParameters cp = new CompilerParameters(); foreach (string refer in references) { cp.ReferencedAssemblies.Add(refer); } cp.GenerateExecutable = false; CompilerResults cr = cpd.CompileAssemblyFromSource(cp, thisCode); return(cr.CompiledAssembly); } catch (Exception e) { Console.WriteLine(e.Message); } return(null); }
static void CompileLocations(string outputFile) { CodeCompileUnit unit = new CodeCompileUnit(); CodeNamespace ns = new CodeNamespace("Desklet.Weather"); unit.Namespaces.Add(ns); ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); MainClass = new CodeTypeDeclaration("Locations"); MainClass.TypeAttributes = TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public; MainClass.IsPartial = true; ns.Types.Add(MainClass); CodeMemberMethod buildData = new CodeMemberMethod(); buildData.Name = "BuildData"; GenerateBuildData(buildData); MainClass.Members.Add(buildData); CodeDomProvider provider = new CSharpCodeProvider(); ICodeGenerator gen = provider.CreateGenerator(); TextWriter tw = new IndentedTextWriter(new StreamWriter(outputFile, false), "\t"); gen.GenerateCodeFromCompileUnit(unit, tw, new CodeGeneratorOptions()); tw.Close(); }
public CodeGenerationResult GenerateProjectCode(string file, string namespaceName, CodeDomProvider provider, GenerationOptions options, params Project[] projects) { ArrayList files = new ArrayList(); CodeGenerationResult res = GenerateProjectCode(options, projects); ICodeGenerator gen = provider.CreateGenerator(); string basePath = Path.GetDirectoryName(file); string ext = Path.GetExtension(file); foreach (SteticCompilationUnit unit in res.Units) { string fname; if (unit.Name.Length == 0) { fname = file; } else { fname = Path.Combine(basePath, unit.Name) + ext; } files.Add(fname); unit.Name = fname; StreamWriter fileStream = new StreamWriter(fname); try { gen.GenerateCodeFromCompileUnit(unit, fileStream, new CodeGeneratorOptions()); } finally { fileStream.Close(); } } return(res); }
public static string CreateCode( Type proxyType, ICodeGenerator generator, XmlRpcProxyCodeGenOptions options) { if (options == null) { throw new ArgumentNullException( "options", "The options parameter cannot be null"); } CodeCompileUnit ccu = CreateCodeCompileUnit(proxyType, generator, options); CodeGeneratorOptions cgo = new CodeGeneratorOptions(); cgo.BlankLinesBetweenMembers = true; cgo.BracingStyle = "C"; StringWriter sw = new StringWriter(CultureInfo.InvariantCulture); generator.GenerateCodeFromCompileUnit(ccu, sw, cgo); string ret = sw.ToString(); return(ret); }
static void Main(string[] args) { Console.WriteLine("What string do you want the custom program to display?"); string message = Console.ReadLine(); Console.WriteLine("How many times do you want the program to display this message?"); int nDisplays = int.Parse(Console.ReadLine()); CodeCompileUnit unit = GenerateProgram(message, nDisplays); // Set up options for source code style CodeGeneratorOptions opts = new CodeGeneratorOptions(); opts.BracingStyle = "C"; opts.IndentString = "\t"; // Create code generator and write code file CSharpCodeProvider cscp = new CSharpCodeProvider(); ICodeGenerator gen = cscp.CreateGenerator(); StreamWriter sw = new StreamWriter("MyCode.cs"); gen.GenerateCodeFromCompileUnit(unit, sw, opts); sw.Close(); CompilerParameters compilerParams = new CompilerParameters(); compilerParams.GenerateExecutable = true; compilerParams.OutputAssembly = "MyCode.exe"; ICodeCompiler compiler = cscp.CreateCompiler(); compiler.CompileAssemblyFromFile(compilerParams, "MyCode.cs"); }
public static void GenerateProjectCode(string file, CodeDomProvider provider, GenerationOptions options, ProjectBackend[] projects) { CodeGenerationResult res = GenerateProjectCode(options, projects); ICodeGenerator gen = provider.CreateGenerator(); string basePath = Path.GetDirectoryName(file); foreach (SteticCompilationUnit unit in res.Units) { string fname; if (unit.Name.Length == 0) { fname = file; } else { fname = Path.Combine(basePath, unit.Name); } StreamWriter fileStream = new StreamWriter(fname); try { gen.GenerateCodeFromCompileUnit(unit, fileStream, new CodeGeneratorOptions()); } finally { fileStream.Close(); } } }
public string Generate(ICodeGenerator codeGen) { StringWriter w = new StringWriter(); codeGen.GenerateCodeFromCompileUnit(this.compileUnit, w, null); return(w.ToString()); }
void GenerateCode(HttpContext context, string langId) { context.Response.ContentType = "text/plain; charset=utf-8"; CodeNamespace codeNamespace = new CodeNamespace(); CodeCompileUnit codeUnit = new CodeCompileUnit(); codeUnit.Namespaces.Add(codeNamespace); ServiceDescriptionImporter importer = new ServiceDescriptionImporter(); foreach (ServiceDescription sd in GetDescriptions()) { importer.AddServiceDescription(sd, null, null); } foreach (XmlSchema sc in GetSchemas()) { importer.Schemas.Add(sc); } importer.Import(codeNamespace, codeUnit); if (langId == null || langId == "") { langId = "cs"; } CodeDomProvider provider = GetProvider(langId); ICodeGenerator generator = provider.CreateGenerator(); CodeGeneratorOptions options = new CodeGeneratorOptions(); generator.GenerateCodeFromCompileUnit(codeUnit, context.Response.Output, options); }
// </Snippet2> private void OutputGraph() { // Create string writer to output to textbox StringWriter sw = new StringWriter(); // Create appropriate CodeProvider System.CodeDom.Compiler.CodeDomProvider cp; switch (language) { case 2: // VB cp = CodeDomProvider.CreateProvider("VisualBasic"); break; case 3: // JScript cp = CodeDomProvider.CreateProvider("JScript"); break; default: // CSharp cp = CodeDomProvider.CreateProvider("CSharp"); break; } // Create a code generator that will output to the string writer ICodeGenerator cg = cp.CreateGenerator(sw); // Generate code from the compile unit and outputs it to the string writer cg.GenerateCodeFromCompileUnit(cu, sw, new CodeGeneratorOptions()); // Output the contents of the string writer to the textbox this.textBox1.Text = sw.ToString(); }
public string Generate(ICodeGenerator codeGen) { StringWriter writer1 = new StringWriter(); codeGen.GenerateCodeFromCompileUnit(compileUnit, writer1, null); return(writer1.ToString()); }
/// <summary> /// 生成并输出类文件. /// </summary> /// <param name="codeClass">用于生成类的一些基本信息.</param> /// <param name="filePath">保存文到该文件.</param> /// <param name="overwrite">若源代码文件存在时是否覆盖.</param> public void WriteTo(string filePath, bool overwrite = false) { if (File.Exists(filePath)) { if (overwrite) { File.Delete(filePath); } else { return; } } using (StreamWriter codeWriter = new StreamWriter(File.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite))) { CSharpCodeProvider provider = new CSharpCodeProvider(); ICodeGenerator generator = provider.CreateGenerator(codeWriter); CodeGeneratorOptions options = new CodeGeneratorOptions { BlankLinesBetweenMembers = true, BracingStyle = "C" }; // 生成 using 引用 generator.GenerateCodeFromCompileUnit(new CodeSnippetCompileUnit(BuildCompileUnit()), codeWriter, options); // 将命名空间中的代码生成到文件. generator.GenerateCodeFromNamespace(codeNamespace, codeWriter, options); } if (ResetOnAfterWrite) { codeNamespace = null; } }
public static String GenerateFullClass(ICollection <String> references, ICollection <String> imports, String CodeNamespace, String className, string methodBody, String method = "Method") { CodeCompileUnit unit = new CodeCompileUnit(); if (references != null) { foreach (var item in references) { unit.ReferencedAssemblies.Add(item); } } CodeNamespace customEntityRoot = new CodeNamespace(CodeNamespace); //Create a namespace unit.Namespaces.Add(customEntityRoot); if (imports != null) { foreach (var item in imports) { customEntityRoot.Imports.Add(new CodeNamespaceImport(item)); } } CodeTypeDeclaration derived = new CodeTypeDeclaration(className); customEntityRoot.Types.Add(derived); CodeConstructor derivedClassConstructor = new CodeConstructor(); derivedClassConstructor.Attributes = MemberAttributes.Public; derived.Members.Add(derivedClassConstructor); CodeMemberMethod derivedMethod = new CodeMemberMethod(); derivedMethod.Attributes = MemberAttributes.Public; derivedMethod.Name = method; derivedMethod.ReturnType = new CodeTypeReference(typeof(void)); CodeSnippetStatement code = new CodeSnippetStatement(methodBody); derivedMethod.Statements.Add(code); derived.Members.Add(derivedMethod); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); ICodeGenerator codeGenerator = codeProvider.CreateGenerator(); StringBuilder generatedCode = new StringBuilder(); StringWriter codeWriter = new StringWriter(generatedCode); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; codeGenerator.GenerateCodeFromCompileUnit(unit, codeWriter, options); return(generatedCode.ToString()); }
public virtual void GenerateCodeFromCompileUnit(CodeCompileUnit compileUnit, TextWriter writer, CodeGeneratorOptions options) { ICodeGenerator cg = CreateGenerator(); if (cg == null) { throw GetNotImplemented(); } cg.GenerateCodeFromCompileUnit(compileUnit, writer, options); }
public String ToCode(CodeCompileUnit compileunit, CodeDomProvider provider, IDomainMap domainMap) { StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); IndentedTextWriter tw = new IndentedTextWriter(sw, " "); ICodeGenerator gen = provider.CreateGenerator(tw); gen.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions()); string code = sb.ToString(); if (domainMap != null) { foreach (ICodeMap codeMap in domainMap.CodeMaps) { if (provider is CSharpCodeProvider && codeMap.CodeLanguage == CodeLanguage.CSharp) { code = GetDomainCodeMap(domainMap, codeMap) + code; } else if (provider is VBCodeProvider && codeMap.CodeLanguage == CodeLanguage.VB) { code = GetDomainCodeMap(domainMap, codeMap) + code; } // if (provider is DelphiCodeProvider && codeMap.CodeLanguage == CodeLanguage.Delphi) // { // code = GetDomainCodeMap(code, classMap, codeMap) + code; // } } foreach (IClassMap classMap in domainMap.ClassMaps) { foreach (ICodeMap codeMap in classMap.CodeMaps) { if (provider is CSharpCodeProvider && codeMap.CodeLanguage == CodeLanguage.CSharp) { code = InsertCodeMap(code, classMap, codeMap); } else if (provider is VBCodeProvider && codeMap.CodeLanguage == CodeLanguage.VB) { code = InsertCodeMap(code, classMap, codeMap); } // if (provider is DelphiCodeProvider && codeMap.CodeLanguage == CodeLanguage.Delphi) // { // code = InsertCodeMap(code, classMap, codeMap); // } } } } return(code); }
private void writeCode(CodeDomProvider provider, StreamWriter sw) { //Create a code generator ICodeGenerator generator = provider.CreateGenerator(); //Default options are fine CodeGeneratorOptions options = new CodeGeneratorOptions(); //Build the code and display it generator.GenerateCodeFromCompileUnit(compileUnit, sw, options); sw.Flush(); }
public String GetCode() { CSharpCodeProvider codeProvider = new CSharpCodeProvider(); ICodeGenerator codeGenerator = codeProvider.CreateGenerator(); StringBuilder generatedCode = new StringBuilder(); StringWriter codeWriter = new StringWriter(generatedCode); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; codeGenerator.GenerateCodeFromCompileUnit(CodeCompileUnit, codeWriter, options); return(generatedCode.ToString()); }
protected void OptionallyWriteCodeToDisk(string codeOutputFilename, CodeCompileUnit codeCompileUnit, CSharpCodeProvider provider) { if (codeOutputFilename != "") { TextWriter writer = File.CreateText(Path.Combine(MyDirectory, codeOutputFilename)); ICodeGenerator codeGenerator = provider.CreateGenerator(writer); CodeGeneratorOptions options = GetCodeGeneratorOptions(); codeGenerator.GenerateCodeFromCompileUnit(codeCompileUnit, writer, options); writer.Close(); } }
public void GenerateDataset() { if (namesp == null) { namesp = ""; } if (uri == null) { uri = ""; } string targetFile = ""; DataSet dataset = new DataSet(); foreach (string fileName in schemaNames) { dataset.ReadXmlSchema(fileName); if (targetFile == "") { targetFile = Path.GetFileNameWithoutExtension(fileName); } else { targetFile += "_" + Path.GetFileNameWithoutExtension(fileName); } } targetFile += "." + provider.FileExtension; CodeCompileUnit cunit = new CodeCompileUnit(); CodeNamespace codeNamespace = new CodeNamespace(namesp); cunit.Namespaces.Add(codeNamespace); codeNamespace.Comments.Add(new CodeCommentStatement("\nThis source code was auto-generated by MonoXSD\n")); // Generate the code ICodeGenerator gen = provider.CreateGenerator(); TypedDataSetGenerator.Generate(dataset, codeNamespace, gen); string genFile = Path.Combine(outputDir, targetFile); StreamWriter sw = new StreamWriter(genFile, false); gen.GenerateCodeFromCompileUnit(cunit, sw, new CodeGeneratorOptions()); sw.Close(); Console.WriteLine("Written file " + genFile); }
protected override string CreateProxyFile(DotNetProject dotNetProject, FilePath basePath, string proxyNamespace, string referenceName) { // Setup the proxy namespace and compile unit ICodeGenerator codeGen = GetProvider(dotNetProject).CreateGenerator(); CodeNamespace codeNamespace = new CodeNamespace(proxyNamespace); CodeConstructor urlConstructor = new CodeConstructor(); CodeCompileUnit codeUnit = new CodeCompileUnit(); codeUnit.Namespaces.Add(codeNamespace); // Setup the importer and import the service description into the code unit ServiceDescriptionImporter importer = Library.ReadServiceDescriptionImporter(protocol); importer.Import(codeNamespace, codeUnit); // Add the new Constructor with Url as a paremeter // Search for the class which inherit SoapHttpClientProtocol (Which is the Service Class) foreach (CodeTypeDeclaration declarationType in codeUnit.Namespaces[0].Types) { if (declarationType.IsClass) { if (declarationType.BaseTypes.Count > 0) { // Is a Service Class if (declarationType.BaseTypes [0].BaseType.IndexOf("SoapHttpClientProtocol") > -1) { // Create new public constructor with the Url as parameter urlConstructor.Attributes = MemberAttributes.Public; urlConstructor.Parameters.Add(new CodeParameterDeclarationExpression("System.String", "url")); urlConstructor.Statements.Add(new CodeAssignStatement( new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Url"), new CodeVariableReferenceExpression("url"))); declarationType.Members.Add(urlConstructor); } } } } // Generate the code and save the file string fileSpec = Path.Combine(basePath, dotNetProject.LanguageBinding.GetFileName(referenceName)); StreamWriter writer = new StreamWriter(fileSpec); codeGen.GenerateCodeFromCompileUnit(codeUnit, writer, new CodeGeneratorOptions()); writer.Close(); return(fileSpec); }
public static string ToCode(CodeCompileUnit compileunit, CodeDomProvider provider) { StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); IndentedTextWriter tw = new IndentedTextWriter(sw, " "); ICodeGenerator gen = provider.CreateGenerator(tw); gen.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions()); string code = sb.ToString(); return(code); }
//根据CodeDOM产生程序代码,代码文件就是GenCodeHello.cs private string GenerateCode(CodeCompileUnit code) { CSharpCodeProvider cprovider = new CSharpCodeProvider(); //当然换个Microsoft.VisualBasic.VBCodeProvider就产生VB.NET的代码 ICodeGenerator gen = cprovider.CreateGenerator(); // 也可以直接用字符串来存储源代码 StringBuilder sb = new StringBuilder(); StringWriter strW = new StringWriter(sb); // 将源代码存储起来 gen.GenerateCodeFromCompileUnit(code, strW, new CodeGeneratorOptions()); return(sb.ToString()); }
private static void writeCode(CodeCompileUnit compileUnit) { //Create a code generator that can output VB source CodeDomProvider provider = new VBCodeProvider(); ICodeGenerator generator = provider.CreateGenerator(); //Default options are file CodeGeneratorOptions options = new CodeGeneratorOptions(); //Keep the output in memory StringWriter output = new StringWriter(); //Build the code and display it generator.GenerateCodeFromCompileUnit(compileUnit, output, options); Console.WriteLine("\nThe following VB source was generated\n\n"); Console.WriteLine(output.ToString()); }
public String ToCodeFile(CodeCompileUnit compileunit, CodeDomProvider provider, string fileName) { #if NET2 String sourceFile; if (provider.FileExtension[0] == '.') { sourceFile = fileName + provider.FileExtension; } else { sourceFile = fileName + "." + provider.FileExtension; } IndentedTextWriter tw = new IndentedTextWriter( new StreamWriter(sourceFile, false), " "); provider.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions()); tw.Close(); return(sourceFile); #else ICodeGenerator gen = provider.CreateGenerator(); String sourceFile; if (provider.FileExtension[0] == '.') { sourceFile = fileName + provider.FileExtension; } else { sourceFile = fileName + "." + provider.FileExtension; } IndentedTextWriter tw = new IndentedTextWriter( new StreamWriter(sourceFile, false), " "); gen.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions()); tw.Close(); return(sourceFile); #endif }
public string GeneratorCode() { CSharpCodeProvider codeProvider = new CSharpCodeProvider(); ICodeGenerator codeGenerator = codeProvider.CreateGenerator(); StringBuilder generatedCode = new StringBuilder(); using (StringWriter codeWriter = new StringWriter(generatedCode)) { CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C";//Keep the braces on the line following the statement or declaration that they are associated with codeGenerator.GenerateCodeFromCompileUnit(unit, codeWriter, options); } this._code = generatedCode.ToString(); return(_code); }
//////////////////////////////////Генерация//////////////////////////////////// private static void GENERATE_CODE_SERVER(CodeDomProvider provider, CodeCompileUnit compileunit) { String sourceFile; ///////////////Файл "TEST_CODEDOM.cs"////////////////////////////////////// sourceFile = "TEST_CODEDOM." + provider.FileExtension; /////////Получаем ICodeGenerator от CodeDomProvider//////////////////////// ICodeGenerator gen = provider.CreateGenerator(); ///Создаем IndentedTextWriter, построенный с StreamWriter исходного кода/// IndentedTextWriter tw = new IndentedTextWriter(new StreamWriter(sourceFile, false), " "); //////Генерируем исходный код, используя кодо-генератор//////////////////// gen.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions()); //////////////////Закрываем выходной файл////////////////////////////////// tw.Close(); }
public string Convert(XamlReader reader, CodeDomProvider cscProvider) { MainCodeClassName = string.Empty; StringBuilder sb = new StringBuilder(); StringWriter stringWriter = new StringWriter(sb); NamespacesToUse = new SortedDictionary <string, object>(); // TODO: XamlXmlReader can sometimes be null, if there is misformed XML in the first sections of XML _schemaContext = reader != null ? reader.SchemaContext : new XamlSchemaContext(); CodeDomDomWriter codeDomDomWriter = new CodeDomDomWriter(_schemaContext); // Load XAML into a specialized XAML DOM, for analysis and processing Debug.WriteLine("Building codeDOM from XAML..."); while (reader.Read()) { codeDomDomWriter.WriteNode(reader); } Debug.WriteLine("codeDOM complete."); CodeDomObjectNode objectNode = (CodeDomObjectNode)codeDomDomWriter.Result; //DumpNodeTree(objectNode); // Initialize CodeDom constructs ICodeGenerator cscg = cscProvider.CreateGenerator(stringWriter); ccu = new CodeCompileUnit(); CodeNamespace cns = new CodeNamespace(); ccu.Namespaces.Add(cns); // Go process XAML DOM CodeMemberMethod initMethod = CreateInitializeMethod(cns, objectNode); GenerateUsings(cns, objectNode); CreateClass(cns, objectNode, initMethod); AddPublicObjectMembers(); // Create code from codeDOM cscg.GenerateCodeFromCompileUnit(ccu, stringWriter, new CodeGeneratorOptions()); string returnText = sb.ToString(); return(returnText); }
static void Main() { Console.WriteLine("What string do you want the custom program to display?"); string message = Console.ReadLine(); Console.WriteLine("How many times do you want the program to display this message?"); int nDisplays = int.Parse(Console.ReadLine()); CodeCompileUnit unit = GenerateProgram(message, nDisplays); // Set up options for source code style CodeGeneratorOptions opts = new CodeGeneratorOptions(); opts.BracingStyle = "C"; opts.IndentString = "\t"; // Create code generators and write code files CodeDomProvider[] providers = new CodeDomProvider[3]; providers[0] = new CSharpCodeProvider(); providers[1] = new VBCodeProvider(); providers[2] = new JScriptCodeProvider(); // providers[3] = new VJSharpCodeProvider(); string[] fileNames = { "MyCodeCS.cs", "MyCodeVB.vb", "MyCodeJS.js" }; for (int i = 0; i < providers.Length; i++) { ICodeGenerator gen = providers[i].CreateGenerator(); StreamWriter sw = new StreamWriter(fileNames[i]); gen.GenerateCodeFromCompileUnit(unit, sw, opts); sw.Close(); } string[] assemblyFileNames = { "MyCodeCS.exe", "MyCodeVB.exe", "MyCodeJS.exe" }; CompilerParameters compilerParams = new CompilerParameters(); compilerParams.GenerateExecutable = true; for (int i = 0; i < providers.Length; i++) { ICodeCompiler compiler = providers[i].CreateCompiler(); compilerParams.OutputAssembly = assemblyFileNames[i]; compiler.CompileAssemblyFromFile(compilerParams, fileNames[i]); } }
/// <summary> /// Constructor for the XsdGen class. /// </summary> /// <param name="args">Command-line arguments passed to the program.</param> private XsdGen(string[] args) { this.ParseCommandlineArgs(args); // show usage information if (this.showHelp) { Console.WriteLine("usage: XsdGen.exe <schema>.xsd <outputFile> <namespace> [<commonNamespace>]"); return; } // ensure that the schema file exists if (!File.Exists(this.xsdFile)) { throw new ApplicationException(String.Format("Schema file does not exist: '{0}'.", this.xsdFile)); } XmlSchema document = null; using (StreamReader xsdFileReader = new StreamReader(this.xsdFile)) { document = XmlSchema.Read(xsdFileReader, new ValidationEventHandler(this.ValidationHandler)); } CodeCompileUnit codeCompileUnit = StronglyTypedClasses.Generate(document, this.outputNamespace, this.commonNamespace); using (CSharpCodeProvider codeProvider = new CSharpCodeProvider()) { ICodeGenerator generator = codeProvider.CreateGenerator(); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BlankLinesBetweenMembers = true; options.BracingStyle = "C"; options.IndentString = " "; using (StreamWriter csharpFileWriter = new StreamWriter(this.outFile)) { generator.GenerateCodeFromCompileUnit(codeCompileUnit, csharpFileWriter, options); } } }
/// /// <summary/> /// void WriteCodeUnit(CodeCompileUnit codeUnit, string serviceName) { CodeDomProvider provider = GetProvider(); ICodeGenerator generator = provider.CreateGenerator(); CodeGeneratorOptions options = new CodeGeneratorOptions(); string filename; if (outFilename != null) { filename = outFilename; } else { filename = serviceName + "." + provider.FileExtension; } Console.WriteLine("Writing file '{0}'", filename); StreamWriter writer = new StreamWriter(filename); generator.GenerateCodeFromCompileUnit(codeUnit, writer, options); writer.Close(); }
/// <summary> /// Generate the actual C# code. /// </summary> /// <param name="codeCompileUnit">The code DOM.</param> /// <param name="destClassFile">Destination C# source file.</param> public static void GenerateCSharpCode(CodeCompileUnit codeCompileUnit, string destClassFile) { // generate the code with the C# code provider CSharpCodeProvider provider = new CSharpCodeProvider(); // obtain an ICodeGenerator from the CodeDomProvider class ICodeGenerator gen = provider.CreateGenerator(); // create a TextWriter to a StreamWriter to the output file using (StreamWriter sw = new StreamWriter(destClassFile)) { using (IndentedTextWriter tw = new IndentedTextWriter(sw, " ")) { CodeGeneratorOptions options = new CodeGeneratorOptions(); // code generation options options.BlankLinesBetweenMembers = true; options.BracingStyle = "C"; // generate source code using the code generator gen.GenerateCodeFromCompileUnit(codeCompileUnit, tw, options); } } }
private void GenerateCode(ServiceDescriptionCollection sources, XmlSchemas schemas, string uriToWSDL, ICodeGenerator codeGen, string fileExtension) { proxyCode = " <ERROR> "; StringWriter writer1 = null; compileUnit = new CodeCompileUnit(); ServiceDescriptionImporter importer1 = new ServiceDescriptionImporter(); importer1.Schemas.Add(schemas); foreach (ServiceDescription description1 in sources) { importer1.AddServiceDescription(description1, "", ""); } importer1.Style = ServiceDescriptionImportStyle.Client; Protocol protocol1 = WsdlProperties.Protocol; importer1.ProtocolName = WsdlProperties.Protocol.ToString(); CodeNamespace namespace1 = new CodeNamespace(proxyNamespace); compileUnit.Namespaces.Add(namespace1); ServiceDescriptionImportWarnings warnings1 = importer1.Import(namespace1, compileUnit); try { try { writer1 = new StringWriter(); } catch { throw; } MemoryStream stream1 = null; if (schemas.Count > 0) { compileUnit.ReferencedAssemblies.Add("System.Data.dll"); foreach (XmlSchema schema1 in schemas) { string text1 = null; try { text1 = schema1.TargetNamespace; if (XmlSchemas.IsDataSet(schema1)) { if (stream1 == null) { stream1 = new MemoryStream(); } stream1.Position = 0; stream1.SetLength((long) 0); schema1.Write(stream1); stream1.Position = 0; DataSet set1 = new DataSet(); set1.ReadXmlSchema(stream1); TypedDataSetGenerator.Generate(set1, namespace1, codeGen); } continue; } catch { throw; } } } try { GenerateVersionComment(compileUnit.Namespaces[0]); ChangeBaseType(compileUnit); codeGen.GenerateCodeFromCompileUnit(compileUnit, writer1, null); } catch (Exception exception1) { if (writer1 != null) { writer1.Write("Exception in generating code"); writer1.Write(exception1.Message); } throw new InvalidOperationException("Error generating ", exception1); } } finally { proxyCode = writer1.ToString(); if (writer1 != null) { writer1.Close(); } } }
public string Generate(ICodeGenerator codeGen) { StringWriter writer1 = new StringWriter(); codeGen.GenerateCodeFromCompileUnit(compileUnit, writer1, null); return writer1.ToString(); }
void ImportSchemasAsClasses( string outputdir, ICodeGenerator codeGen, string fileExtension, IList fileNames, string ns, string uri, IList elements) { XmlSchemas schemasToCompile = new XmlSchemas(); XmlSchemas userSchemas = new XmlSchemas(); string outputSchemaName = ""; // Create parent schema XmlSchema parent = new XmlSchema(); foreach (string fileName in fileNames) { schemasToCompile.Add(ReadSchema(fileName, false)); userSchemas.Add(ReadSchema(fileName, true)); outputSchemaName += Path.ChangeExtension(fileName,"").Replace('.','_'); } Hashtable includeSchemas = new Hashtable(); foreach (XmlSchema schema in schemasToCompile) { CollectIncludes(schema, includeSchemas, false); } Compile(schemasToCompile); includeSchemas = new Hashtable(); foreach (XmlSchema schema in userSchemas) { CollectIncludes(schema, includeSchemas, true); } try { outputSchemaName = outputSchemaName.Substring(0, outputSchemaName.Length - 1); XmlSchemaImporter schemaImporter = new XmlSchemaImporter(userSchemas); CodeCompileUnit codeCompileUnit = new CodeCompileUnit(); CodeNamespace codeNamespace = new CodeNamespace(ns); codeCompileUnit.Namespaces.Add(codeNamespace); GenerateVersionComment(codeNamespace); XmlCodeExporter codeExporter = new XmlCodeExporter(codeNamespace, codeCompileUnit); AddImports(codeNamespace, GetNamespacesForTypes(new Type[] { typeof(XmlAttributeAttribute) })); for (int i = 0; i < userSchemas.Count; i++) { XmlSchema schema = userSchemas[i]; for (int j = 0; j < schema.Items.Count; j++) { object item = schema.Items[j]; if (item is XmlSchemaElement) { XmlSchemaElement element = (XmlSchemaElement)item; if (!element.IsAbstract) { if (uri.Length == 0 || schema.TargetNamespace == uri) { bool found; if (elements.Count == 0) { found = true; } else { found = false; foreach (string e in elements) { if (e == element.Name) { found = true; break; } } } if (found) { XmlTypeMapping xmlTypeMapping = schemaImporter.ImportTypeMapping(new XmlQualifiedName(element.Name, schema.TargetNamespace)); codeExporter.ExportTypeMapping(xmlTypeMapping); } } } } } } CodeTypeDeclarationCollection classes = codeNamespace.Types; if (classes == null || classes.Count == 0) { Console.WriteLine(Res.GetString(Res.NoClassesGenerated)); } else { TextWriter writer = CreateOutputWriter(outputdir, outputSchemaName, fileExtension); codeGen.GenerateCodeFromCompileUnit(codeCompileUnit, writer, null); writer.Close(); } } catch (Exception e) { throw new InvalidOperationException(Res.GetString(Res.ErrGenerateClassesForSchema, outputSchemaName), e); } }
private static void SaveCompileUnit(ICodeGenerator codegen, CodeCompileUnit cu, string fileName) { try { try { if (File.Exists(fileName)) { File.Delete(fileName); } } catch { } FileStream stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite); StreamWriter w = new StreamWriter(stream, new UTF8Encoding(false)); codegen.GenerateCodeFromCompileUnit(cu, w, null); w.Flush(); w.Close(); stream.Close(); GeneratedSources.Add(fileName); } catch (Exception) { } }
public static string CreateCode( Type proxyType, ICodeGenerator generator, XmlRpcProxyCodeGenOptions options) { if (options == null) { throw new ArgumentNullException( "options", "The options parameter cannot be null"); } CodeCompileUnit ccu = CreateCodeCompileUnit(proxyType, options); var cgo = new CodeGeneratorOptions(); cgo.BlankLinesBetweenMembers = true; cgo.BracingStyle = "C"; using (var sw = new StringWriter(CultureInfo.InvariantCulture)) { generator.GenerateCodeFromCompileUnit(ccu, sw, cgo); return sw.ToString(); } }
private void GenerateCode(ServiceDescriptionCollection sources, XmlSchemas schemas, string uriToWSDL, ICodeGenerator codeGen, string fileExtension) { this.proxyCode = " <ERROR> "; StringWriter w = null; this.compileUnit = new CodeCompileUnit(); ServiceDescriptionImporter importer = new ServiceDescriptionImporter(); importer.Schemas.Add(schemas); foreach (ServiceDescription description in sources) { importer.AddServiceDescription(description, "", ""); } importer.Style = ServiceDescriptionImportStyle.Client; Protocol protocol = this.WsdlProperties.Protocol; importer.ProtocolName = this.WsdlProperties.Protocol.ToString(); CodeNamespace namespace2 = new CodeNamespace(this.proxyNamespace); this.compileUnit.Namespaces.Add(namespace2); ServiceDescriptionImportWarnings warnings = importer.Import(namespace2, this.compileUnit); try { try { w = new StringWriter(); } catch { throw; } MemoryStream stream = null; if (schemas.Count > 0) { this.compileUnit.ReferencedAssemblies.Add("System.Data.dll"); foreach (XmlSchema schema in schemas) { string targetNamespace = null; try { targetNamespace = schema.TargetNamespace; if (XmlSchemas.IsDataSet(schema)) { if (stream == null) { stream = new MemoryStream(); } stream.Position = 0L; stream.SetLength(0L); schema.Write(stream); stream.Position = 0L; DataSet dataSet = new DataSet(); dataSet.ReadXmlSchema(stream); TypedDataSetGenerator.Generate(dataSet, namespace2, codeGen); } continue; } catch { throw; } } } try { GenerateVersionComment(this.compileUnit.Namespaces[0]); this.ChangeBaseType(this.compileUnit); codeGen.GenerateCodeFromCompileUnit(this.compileUnit, w, null); } catch (Exception exception) { if (w != null) { w.Write("Exception in generating code"); w.Write(exception.Message); } throw new InvalidOperationException("Error generating ", exception); } } finally { this.proxyCode = w.ToString(); if (w != null) { w.Close(); } } }
public string Generate(ICodeGenerator codeGen) { StringWriter w = new StringWriter(); codeGen.GenerateCodeFromCompileUnit(this.compileUnit, w, null); return w.ToString(); }