public void CreateGenerator_ReturnsSame() { CSharpCodeProvider provider = new CSharpCodeProvider(); #pragma warning disable 0618 Assert.Same(provider.CreateGenerator(), provider.CreateGenerator()); #pragma warning restore 0618 }
public void Ctor_Default() { CSharpCodeProvider provider = new CSharpCodeProvider(); #pragma warning disable 0618 Assert.NotNull(provider.CreateGenerator()); Assert.Same(provider.CreateGenerator(), provider.CreateCompiler()); #pragma warning restore 0618 }
public void Ctor_IDictionaryStringString(IDictionary <string, string> providerOptions) { CSharpCodeProvider provider = new CSharpCodeProvider(providerOptions); #pragma warning disable 0618 Assert.NotNull(provider.CreateGenerator()); Assert.Same(provider.CreateGenerator(), provider.CreateCompiler()); #pragma warning restore 0618 }
private StringBuilder BuildClass(List <Guid> resGuidsToTake) { // need a string to put the code into var source = new StringBuilder(); var sw = new StringWriter(source); //Declare your provider and generator var codeProvider = new CSharpCodeProvider(); ICodeGenerator generator = codeProvider.CreateGenerator(sw); var codeOpts = new CodeGeneratorOptions(); var codeNamespace = new CodeNamespace("WebHookData.DataAccess.ExternalAPI"); codeNamespace.Imports.Add(new CodeNamespaceImport(nameof(System))); codeNamespace.Imports.Add(new CodeNamespaceImport("System.Linq")); //Build the class declaration and member variables var classDeclaration = new CodeTypeDeclaration { IsClass = true, Name = "ProjectOnlineAccessService", Attributes = MemberAttributes.Public, IsPartial = true }; CodeMemberMethod method = BuildMethod(resGuidsToTake); classDeclaration.Members.Add(method); //write code codeNamespace.Types.Add(classDeclaration); generator.GenerateCodeFromNamespace(codeNamespace, sw, codeOpts); // cleanup sw.Flush(); sw.Close(); return(source); }
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 void Deny_Unrestricted() { CSharpCodeProvider csprov = new CSharpCodeProvider(); Assert.AreEqual("cs", csprov.FileExtension, "FileExtension"); Assert.IsNotNull(csprov.CreateCompiler(), "CreateCompiler"); Assert.IsNotNull(csprov.CreateGenerator(), "CreateGenerator"); try { Assert.IsNotNull(csprov.GetConverter(typeof(string)), "GetConverter"); } catch (NotImplementedException) { // mono } #if NET_2_0 CodeTypeMember ctm = new CodeTypeMember(); StringWriter sw = new StringWriter(); CodeGeneratorOptions cgo = new CodeGeneratorOptions(); try { csprov.GenerateCodeFromMember(ctm, sw, cgo); } catch (NotImplementedException) { // mono } #endif }
private void UpdateCodeWindows() { TabControl tc = this.host.GetService(typeof(TabControl)) as TabControl; CodeGeneratorOptions o = new CodeGeneratorOptions(); o.BlankLinesBetweenMembers = true; o.BracingStyle = "C"; o.ElseOnClosing = false; o.IndentString = " "; StringWriter sw = new StringWriter(); CSharpCodeProvider cs = new CSharpCodeProvider(); cs.CreateGenerator().GenerateCodeFromCompileUnit(this.codeCompileUnit, sw, o); sw.Close(); sw = new StringWriter(); VBCodeProvider vb = new VBCodeProvider(); vb.CreateGenerator().GenerateCodeFromCompileUnit(this.codeCompileUnit, sw, o); sw.Close(); sw = new StringWriter(); XmlTextWriter xtw = new XmlTextWriter(sw); xtw.Formatting = Formatting.Indented; this.xmlDocument.WriteTo(xtw); string cleanup = sw.ToString().Replace("<DOCUMENT_ELEMENT>", "").Replace("</DOCUMENT_ELEMENT>", ""); sw.Close(); }
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 Interpreter() { this.varTable = new HashtableWithItemGetterHook(this); AddNamespace("System"); AddNamespace("System.Collections"); AddReference("System.dll"); // Also works on Mono SetValue("interpreter", this); SetValue("_", this); Utils.interpreter = this; string fullExecutablePath = FullExecutablePath(); if (File.Exists(fullExecutablePath)) { AddReference(fullExecutablePath); } string localNamespace = typeof(Interpreter).Namespace; if (!string.IsNullOrEmpty(localNamespace)) { AddNamespace(localNamespace); } prov = new CSharpCodeProvider(); using (StringWriter stringWriter = new StringWriter()) { gen = prov.CreateGenerator(stringWriter); } }
private string GenerateAssemblyInfo(string assemblyName) { var sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { var codeDomProvider = new CSharpCodeProvider(); var codeGenerator = codeDomProvider.CreateGenerator(sw); var compileUnit = new CodeCompileUnit(); var time = DateTime.Now; var build = string.Format("{0:yy}{1}", time, time.DayOfYear); var revision = string.Format("{0:HHmm}", time); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyTitleAttribute), assemblyName); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyDescriptionAttribute), ""); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyConfigurationAttribute), ""); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyCompanyAttribute), "NTREEV SOFT"); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyProductAttribute), assemblyName); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyCopyrightAttribute), $"Copyright © NTREEV SOFT {DateTime.Now.Year}"); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyTrademarkAttribute), ""); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyCultureAttribute), ""); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyVersionAttribute), $"{CremaSchema.MajorVersion}.{CremaSchema.MinorVersion}.0.0"); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyFileVersionAttribute), $"{CremaSchema.MajorVersion}.{CremaSchema.MinorVersion}.{build}.{revision}"); compileUnit.AssemblyCustomAttributes.Add(typeof(System.Reflection.AssemblyInformationalVersionAttribute), $"{CremaSchema.MajorVersion}.{CremaSchema.MinorVersion}.{build}.{revision}"); codeGenerator.GenerateCodeFromCompileUnit(compileUnit, sw, this.options); } return(sb.ToString()); }
public TypedDataSetGeneratorTest() { CodeDomProvider p = new CSharpCodeProvider(); gen = p.CreateGenerator(); compiler = p.CreateCompiler(); }
/// <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 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); }
/// <summary> /// Builds the class /// </summary> private void BuildClass() { // need a string to put the code into _source = new StringBuilder(); var sw = new StringWriter(_source); //Declare your provider and generator var codeProvider = new CSharpCodeProvider(); var generator = codeProvider.CreateGenerator(sw); var codeOpts = new CodeGeneratorOptions(); //Setup the namespace and imports var myNamespace = new CodeNamespace("IndiaTango"); myNamespace.Imports.Add(new CodeNamespaceImport("System")); myNamespace.Imports.Add(new CodeNamespaceImport("System.Linq")); myNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); myNamespace.Imports.Add(new CodeNamespaceImport("IndiaTango.Models")); //Build the class declaration and member variables var classDeclaration = new CodeTypeDeclaration { IsClass = true, Name = "Calculator", Attributes = MemberAttributes.Public }; //default constructor var defaultConstructor = new CodeConstructor { Attributes = MemberAttributes.Public }; defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true)); classDeclaration.Members.Add(defaultConstructor); //Our Calculate Method var myMethod = new CodeMemberMethod { Name = "ApplyFormula", ReturnType = new CodeTypeReference(typeof(KeyValuePair <Sensor, SensorState>)) }; myMethod.Comments.Add(new CodeCommentStatement("Apply a formula across a dataset", true)); myMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(List <SensorVariable>)), "sensorVariables")); myMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(SensorVariable)), "variableAssignedTo")); myMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(DateTime)), "startTime")); myMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(DateTime)), "endTime")); myMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(bool)), "skipMissingValues")); myMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(ChangeReason)), "reason")); myMethod.Attributes = MemberAttributes.Public; //Add the user specified code myMethod.Statements.Add(new CodeSnippetExpression(_loopCode)); myMethod.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("new KeyValuePair<Sensor,SensorState>(variableAssignedTo.Sensor,state)"))); classDeclaration.Members.Add(myMethod); //write code myNamespace.Types.Add(classDeclaration); generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts); sw.Flush(); sw.Close(); }
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 static void GenerateCode(CodeNamespace ns) { CodeDomProvider provider = new CSharpCodeProvider(); using (StreamWriter s = new StreamWriter("Auto.cs", false)) { provider.CreateGenerator().GenerateCodeFromNamespace(ns, s, new CodeGeneratorOptions()); } }
/// <summary> /// Main driving routine for building a class /// </summary> private string BuildClass() { this.m_expression = RefineEvaluationString(this.m_expression); this.m_expression = this.m_expression.Replace("SE", "se").Replace("Se", "se"); this.m_expression = ConvertToIf(this.m_expression).Replace("se", string.Empty); // need a string to put the code into StringBuilder source = new StringBuilder(); using (StringWriter sw = new StringWriter(source)) { //Declare your provider and generator CSharpCodeProvider codeProvider = new CSharpCodeProvider(); ICodeGenerator generator = codeProvider.CreateGenerator(sw); CodeGeneratorOptions codeOpts = new CodeGeneratorOptions(); CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator"); myNamespace.Imports.Add(new CodeNamespaceImport("System")); myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms")); //Build the class declaration and member variables CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration(); classDeclaration.IsClass = true; classDeclaration.Name = "Calculator"; classDeclaration.Attributes = MemberAttributes.Public; classDeclaration.Members.Add(FieldVariable("answer", typeof(double), MemberAttributes.Private)); //default constructor CodeConstructor defaultConstructor = new CodeConstructor(); defaultConstructor.Attributes = MemberAttributes.Public; defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true)); defaultConstructor.Statements.Add(new CodeSnippetStatement("//TODO: implement default constructor")); classDeclaration.Members.Add(defaultConstructor); //property classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(double))); //Our Calculate Method CodeMemberMethod myMethod = new CodeMemberMethod(); myMethod.Name = "Calculate"; myMethod.ReturnType = new CodeTypeReference(typeof(double)); myMethod.Comments.Add(new CodeCommentStatement("Calculate an expression", true)); myMethod.Attributes = MemberAttributes.Public; myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Answer"), new CodeSnippetExpression(this.m_expression))); myMethod.Statements.Add( new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Answer"))); classDeclaration.Members.Add(myMethod); //write code myNamespace.Types.Add(classDeclaration); generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts); sw.Flush(); sw.Close(); } return(source.ToString()); }
static void Main(string[] args) { // Prompt for target language. Console.Write("Do you want to generate C# or VB .NET code? "); syntaxTarget = Console.ReadLine(); // Get ICodeGenerator interface. switch (syntaxTarget.ToUpper()) { case "C#": case "CSharp": case "CS": syntaxTarget = "cs"; CSharpCodeProvider cdp = new CSharpCodeProvider(); itfCG = cdp.CreateGenerator(); itfCC = cdp.CreateCompiler(); break; case "VB .NET": case "VB.NET": case "VB": syntaxTarget = "vb"; VBCodeProvider vbdp = new VBCodeProvider(); itfCG = vbdp.CreateGenerator(); itfCC = vbdp.CreateCompiler(); break; default: Console.WriteLine("Sorry...can't do it..."); syntaxTarget = null; break; } // Only proceed if they picked a valid language // supported by System.CodeDOM. if (syntaxTarget != null) { // Now create the file and generate the code! TextWriter txtWriter = CreateFile(syntaxTarget); PopulateNamespace(itfCG, txtWriter); txtWriter.Close(); Console.WriteLine("Done!"); // Now compile the code into a .NET DLL. Console.WriteLine("Compiling code..."); CompileCode(itfCC, syntaxTarget); // Now launch the application! Console.Write("Enter your message: "); string msg = Console.ReadLine(); LoadAndRunAsm(msg); Console.WriteLine("Thanks for playing..."); } }
private void GenerateAssemblerSource() { CSharpCodeProvider csp = new CSharpCodeProvider(); CodeGeneratorOptions cop = new CodeGeneratorOptions(); cop.BracingStyle = "C"; StreamWriter sw = File.CreateText(m_context.AssemblerGenerationOptions.OutputFile); ICodeGenerator gen = csp.CreateGenerator(sw); gen.GenerateCodeFromNamespace(m_namespace, sw, cop); sw.Close(); }
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()); }
public static System.Reflection.Assembly CreateAssemblyFromDataTable(DataTable DataValues) { System.Random rnd = new Random(); if (DataValues.TableName == null || DataValues.TableName == "") { DataValues.TableName = rnd.Next().ToString(); } object result = null; CodeTypeDeclaration classDec = new CodeTypeDeclaration(DataValues.TableName); classDec.IsClass = true; CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; classDec.Members.Add(classDec); foreach (System.Data.DataColumn col in DataValues.Columns) { AddPropertyAndField(classDec, col.DataType, "", col.ColumnName); } AddPropertyAndField(classDec, null, "System.Collections.Generic.List<" + DataValues.TableName + ">", "ListOf" + DataValues.TableName); using (CSharpCodeProvider provider = new CSharpCodeProvider()) { ICodeGenerator generator = provider.CreateGenerator(); CodeNamespace ns = new CodeNamespace("Terminals.Generated"); ns.Types.Add((CodeTypeDeclaration)classDec); CodeGeneratorOptions options = new CodeGeneratorOptions(); //options.BlankLinesBetweenMembers = true; string filename = System.IO.Path.GetTempFileName(); using (System.IO.StreamWriter sw = new System.IO.StreamWriter(filename, false)) { generator.GenerateCodeFromNamespace(ns, sw, options); ICodeCompiler icc = provider.CreateCompiler(); CompilerParameters compileParams = new CompilerParameters(); compileParams.GenerateExecutable = false; compileParams.GenerateInMemory = true; return(icc.CompileAssemblyFromSource(compileParams, System.IO.File.ReadAllText(filename)).CompiledAssembly); } } return(null); }
static void Main(string[] args) { int namespaces = 10; int classesPerNamespace = 10; int methodsPerClass = 10; CodeCompileUnit codeCompileUnit = new CodeCompileUnit(); for (int i = 0; i < namespaces; ++i) { CodeNamespace codeNamespace = new CodeNamespace(); codeCompileUnit.Namespaces.Add(codeNamespace); codeNamespace.Name = "Namespace" + i; for (int j = 0; j < classesPerNamespace; ++j) { CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration(); codeNamespace.Types.Add(codeTypeDeclaration); codeTypeDeclaration.Name = "Class" + j; codeTypeDeclaration.TypeAttributes = TypeAttributes.Public; codeTypeDeclaration.Comments.Add( new CodeCommentStatement( "<summary>This is a summary.</summary>", true ) ); for (int k = 0; k < methodsPerClass; ++k) { CodeMemberMethod codeMemberMethod = new CodeMemberMethod(); codeTypeDeclaration.Members.Add(codeMemberMethod); codeMemberMethod.Name = "Method" + k; codeMemberMethod.Attributes = MemberAttributes.Public; codeMemberMethod.Comments.Add( new CodeCommentStatement( "<summary>This is a summary.</summary>", true ) ); } } } CodeDomProvider codeDomProvider = new CSharpCodeProvider(); ICodeGenerator codeGenerator = codeDomProvider.CreateGenerator(); CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions(); codeGenerator.GenerateCodeFromCompileUnit(codeCompileUnit, Console.Out, codeGeneratorOptions); }
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(); } }
//根据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()); }
/// <summary> /// Dynamic combile a assembely accord the wsdl content /// </summary> /// <param name="wsdlContent">Wsdl content In string</param> /// <returns>Assembly</returns> public Assembly AssemblyFromWsdl(string wsdlContent) { // Xml text reader StringReader wsdlStringReader = new StringReader(wsdlContent); XmlTextReader tr = new XmlTextReader(wsdlStringReader); ServiceDescription sd = ServiceDescription.Read(tr); tr.Close(); // WSDL service description importer CodeNamespace cns = new CodeNamespace(m_NameSpace); ServiceDescriptionImporter sdi = new ServiceDescriptionImporter(); sdi.AddServiceDescription(sd, null, null); sdi.ProtocolName = m_ProtocolName; sdi.Import(cns, null); // source code generation CSharpCodeProvider cscp = new CSharpCodeProvider(); ICodeGenerator icg = cscp.CreateGenerator(); StringBuilder srcStringBuilder = new StringBuilder(); StringWriter sw = new StringWriter(srcStringBuilder); icg.GenerateCodeFromNamespace(cns, sw, null); m_SourceProxy = srcStringBuilder.ToString(); sw.Close(); // assembly compilation. CompilerParameters cp = new CompilerParameters(); cp.ReferencedAssemblies.Add("System.dll"); cp.ReferencedAssemblies.Add("System.Xml.dll"); cp.ReferencedAssemblies.Add("System.Web.Services.dll"); cp.GenerateExecutable = false; cp.GenerateInMemory = true; cp.IncludeDebugInformation = false; ICodeCompiler icc = cscp.CreateCompiler(); CompilerResults cr = icc.CompileAssemblyFromSource(cp, m_SourceProxy); if (cr.Errors.Count > 0) { throw new Exception(string.Format("Build failed: {0} errors", cr.Errors.Count)); } return(m_Assembly = cr.CompiledAssembly); }
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); }
public Interpreter() { this.varTable = new HashtableWithItemGetterHook(this); AddNamespace("System"); AddNamespace("System.Collections"); AddReference("System.dll"); // Also works on Mono SetValue("interpreter", this); SetValue("_", this); Utils.interpreter = this; string fullExecutablePath = FullExecutablePath(); if (File.Exists(fullExecutablePath)) { AddReference(fullExecutablePath); } string localNamespace = typeof(Interpreter).Namespace; if (!string.IsNullOrEmpty(localNamespace)) { AddNamespace(localNamespace); } ConstructorInfo constructorInfo = typeof(CSharpCodeProvider).GetConstructor( new Type[] { typeof(System.Collections.Generic.Dictionary <string, string>) }); if (constructorInfo == null) { prov = new CSharpCodeProvider(); } else { System.Collections.Generic.Dictionary <string, string> providerOptions = new System.Collections.Generic.Dictionary <string, string>(); providerOptions.Add( "CompilerVersion", (Environment.Version < new Version("4.0.0.0")) ? "v3.5" : "v4.0"); prov = (CSharpCodeProvider)constructorInfo.Invoke(new object[] { providerOptions }); } using (StringWriter stringWriter = new StringWriter()) { gen = prov.CreateGenerator(stringWriter); } }
private string GenerateTypeCode(CodeGenerationInfo generationInfo) { var sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { var codeDomProvider = new CSharpCodeProvider(); var codeGenerator = codeDomProvider.CreateGenerator(sw); var compileUnit = new CodeCompileUnit(); var codeNamespace = new CodeNamespace(generationInfo.Namespace); codeNamespace.Imports.Add(new CodeNamespaceImport(generationInfo.ReaderNamespace)); CremaTypeEnumCreator.Create(codeNamespace, generationInfo); compileUnit.Namespaces.Add(codeNamespace); codeGenerator.GenerateCodeFromCompileUnit(compileUnit, sw, this.options); } return(sb.ToString()); }
/// <summary> /// /// </summary> /// <param name="NameSpace"></param> /// <param name="FolderPath"></param> /// <param name="ctd"></param> public static void WriteCsharpFile(String CompanyName, String DataAccessNamespaceSegment, String DatabaseName, String FolderPath, CodeTypeDeclaration ctd) { // [0] Build the Namespaces String CompanyNamespace = CompanyName; String DataAccessNamespace = String.Format("{0}.{1}", CompanyName, DataAccessNamespaceSegment); String DataLayerNamespace = String.Format("{0}.{1}.{2}", CompanyName, DataAccessNamespaceSegment, DatabaseName); CodeCompileUnit targetUnit = new CodeCompileUnit(); CodeNamespace gNamespace = new CodeNamespace(DataLayerNamespace); gNamespace.Imports.Add(new CodeNamespaceImport("System")); gNamespace.Imports.Add(new CodeNamespaceImport("System.IO")); gNamespace.Imports.Add(new CodeNamespaceImport("System.Linq")); gNamespace.Imports.Add(new CodeNamespaceImport("System.Collections")); gNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); gNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.ObjectModel")); gNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Specialized")); gNamespace.Imports.Add(new CodeNamespaceImport("System.Data")); gNamespace.Imports.Add(new CodeNamespaceImport("System.Xml")); gNamespace.Imports.Add(new CodeNamespaceImport("System.Xml.Linq")); gNamespace.Imports.Add(new CodeNamespaceImport(CompanyNamespace)); gNamespace.Imports.Add(new CodeNamespaceImport(DataAccessNamespace)); gNamespace.Imports.Add(new CodeNamespaceImport("System.Runtime.Serialization")); gNamespace.Types.Add(ctd); String NewCodeFileName = FolderPath + @"\" + ctd.Name + ".generated.cs"; Stream s = File.Open(NewCodeFileName, FileMode.Create); StreamWriter sw = new StreamWriter(s); CSharpCodeProvider cscProvider = new CSharpCodeProvider(); //VBCodeProvider cscProvider = new VBCodeProvider(); ICodeGenerator cscg = cscProvider.CreateGenerator(sw); CodeGeneratorOptions cop = new CodeGeneratorOptions(); // Create the Generated File cscg.GenerateCodeFromNamespace(gNamespace, sw, cop); sw.Close(); s.Close(); }
/// <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); } } }
void CreateTestFile(String[] values) { StreamWriter sw = new StreamWriter("test.cs"); CSharpCodeProvider cdp = new CSharpCodeProvider(); ICodeGenerator cg = cdp.CreateGenerator(); CodeNamespace cnspace = new CodeNamespace("N"); cnspace.Imports.Add(new CodeNamespaceImport("System")); CodeTypeDeclaration co = new CodeTypeDeclaration("C"); co.IsClass = true; cnspace.Types.Add(co); co.TypeAttributes = TypeAttributes.Public; CodeMemberMethod cmm = new CodeMemberMethod(); cmm.Name = "Main"; cmm.ReturnType = null; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeVariableDeclarationStatement cvar = new CodeVariableDeclarationStatement(typeof(String[]), "args", new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Environment"), "GetCommandLineArgs")); cmm.Statements.Add(cvar); cvar = new CodeVariableDeclarationStatement(typeof(Int32), "exitCode", new CodeSnippetExpression("0")); cmm.Statements.Add(cvar); String strArgLength = (values.Length + 1).ToString(); CodeConditionStatement ccs1 = new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("args.Length"), CodeBinaryOperatorType.IdentityInequality, new CodeSnippetExpression(strArgLength)), new CodeStatement [] { new CodeAssignStatement(new CodeVariableReferenceExpression("exitCode"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("exitCode"), CodeBinaryOperatorType.Add, new CodeSnippetExpression("1"))) }); cmm.Statements.Add(ccs1); ccs1 = new CodeConditionStatement(new CodeSnippetExpression("!args[0].ToLower().EndsWith(\"test.exe\")"), new CodeStatement [] { new CodeAssignStatement(new CodeVariableReferenceExpression("exitCode"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("exitCode"), CodeBinaryOperatorType.Add, new CodeSnippetExpression("1"))) }); cmm.Statements.Add(ccs1); for (int i = 0; i < values.Length; i++) { ccs1 = new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("args[" + (i + 1).ToString() + "]"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(values[i])), new CodeStatement [] { new CodeAssignStatement(new CodeVariableReferenceExpression("exitCode"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("exitCode"), CodeBinaryOperatorType.Add, new CodeSnippetExpression("1"))) }); cmm.Statements.Add(ccs1); } cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("Environment.ExitCode"), new CodeVariableReferenceExpression("exitCode"))); co.Members.Add(cmm); cg.GenerateCodeFromNamespace(cnspace, sw, null); sw.Flush(); sw.Close(); }
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 (); }
void CreateTestFile(String[] values) { StreamWriter sw = new StreamWriter("test.cs"); CSharpCodeProvider cdp = new CSharpCodeProvider(); ICodeGenerator cg = cdp.CreateGenerator(); CodeNamespace cnspace = new CodeNamespace("N"); cnspace.Imports.Add(new CodeNamespaceImport("System")); CodeTypeDeclaration co = new CodeTypeDeclaration ("C"); co.IsClass = true; cnspace.Types.Add (co); co.TypeAttributes = TypeAttributes.Public; CodeMemberMethod cmm = new CodeMemberMethod(); cmm.Name = "Main"; cmm.ReturnType = null; cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static; CodeVariableDeclarationStatement cvar = new CodeVariableDeclarationStatement(typeof(String[]), "args", new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Environment"), "GetCommandLineArgs")); cmm.Statements.Add(cvar); cvar = new CodeVariableDeclarationStatement(typeof(Int32), "exitCode", new CodeSnippetExpression("0")); cmm.Statements.Add(cvar); String strArgLength = (values.Length + 1).ToString(); CodeConditionStatement ccs1 = new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("args.Length"), CodeBinaryOperatorType.IdentityInequality, new CodeSnippetExpression(strArgLength)), new CodeStatement []{new CodeAssignStatement(new CodeVariableReferenceExpression("exitCode"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("exitCode"), CodeBinaryOperatorType.Add, new CodeSnippetExpression("1")))}); cmm.Statements.Add(ccs1); ccs1 = new CodeConditionStatement(new CodeSnippetExpression("!args[0].ToLower().EndsWith(\"test.exe\")"), new CodeStatement []{new CodeAssignStatement(new CodeVariableReferenceExpression("exitCode"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("exitCode"), CodeBinaryOperatorType.Add, new CodeSnippetExpression("1")))}); cmm.Statements.Add(ccs1); for(int i=0; i<values.Length; i++){ ccs1 = new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("args[" + (i+1).ToString() + "]"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(values[i])), new CodeStatement []{new CodeAssignStatement(new CodeVariableReferenceExpression("exitCode"), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("exitCode"), CodeBinaryOperatorType.Add, new CodeSnippetExpression("1")))}); cmm.Statements.Add(ccs1); } cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("Environment.ExitCode"), new CodeVariableReferenceExpression("exitCode"))); co.Members.Add(cmm); cg.GenerateCodeFromNamespace(cnspace, sw, null); sw.Flush(); sw.Close(); }