public static void WriteCode(this CodeNamespace @namespace, CodeDomProvider provider, TextWriter textWriter, CodeGeneratorOptions options) { if (@namespace == null) { throw new ArgumentNullException("namespace"); } if (provider == null) { throw new ArgumentNullException("provider"); } if (textWriter == null) { throw new ArgumentNullException("textWriter"); } CodeGenerator.ValidateIdentifiers(@namespace); if (textWriter is IndentedTextWriter) { provider.GenerateCodeFromNamespace(@namespace, textWriter, options); } else { using (IndentedTextWriter indentedWriter = new IndentedTextWriter(textWriter)) { provider.GenerateCodeFromNamespace(@namespace, indentedWriter, options); indentedWriter.Flush(); } } }
public void Build() { //ext OnBuildStarting(); xmlModel = new StateMachineXmlModel(InputFileName); model = xmlModel.Build(); //ext OnModelRead(model); StreamWriter streamWriter = new StreamWriter(OutputFileName); CodeCompileUnit code = new CodeCompileUnit(); CodeNamespace codeNamespace = CreateNameSpace(code); WriteHeader(codeNamespace); coder = new CoderStateMachine(model, Options, codeNamespace); coder.WriteCode(); OnBuildWriteCompleted(coder, codeNamespace, code, model); codeDomProvider.GenerateCodeFromNamespace(codeNamespace, streamWriter, null); streamWriter.Close(); OnBuildCompleted(coder, codeNamespace, code, model, OutputFileName, OutputDirectory); }
/// <summary>Generates the output.</summary> /// <param name="inputFileName">Name of file to generate input from</param> /// <param name="inputFileContent">Content of file to generate input from</param> protected override byte[] GenerateCode(string inputFileName, string inputFileContent) { string code = ""; try { // Process the file. CodeDomProvider Provider = CodeProvider; CodeNamespace ns = Processor.Process(inputFileName, FileNamespace, Provider); // Generate code for it. CodeGeneratorOptions opt = new CodeGeneratorOptions(); opt.BracingStyle = "C"; StringWriter sw = new StringWriter(); Provider.GenerateCodeFromNamespace(ns, sw, opt); // Finaly assign it to the result to return. code = sw.ToString(); Processor.PostProcess(inputFileName, ref code, Provider); } catch (Exception e) { code = String.Format(Resources.err_CouldNotGenerateCode, e); } // Convert to bytes. return(System.Text.Encoding.UTF8.GetBytes(code)); }
static void Main(string[] args) { CodeNamespace mynamespace = new CodeNamespace("myapplication"); Console.Out.WriteLine("\n--------- 以下是C#代码 ------------"); CodeDomProvider csp = CodeDomProvider.CreateProvider("C#"); csp.GenerateCodeFromNamespace(mynamespace, Console.Out, new CodeGeneratorOptions { BracingStyle = "C" }); Console.Out.WriteLine("\n\n------ - 以下是VB.NET代码---------- -"); CodeDomProvider vbp = CodeDomProvider.CreateProvider("VB"); vbp.GenerateCodeFromNamespace(mynamespace, Console.Out, new CodeGeneratorOptions()); Console.ReadKey(); DateTime dt = new DateTime(); var intArray = new int[] { 1, 2, 3, 4 }; Array.Sort(intArray, (a, b) => { return(a >= b?1:0); }); }
/// <summary> /// Generates source code from given namespace. /// </summary> private static string GenerateFromNamespace(CodeDomProvider codeProvider, System.CodeDom.CodeNamespace codeNamespace, bool blankLinesBetweenMembers, bool isCSharp) { var result = new StringBuilder(); using (var writer = new StringWriter(result)) { var options = new CodeGeneratorOptions { BlankLinesBetweenMembers = blankLinesBetweenMembers, ElseOnClosing = true, VerbatimOrder = true, BracingStyle = "C", }; // generate the code: codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options); // send it to the StringBuilder object: writer.Flush(); } if (isCSharp) { result.Replace(" class ", " static class "); result.Replace(" partial static ", " static partial "); result.Replace(" static System.Guid ", " static readonly System.Guid "); } return(result.ToString()); }
public string GenerateClass(XmlNode node, TypeTable typeTable) { InitializeCodeGenerator(); // Get the namespace and class type from the XML. XmlNode platformNode = node.SelectSingleNode("platform"); XmlNode nameNode = node.SelectSingleNode("name"); XmlNode mainNode = node.SelectSingleNode("//struct"); string className = typeTable.LocateEntryByFourCC(nameNode.Attributes["type"].InnerText).FullName; string friendlyClassName = nameNode.InnerText; string parentType = null; try { string fourCC = nameNode.Attributes["parenttype"].InnerText; if (fourCC != "????") { parentType = typeTable.LocateEntryByFourCC(fourCC).FullName; } } catch { parentType = null; } string mainBlockName = mainNode.Attributes["name"].InnerText + "Block"; //generate root level code ns = GenerateNamespaceAndImports(platformNode.InnerText, className, parentType); rootClassDeclaration = GenerateRootClass(className, friendlyClassName, mainBlockName, parentType, className /*typeTable.GetExtended(nameNode.Attributes["type"].InnerText)*/); // Generate all of the component block classes. List <string> structs = new List <string>(); XmlNodeList structsList = node.SelectNodes("//struct"); foreach (XmlNode structNode in structsList) { string nameOfClass = structNode.Attributes["name"].InnerText; // If the class already exists, don't generate it again. if (!structs.Contains(nameOfClass)) { CodeTypeDeclaration ct = GenerateBlockClass(structNode, false); rootClassDeclaration.Members.Add(ct); structs.Add(nameOfClass); } } ns.Types.Add(rootClassDeclaration); // Generate the code and return it as a string. StreamWriter writer = new StreamWriter(new MemoryStream()); provider.GenerateCodeFromNamespace(ns, writer, codeGenOptions); writer.Flush(); StreamReader reader = new StreamReader(writer.BaseStream); reader.BaseStream.Position = 0; string code = reader.ReadToEnd(); reader.Close(); writer.Close(); return(code); }
/// <summary> /// This method writes the generated code into a single file. /// </summary> private void WriteSingleCodeFile() { // Some assertions to make debugging easier. Debug.Assert(!string.IsNullOrEmpty(options.OutputLocation), "This action cannot be performed when output location is null or an empty string."); Debug.Assert(!string.IsNullOrEmpty(options.OutputFileName), "This action cannot be performed when output file name is null or an empty string"); // Get the destination file name. string fileName = CodeWriter.GetUniqueFileName(options.OutputLocation, options.OutputFileName, options.Language, options.OverwriteExistingFiles); // Create a StreamWriter for writing to the destination file. StreamWriter writer = new StreamWriter(fileName); try { // Write out the code to the destination file. provider.GenerateCodeFromNamespace(codeNamespace, writer, codeGenerationOptions); // Flush all buffers in the writer. writer.Flush(); codeFilesCount = 1; // Initialize generatedFileNames array to hold the one and only one // file we just generated. generatedCodeFileNames = new string[codeFilesCount + textFiles.Count]; // Finally add the file name to the generatedFileNames array. generatedCodeFileNames[0] = fileName; } catch (IOException e) { // Wrap the IOException in a CodeWriterException with little bit // more information. throw new CodeWriterException( string.Format("An error occurred while trying write to file {0}: {1}", fileName, e.Message), e); } finally { // No matter what happens, dispose the stream writer and release the unmanaged // resources. writer.Dispose(); } }
/// <summary> /// Generates class from the CodeCompileUnit and Language specified /// </summary> public override void Execute() { CodeDomProvider provider = ProviderFactory.CreateProvider(this.language); CodeGeneratorOptions options = new CodeGeneratorOptions(); using (StringWriter tw = new StringWriter()) { if (this.compileUnit.Namespaces.Count == 1) { provider.GenerateCodeFromNamespace(this.compileUnit.Namespaces[0], tw, options); this._class = tw.ToString(); } } }
public void GenerateTestFile(FeatureFileInput featureFile, CodeDomProvider codeProvider, TextReader inputReader, TextWriter outputWriter) { outputWriter = new IndentProcessingWriter(outputWriter); CodeDomHelper codeDomHelper = new CodeDomHelper(codeProvider); var codeNamespace = GenerateTestFileCode(featureFile, inputReader, codeProvider, codeDomHelper); var options = new CodeGeneratorOptions { BracingStyle = "C" }; AddSpecFlowHeader(codeProvider, outputWriter, codeDomHelper); codeProvider.GenerateCodeFromNamespace(codeNamespace, outputWriter, options); AddSpecFlowFooter(codeProvider, outputWriter, codeDomHelper); outputWriter.Flush(); }
/// <summary> /// Generate the WMI output file /// </summary> public void GenerateFile(ManagementObject mgo, string name, string outfile) { var imports = new string[] { "System", "System.Linq", "LinqToWmi.Core.WMI" }; var generatedNamespace = new CodeNamespace(_namespace); Assembly generatorAssembly = GetType().Assembly; string versionNumber = generatorAssembly.GetName().Version.ToString(); generatedNamespace.Comments.Add(new CodeCommentStatement(String.Format("<auto-generated>\n This code was generated by a tool.\n LinqToWmi.ClassGenerator Version: {0}\n\n Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.\n </auto-generated>", versionNumber))); var generatedClass = new CodeTypeDeclaration(name); generatedClass.CustomAttributes.Add(new CodeAttributeDeclaration("System.CodeDom.Compiler.GeneratedCodeAttribute", CreateAttributeArgument(generatorAssembly.GetName().Name), CreateAttributeArgument(versionNumber) )); generatedNamespace.Imports.AddRange((from import in imports select new CodeNamespaceImport(import)).ToArray()); IEnumerable <CodeMemberField> wmiProperties = from property in Wrap(mgo.Properties) select new CodeMemberField( new CodeTypeReference(CimTypeConverter.Convert(property)), GetFieldName(property.Name) ); generatedClass.Members.AddRange(wmiProperties.ToArray()); generatedClass.Members.AddRange((from property in Wrap(mgo.Properties) select CreateProperty(property)).ToArray()); generatedNamespace.Types.Add(generatedClass); //Write the file using the given code provider CodeDomProvider provider = CodeDomProvider.CreateProvider(_outputLanguage); string output = (outfile != null ? outfile : String.Format("{0}.{1}", name, provider.FileExtension)); using (TextWriter writer = new StreamWriter(File.OpenWrite(output))) { provider.GenerateCodeFromNamespace(generatedNamespace, writer, null); } }
public void Generate(TextWriter w, Database database, CodeDomProvider provider, String ns) { CodeCommentStatement c = new CodeCommentStatement( String.Format("Enum for {0}", database.DisplayName.Replace("DataSet", ""))); provider.GenerateCodeFromStatement(c, w, null); //Gen: namespace <NAMESPACE> { // using System; CodeNamespace cnamespace = new CodeNamespace(ns); cnamespace.Imports.Add(new CodeNamespaceImport("System")); string databaseName = database.DisplayName.Replace("DataSet", "").Replace(' ', '_'); //Gen: public enum <typeName> CodeTypeDeclaration enumViewsType = new CodeTypeDeclaration(databaseName + "Views"); enumViewsType.IsEnum = true; //Add this so that VB does not Inherit either interface enumViewsType.TypeAttributes = TypeAttributes.Public; cnamespace.Types.Add(enumViewsType); foreach (View view in database.Views.Values) { enumViewsType.Members.Add(new CodeMemberField(typeof(int), view.Name)); //Gen: public enum <typeName> CodeTypeDeclaration enumViewType = new CodeTypeDeclaration(view.Name); enumViewType.IsEnum = true; //Add this so that VB does not Inherit either interface enumViewType.TypeAttributes = TypeAttributes.Public; cnamespace.Types.Add(enumViewType); foreach (Field field in view.Fields.Values) { enumViewType.Members.Add(new CodeMemberField(typeof(int), field.Name)); } } provider.GenerateCodeFromNamespace(cnamespace, w, null); }
/// <summary> /// Writes each types in each namespaces into individual files /// </summary> /// <param name="outputdir">name of directory to write to</param> public virtual void WriteTypes(string outputdir) { CodeDomProvider cscp = DoJava ? (CodeDomProvider) Type.GetType("Microsoft.VJSharp.VJSharpCodeProvider").GetConstructor( new Type[0]).Invoke(new object[0]) : new CSharpCodeProvider(); var opts = new CodeGeneratorOptions(); opts.BracingStyle = "C"; opts.IndentString = "\t"; opts.BlankLinesBetweenMembers = false; CodeNamespaceCollection nsc = CompileUnit.Namespaces; for (int i = 0; i < nsc.Count; i++) { var ns = nsc[i]; string dir = outputdir + "\\" + CodeGenUtil.Instance.UnMangle(ns.Name).Replace('.', '\\'); Directory.CreateDirectory(dir); var new_ns = new CodeNamespace(ns.Name); new_ns.Comments.Add(CodeGenUtil.Instance.FileComment); foreach (CodeNamespaceImport nci in CodeGenUtil.Instance.NamespaceImports) { new_ns.Imports.Add(nci); } var types = ns.Types; for (int j = 0; j < types.Count; j++) { var ctd = types[j]; string file = dir + "\\" + CodeGenUtil.Instance.UnMangle(ctd.Name) + (DoJava ? ".java" : ".cs"); using (var writer = new StreamWriter(file, false)) { new_ns.Types.Add(ctd); cscp.GenerateCodeFromNamespace(new_ns, writer, opts); new_ns.Types.Remove(ctd); } } } }
public void GenerateCode( string outputPath, NamespaceDeclaration ns ) { if (ns == null) { throw new ArgumentNullException("ns"); } foreach (DictionaryEntry de in ns.ToCodeDom()) { FileName key = (FileName)de.Key; CodeNamespace nms = (CodeNamespace)de.Value; // creating directory string path; if (createFolders) { path = PathFromNamespace(outputPath, key.Namespace); } else { path = outputPath; } string filePath = Path.Combine(path, key.Name + "." + this.Provider.FileExtension); using (StreamWriter writer = new StreamWriter(filePath)) { // add copyright nms.Comments.Add(new CodeCommentStatement(copyright)); // Create a TextWriter to a StreamWriter to an output file. IndentedTextWriter tw = new IndentedTextWriter(writer, this.tab); // Generate source code using the code generator. provider.GenerateCodeFromNamespace(nms, tw, options); // log this.OnFileCreated(new StringEventArgs(filePath)); } } }
public void Build() { xmlModel = new StateMachineXmlModel(InputFileName); model = xmlModel.Build(); StreamWriter streamWriter = new StreamWriter(OutputFileName); CodeCompileUnit code = new CodeCompileUnit(); CodeNamespace codeNamespace = CreateNameSpace(code); WriteHeader(codeNamespace); coder = new CoderStateMachine(model, Options, codeNamespace); coder.WriteCode(); codeDomProvider.GenerateCodeFromNamespace(codeNamespace, streamWriter, null); streamWriter.Close(); }
/// <summary> /// Generates source code from given namespace. /// </summary> private static string GenerateFromNamespace(CodeDomProvider codeProvider, System.CodeDom.CodeNamespace codeNamespace, bool blankLinesBetweenMembers) { var result = new StringBuilder(); var writer = new StringWriter(result); var options = new CodeGeneratorOptions(); options.BlankLinesBetweenMembers = blankLinesBetweenMembers; options.ElseOnClosing = true; options.VerbatimOrder = true; options.BracingStyle = "C"; // generate the code: codeProvider.GenerateCodeFromNamespace(codeNamespace, writer, options); // send it to the StringBuilder object: writer.Flush(); return(result.ToString()); }
/// <summary> /// Generates a value type implementation for forValueType in /// targetWriter /// </summary> private void GenerateValueTypeImplToFile(Type forValueType, TextWriter targetWriter) { CodeNamespace targetNamespace = new CodeNamespace(forValueType.Namespace); CodeTypeDeclaration valTypeImpl = new CodeTypeDeclaration(forValueType.Name + "Impl"); targetNamespace.Types.Add(valTypeImpl); valTypeImpl.TypeAttributes = TypeAttributes.Class | TypeAttributes.Public; valTypeImpl.BaseTypes.Add(forValueType.Name); valTypeImpl.CustomAttributes.Add( new CodeAttributeDeclaration("Serializable")); AddNamespaceImport(targetNamespace, "System"); AddMembers(forValueType, valTypeImpl, targetNamespace); m_codeDomProvider.GenerateCodeFromNamespace(targetNamespace, targetWriter, new CodeGeneratorOptions()); }
private static string GenerateCode(CodeObject c, CodeDomProvider provider) { var sb = new StringBuilder(); var writer = new StringWriter(sb); var options = new CodeGeneratorOptions(); if (c is CodeStatement) { provider.GenerateCodeFromStatement((CodeStatement)c, writer, options); } else if (c is CodeCompileUnit) { provider.GenerateCodeFromCompileUnit((CodeCompileUnit)c, writer, options); } else if (c is CodeExpression) { provider.GenerateCodeFromExpression((CodeExpression)c, writer, options); } else if (c is CodeTypeMember) { provider.GenerateCodeFromMember((CodeTypeMember)c, writer, options); } else if (c is CodeTypeDeclaration) { provider.GenerateCodeFromType((CodeTypeDeclaration)c, writer, options); } else if (c is CodeNamespace) { provider.GenerateCodeFromNamespace((CodeNamespace)c, writer, options); } else { throw new ArgumentException($"Tests not set up for unexpected type: {c.GetType()}"); } return(sb.ToString()); }
private static string GenerateCode(CodeObject c, CodeDomProvider provider) { var sb = new StringBuilder(); var writer = new StringWriter(sb); var options = new CodeGeneratorOptions(); if (c is CodeStatement) { provider.GenerateCodeFromStatement((CodeStatement)c, writer, options); } else if (c is CodeCompileUnit) { provider.GenerateCodeFromCompileUnit((CodeCompileUnit)c, writer, options); } else if (c is CodeExpression) { provider.GenerateCodeFromExpression((CodeExpression)c, writer, options); } else if (c is CodeTypeMember) { provider.GenerateCodeFromMember((CodeTypeMember)c, writer, options); } else if (c is CodeTypeDeclaration) { provider.GenerateCodeFromType((CodeTypeDeclaration)c, writer, options); } else if (c is CodeNamespace) { provider.GenerateCodeFromNamespace((CodeNamespace)c, writer, options); } else { Assert.False(true, $"Unknown type: {c.GetType()}"); } return(sb.ToString()); }
/// <summary> /// Serializes a component to a source code in the language specified in the <see cref="LiteDevelop.Essentials.FormsDesigner.DesignerCodeWriter.Language"/> property. /// </summary> /// <param name="namespace">The namespace to create the code in.</param> /// <param name="instance">The object to be serialized.</param> /// <param name="container">The container object.</param> /// <param name="includeBaseType">Include the base type of the instance in the to be generated source.</param> /// <returns></returns> public string SerializeCode(string @namespace, Component instance, IContainer container, bool includeBaseType) { // Create new namespace CodeNamespace codeNamespace = new CodeNamespace(@namespace); // Create new class. CodeTypeDeclaration controlType = new CodeTypeDeclaration(instance.Site.Name) { Attributes = MemberAttributes.Public, IsClass = true, IsPartial = true, }; if (includeBaseType) { controlType.BaseTypes.Add(new CodeTypeReference(instance.GetType())); } // generate fields for members. controlType.Members.AddRange(GenerateMembers(container)); // generate initializecomponent(). controlType.Members.Add(GenerateInitializeComponentMethod(instance, container)); // add class to namespace. codeNamespace.Types.Add(controlType); string code = string.Empty; using (MemoryStream stream = new MemoryStream()) { using (StreamWriter writer = new StreamWriter(stream)) { using (IndentedTextWriter codeWriter = new IndentedTextWriter(writer, " ")) { CodeDomProvider provider = Language.CodeProvider; using (provider) { // generate source code. provider.GenerateCodeFromNamespace(codeNamespace, codeWriter, new CodeGeneratorOptions() { BlankLinesBetweenMembers = true, BracingStyle = "C", // use new lines on brackets. }); } } // write data to stream. writer.Flush(); // read stream contents to get code. stream.Position = 0; using (StreamReader reader = new StreamReader(stream)) { code = reader.ReadToEnd(); } } } propertySerializer.TemporaryVariables.Clear(); return(code); }
protected override void ProcessRecord() { if (CompileUnit != null && CompileUnit.Length > 0) { foreach (CodeCompileUnit compileUnit in CompileUnit) { if (compileUnit != null) { _provider.GenerateCodeFromCompileUnit(compileUnit, _indentedWriter, Options); } } } else if (Expression != null && Expression.Length > 0) { foreach (CodeExpression expr in Expression) { if (expr != null) { _provider.GenerateCodeFromExpression(expr, _indentedWriter, Options); } } } else if (Member != null && Member.Length > 0) { foreach (CodeTypeMember member in Member) { if (member != null) { _provider.GenerateCodeFromMember(member, _indentedWriter, Options); } } } else if (NS != null && NS.Length > 0) { foreach (CodeNamespace ns in NS) { if (ns != null) { _provider.GenerateCodeFromNamespace(ns, _indentedWriter, Options); } } } else if (Statement != null && Statement.Length > 0) { foreach (CodeStatement st in Statement) { if (st != null) { _provider.GenerateCodeFromStatement(st, _indentedWriter, Options); } } } else if (Type != null && Type.Length > 0) { foreach (CodeTypeDeclaration t in Type) { if (t != null) { _provider.GenerateCodeFromType(t, _indentedWriter, Options); } } } }
private Type CompileTypeFromFile(OpenedFile file) { string sourceCode = file.GetContentsAsString(); var projectFile = _extensionHost.CurrentSolution.FindProjectFile(file.FilePath); if (projectFile == null) { throw new FileNotFoundException("Cannot find project file " + file.FilePath.FullPath); } CompilerParameters parameters = new CompilerParameters() { GenerateInMemory = true, GenerateExecutable = false, }; // standard references. parameters.ReferencedAssemblies.AddRange(new string[] { "mscorlib.dll", "System.dll", "System.Drawing.dll", "System.Windows.Forms.dll" }); CodeDomProvider provider = Language.CodeProvider; // validate source var sourceSnapshot = Language.CreateSourceSnapshot(sourceCode) as NetSourceSnapshot; if (sourceSnapshot.Types.Length != 1) { throw new ArgumentException("Source must contain exactly one type."); } string @namespace; if (sourceSnapshot.Namespaces.Length == 0) { // TODO: add temp namespace .... throw new NotImplementedException("Cannot handle classes without a namespace yet."); } else { @namespace = sourceSnapshot.Namespaces[0].Name; } // create stub class var writer = new StringWriter(); var stubClass = new CodeTypeDeclaration(sourceSnapshot.Types[0].Name) { IsPartial = true }; stubClass.Members.Add(GenerateConstructor()); // check if snapshot class doesn't have a base type. if (string.IsNullOrEmpty(sourceSnapshot.Types[0].ValueType)) { // try to find in dependencies foreach (var dependency in file.Dependencies) { if (Path.GetExtension(dependency) == file.FilePath.Extension) { var dependentFile = _extensionHost.FileService.OpenFile(projectFile.FilePath.ParentDirectory.Combine(dependency)); var dependencySnapshot = Language.CreateSourceSnapshot(dependentFile.GetContentsAsString()) as NetSourceSnapshot; if (dependencySnapshot.Types[0].Name == sourceSnapshot.Types[0].Name && !string.IsNullOrEmpty(dependencySnapshot.Types[0].ValueType)) { var baseType = dependencySnapshot.GetTypeByName(dependencySnapshot.Types[0].ValueType); if (baseType != null) { stubClass.BaseTypes.Add(baseType); break; } } } } } // write stub class var stubNamespace = new CodeNamespace(@namespace); stubNamespace.Types.Add(stubClass); provider.GenerateCodeFromNamespace(stubNamespace, writer, new CodeGeneratorOptions()); // compile. CompilerResults results = provider.CompileAssemblyFromSource(parameters, sourceCode, writer.GetStringBuilder().ToString()); if (results.Errors.Count == 0) { // find target type. foreach (Type type in results.CompiledAssembly.GetTypes()) { if (type.IsBasedOn(typeof(Component))) { return(type); } } throw new Exception("The type based on " + typeof(Component).FullName + " was not found."); } else { throw new BuildException("The compiler did not succeed in compiling the source.", BuildResult.FromCompilerResults(results)); } }
public string GenerateCodeString() { CodeGeneratorOptions gen = new CodeGeneratorOptions(); gen.BracingStyle = "C"; gen.IndentString = "\t"; gen.VerbatimOrder = true; gen.BlankLinesBetweenMembers = false; StringBuilder sb = new StringBuilder(); using (TextWriter writer = new StringWriter(sb)) { //a header is written to the file. //this embeds some information about how the file was compiled CodeCommentStatementCollection headerCommentes = new CodeCommentStatementCollection(); GenerateHeader(headerCommentes); for (int i = 0; i < headerCommentes.Count; i++) { codeProvider.GenerateCodeFromStatement(headerCommentes[i], writer, gen); } sb.AppendLine(); //generate shader byte pool first, if needed if (source.PoolShaderBytes) { //add the shader pools sb.AppendLine(directives.IfXboxStatement.Text); CodeNamespace space = new CodeNamespace(this.outputNamespace); source.BytePoolXbox.GeneratePool(space.Types, directives); codeProvider.GenerateCodeFromNamespace(space, writer, gen); sb.AppendLine(directives.ElseStatement.Text); space = new CodeNamespace(this.outputNamespace); source.BytePoolPC.GeneratePool(space.Types, directives); codeProvider.GenerateCodeFromNamespace(space, writer, gen); sb.AppendLine(directives.EndifStatement.Text); } if (!source.DefinePlatform) { //geneate the single root namespace codeProvider.GenerateCodeFromNamespace(rootNamespace, writer, gen); } else { //generate the two namespaces, broken up by #if block //#if sb.AppendLine(directives.IfXboxStatement.Text); //xbox code codeProvider.GenerateCodeFromNamespace(rootXboxNamespace, writer, gen); //#else sb.AppendLine(directives.ElseStatement.Text); //pc code codeProvider.GenerateCodeFromNamespace(rootPcNamespace, writer, gen); //#endif sb.AppendLine(directives.EndifStatement.Text); } } return(sb.ToString()); }
private static String ConstructGeneratorCode(TemplateItem item, Boolean lineNumbers, String namespaceName, CodeDomProvider provider) { // 准备类名和命名空间 CodeNamespace codeNamespace = new CodeNamespace(namespaceName); // 加入引用的命名空间 foreach (String str in item.Imports) { if (!String.IsNullOrEmpty(str)) { codeNamespace.Imports.Add(new CodeNamespaceImport(str)); } } CodeTypeDeclaration typeDec = new CodeTypeDeclaration(item.ClassName); typeDec.IsClass = true; codeNamespace.Types.Add(typeDec); // 基类 if (!String.IsNullOrEmpty(item.BaseClassName)) { typeDec.BaseTypes.Add(new CodeTypeReference(item.BaseClassName)); } else if (!String.IsNullOrEmpty(BaseClassName)) { typeDec.BaseTypes.Add(new CodeTypeReference(BaseClassName)); } else { typeDec.BaseTypes.Add(new CodeTypeReference(typeof(TemplateBase))); } if (!String.IsNullOrEmpty(item.Name)) { typeDec.LinePragma = new CodeLinePragma(item.Name, 1); } // Render方法 CreateRenderMethod(item.Blocks, lineNumbers, typeDec); // 代码生成选项 CodeGeneratorOptions options = new CodeGeneratorOptions(); options.VerbatimOrder = true; options.BlankLinesBetweenMembers = false; options.BracingStyle = "C"; // 其它类成员代码块 Boolean firstMemberFound = false; foreach (Block block in item.Blocks) { firstMemberFound = GenerateMemberForBlock(block, typeDec, lineNumbers, provider, options, firstMemberFound); } // 模版变量 if (item.Vars != null && item.Vars.Count > 0) { // 构建静态构造函数,初始化静态属性Vars CreateCctorMethod(typeDec, item.Vars); //public Int32 VarName //{ // get { return (Int32)GetData("VarName"); } // set { Data["VarName"] = value; } //} foreach (String v in item.Vars.Keys) { TypeX vtype = TypeX.Create(item.Vars[v]); String codeName = vtype.FullName; StringBuilder sb = new StringBuilder(); sb.AppendLine(); sb.AppendFormat("public {0} {1}", codeName, v); sb.AppendLine("{"); sb.AppendFormat(" get {{ return GetData<{0}>(\"{1}\"); }}", codeName, v); sb.AppendLine(); sb.AppendFormat(" set {{ Data[\"{0}\"] = value; }}", v); sb.AppendLine(); sb.AppendLine("}"); CodeSnippetTypeMember member = new CodeSnippetTypeMember(sb.ToString()); typeDec.Members.Add(member); } } // 输出 using (StringWriter writer = new StringWriter()) { provider.GenerateCodeFromNamespace(codeNamespace, new IndentedTextWriter(writer), options); return(writer.ToString()); } }
//Generate code for class Node private void GenerateNode() { CodeNamespace ns = new CodeNamespace("GenericList"); compileUnit.Namespaces.Add(ns); //Create class Node CodeTypeDeclaration nodeClass = new CodeTypeDeclaration("Node"); //Add types to generic class nodeClass.TypeParameters.Add(keyTypeParameter); nodeClass.TypeParameters.Add(itemTypeParameter); //Add class to namespace ns.Types.Add(nodeClass); //Add field //public K Key; CodeMemberField keyField = GeneratePublicField("Key", keyType); //Add start region directive //#region Public Fields keyField.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Public Fields")); nodeClass.Members.Add(keyField); //Add field //public T item; CodeMemberField itemField = GeneratePublicField("Item", itemType); nodeClass.Members.Add(itemField); //Add field //public Node<K,T> NextNode CodeMemberField nextNodeField = GeneratePublicField("NextNode", nodeType); //Add end region directive //#endregion nextNodeField.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "End")); nodeClass.Members.Add(nextNodeField); //Add default constructor #region C# code //Node() //{ // Key = K.default; // Item = new T(); // NextNode = null; //} #endregion CodeStatementCollection defConstructorColl = new CodeStatementCollection(); //this.Key = K.default defConstructorColl.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "Key"), new CodeDefaultValueExpression(keyType))); //this.item = new T() defConstructorColl.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "Item"), new CodeObjectCreateExpression(itemType, new CodeExpression[] {})) ); //this.NextNode = null defConstructorColl.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "NextNode"), new CodePrimitiveExpression(null)) ); CodeConstructor defConstructor = GeneratePublicConstructor("Node", new CodeTypeReference[] {}, new string[] {}, defConstructorColl); nodeClass.Members.Add(defConstructor); //Add parameterized constructor #region C# code //Node(K keyPar, T itemPar, Node<K,T> nextNodePar) //{ // Key = keyPar; // Item = itemPar; // NextNode = nextNodePar; //} #endregion CodeStatementCollection parmConstructorColl = new CodeStatementCollection(); //this.Key = keyPar parmConstructorColl.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "Key"), new CodeArgumentReferenceExpression("keyPar")) ); //this.Item = itemPar parmConstructorColl.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "Item"), new CodeArgumentReferenceExpression("itemPar")) ); //this.NextNode = nextNodePar parmConstructorColl.Add( new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "NextNode"), new CodeArgumentReferenceExpression("nextNodePar")) ); CodeConstructor parmConstructor = GeneratePublicConstructor("Node", new CodeTypeReference[] { keyType, itemType, nodeType }, new string[] { "keyPar", "itemPar", "nextNodePar" }, parmConstructorColl); nodeClass.Members.Add(parmConstructor); TextWriter t = new StreamWriter(path + @"\Node." + provider.FileExtension, false); provider.GenerateCodeFromNamespace(ns, t, options); t.Close(); }
/// <summary> /// Gera o código do mapeamento. /// </summary> /// <param name="map">Dados do mapeamento.</param> /// <param name="baseTypeName">Tipo base da model a ser criada.</param> /// <param name="outStream">Sream onde sera salvo o codigo gerado.</param> public void Generate(TableMap map, string baseTypeName, Stream outStream) { if (map == null) { throw new ArgumentNullException("map"); } CodeCompileUnit codeCU = new CodeCompileUnit(); codeCU.StartDirectives.Clear(); CodeNamespace codeNsp = new CodeNamespace(_namespaceName); codeNsp.Imports.Add(new CodeNamespaceImport("System")); codeNsp.Imports.Add(new CodeNamespaceImport("GDA")); if (UsingWCFPattern) { codeNsp.Imports.Add(new CodeNamespaceImport("System.Runtime.Serialization")); } foreach (CodeNamespaceImport cni in _imports) { codeNsp.Imports.Add(cni); } codeCU.Namespaces.Add(codeNsp); CodeTypeDeclaration codeType = new CodeTypeDeclaration(StandartName(map.TableName, true)); codeType.Comments.Add(new CodeCommentStatement("<summary>", true)); codeType.Comments.Add(new CodeCommentStatement(string.Format("This class represent the {0} {1}.", (map.IsView ? "view" : "table"), map.TableName), true)); if (!string.IsNullOrEmpty(map.Comment)) { codeType.Comments.Add(new CodeCommentStatement(map.Comment, true)); } codeType.Comments.Add(new CodeCommentStatement("</summary>", true)); if (!string.IsNullOrEmpty(baseTypeName)) { codeType.BaseTypes.Add(new CodeTypeReference(baseTypeName)); } codeType.CustomAttributes.Add(new CodeAttributeDeclaration("PersistenceClass", new CodeAttributeArgument(new CodeTypeReferenceExpression("\"" + StandartName(map.TableName, false) + "\"")))); if (UsingWCFPattern) { CodeAttributeDeclaration codeAD = new CodeAttributeDeclaration("DataContract"); codeAD.Arguments.Add(new CodeAttributeArgument("Name", new CodeTypeReferenceExpression("\"" + StandartName(map.TableName, false) + "\""))); codeAD.Arguments.Add(new CodeAttributeArgument("Namespace", new CodeTypeReferenceExpression("\"\""))); codeType.CustomAttributes.Add(codeAD); } foreach (CodeAttributeDeclaration attr in _classCustomAttributes) { codeType.CustomAttributes.Add(attr); } for (int i = 0; i < map.Fields.Count; i++) { FieldMap fm = map.Fields[i]; if (string.IsNullOrEmpty(fm.ColumnName)) { continue; } string fieldName = StandartName(fm.ColumnName, true); if (fieldName.Length > 1) { fieldName = "_" + char.ToLower(fieldName[0]) + fieldName.Substring(1); } else { fieldName = "_" + fieldName.ToUpper(); } CodeMemberField field = new CodeMemberField(fm.MemberType, fieldName); codeType.Members.Add(field); if (i == 0) { CodeRegionDirective startlocalVariablesRegion = new CodeRegionDirective(CodeRegionMode.Start, "Local Variables\r\n"); field.StartDirectives.Add(startlocalVariablesRegion); } if (i + 1 == map.Fields.Count || map.Fields.Count == 1) { CodeRegionDirective endlocalVariablesRegion = new CodeRegionDirective(CodeRegionMode.End, "Local Variables"); field.EndDirectives.Add(endlocalVariablesRegion); } } for (int i = 0; i < map.Fields.Count; i++) { FieldMap fm = map.Fields[i]; if (string.IsNullOrEmpty(fm.ColumnName)) { continue; } string fieldName = StandartName(fm.ColumnName, true); if (fieldName.Length > 1) { fieldName = "_" + char.ToLower(fieldName[0]) + fieldName.Substring(1); } else { fieldName = "_" + fieldName.ToUpper(); } string propertyName = StandartName(fm.ColumnName, true); Type pType = fm.MemberType; CodeMemberProperty property = new CodeMemberProperty(); property.Name = propertyName; property.Type = new CodeTypeReference(pType); property.Attributes = MemberAttributes.Public | MemberAttributes.Final; if (!string.IsNullOrEmpty(fm.Comment)) { property.Comments.Add(new CodeCommentStatement("<summary>", true)); property.Comments.Add(new CodeCommentStatement(fm.Comment, true)); property.Comments.Add(new CodeCommentStatement("</summary>", true)); } CodeAttributeDeclaration cadPP = new CodeAttributeDeclaration("PersistenceProperty"); cadPP.Arguments.Add(new CodeAttributeArgument(new CodeTypeReferenceExpression("\"" + fm.ColumnName + "\""))); if (fm.IsAutoGenerated) { cadPP.Arguments.Add(new CodeAttributeArgument(new CodeTypeReferenceExpression("PersistenceParameterType.IdentityKey"))); } else if (fm.IsPrimaryKey) { cadPP.Arguments.Add(new CodeAttributeArgument(new CodeTypeReferenceExpression("PersistenceParameterType.Key"))); } if (!pType.IsValueType && fm.Size > 0) { cadPP.Arguments.Add(new CodeAttributeArgument(new CodeTypeReferenceExpression(fm.Size.ToString()))); } property.CustomAttributes.Add(cadPP); if (!pType.IsValueType && !fm.IsNullable) { CodeAttributeDeclaration cadReq = new CodeAttributeDeclaration("RequiredValidator"); property.CustomAttributes.Add(cadReq); } if (!string.IsNullOrEmpty(fm.ForeignKeyTableName)) { property.CustomAttributes.Add(new CodeAttributeDeclaration("PersistenceForeignKey", new CodeAttributeArgument(new CodeTypeReferenceExpression("typeof(" + StandartName(fm.ForeignKeyTableName, true) + ")")), new CodeAttributeArgument(new CodeTypeReferenceExpression("\"" + StandartName(fm.ForeignKeyColumnName, true) + "\"")))); } if (UsingWCFPattern) { CodeAttributeDeclaration codeAD = new CodeAttributeDeclaration("DataMember"); codeAD.Arguments.Add(new CodeAttributeArgument("Name", new CodeTypeReferenceExpression("\"" + property.Name + "\""))); if (!fm.IsNullable) { codeAD.Arguments.Add(new CodeAttributeArgument("IsRequired", new CodePrimitiveExpression(true))); } property.CustomAttributes.Add(codeAD); } foreach (CodeAttributeDeclaration attr in _propertyCustomAttributes) { property.CustomAttributes.Add(attr); } property.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(null, fieldName))); property.SetStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(null, fieldName), new CodePropertySetValueReferenceExpression())); codeType.Members.Add(property); if (i == 0) { CodeRegionDirective startlocalVariablesRegion = new CodeRegionDirective(CodeRegionMode.Start, "Properties\r\n"); property.StartDirectives.Add(startlocalVariablesRegion); } if (i + 1 == map.Fields.Count || map.Fields.Count == 1) { CodeRegionDirective endlocalVariablesRegion = new CodeRegionDirective(CodeRegionMode.End, "Properties"); property.EndDirectives.Add(endlocalVariablesRegion); } } codeNsp.Types.Add(codeType); StringBuilder sb = new StringBuilder(); StringWriter sw = new StringWriter(sb); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; options.ElseOnClosing = true; CodeDomProvider provider = CodeDomProvider.CreateProvider(_codeLanguage); provider.GenerateCodeFromNamespace(codeNsp, sw, options); string code = sb.ToString(); code = code.Replace("System.DateTime", "DateTime"); int pos1 = 0, pos2 = 0, pos3 = 0; do { pos1 = code.IndexOf("System.Nullable<", pos1); if (pos1 >= 0) { pos2 = code.IndexOf('>', pos1); pos3 = pos1 + "System.Nullable<".Length; code = code.Substring(0, pos1) + code.Substring(pos3, pos2 - pos3) + "?" + code.Substring(pos2 + 1); } }while (pos1 >= 0); outStream.Write(System.Text.Encoding.Default.GetBytes(code), 0, code.Length); }
/// <summary> /// Create a new Alpaca client executable using the supplied parameters /// </summary> /// <param name="DeviceType">The ASCOM device type to create</param> /// <param name="DeviceNumber">The number of this device type to create</param> /// <param name="OutputDirectory">The directory in which to place the compiled assembly</param> /// <remarks> /// This subroutine creates compiler source line definitions (not source code as such) and stores them in memory /// When complete, the compiler is called and the resultant assembly is stored in the specified output directory. /// The code created has no function as such it is just a shell with all of the heavy lifting undertaken by an inherited base class that is supplied pre-compiled /// The resultant assembly for Camera device 1 has this form: /// /// using System; /// using System.Runtime.InteropServices; /// namespace ASCOM.DynamicRemoteClients /// { /// [Guid("70495DF9-C01E-4987-AE49-E12967202C7F")] <====> The GUID is dynamically created on the user's machine so that it is unique for every driver /// [ProgId(DRIVER_PROGID)] /// [ServedClassName(DRIVER_DISPLAY_NAME)] /// [ClassInterface(ClassInterfaceType.None)] /// public class Camera : CameraBaseClass <====> Created from supplied parameters - all executable code is in the base class /// { /// private const string DRIVER_NUMBER = "1"; <====> Created from supplied parameters /// private const string DEVICE_TYPE = "Camera"; <====> Created from supplied parameters /// private const string DRIVER_DISPLAY_NAME = SharedConstants.DRIVER_DISPLAY_NAME + " " + DRIVER_NUMBER; /// private const string DRIVER_PROGID = SharedConstants.DRIVER_PROGID_BASE + DRIVER_NUMBER + "." + DEVICE_TYPE; /// public Camera() : base(DRIVER_NUMBER, DRIVER_DISPLAY_NAME, DRIVER_PROGID) /// { /// } /// } /// } /// </remarks> internal static void CreateAlpacaClient(string DeviceType, int DeviceNumber, string ProgId, string DisplayName, string localServerPath) { TL.LogMessage("CreateAlpacaClient", $"Creating new ProgID: for {DeviceType} device {DeviceNumber} with ProgID: {ProgId} and display name: {DisplayName}"); try { // Generate the container unit CodeCompileUnit program = new CodeCompileUnit(); // Generate the namespace CodeNamespace ns = new CodeNamespace("ASCOM.DynamicRemoteClients"); // Add required imports ns.Imports.Add(new CodeNamespaceImport("System")); ns.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices")); // Declare the device class CodeTypeDeclaration deviceClass = new CodeTypeDeclaration() { Name = DeviceType, IsClass = true }; // Add the class base type deviceClass.BaseTypes.Add(new CodeTypeReference { BaseType = DeviceType + BASE_CLASS_POSTFIX }); TL.LogMessage("CreateAlpacaClient", "Created base type"); // Create custom attributes to decorate the class CodeAttributeDeclaration guidAttribute = new CodeAttributeDeclaration("Guid", new CodeAttributeArgument(new CodePrimitiveExpression(Guid.NewGuid().ToString()))); CodeAttributeDeclaration progIdAttribute = new CodeAttributeDeclaration("ProgId", new CodeAttributeArgument(new CodeArgumentReferenceExpression("DRIVER_PROGID"))); CodeAttributeDeclaration servedClassNameAttribute = new CodeAttributeDeclaration("ServedClassName", new CodeAttributeArgument(new CodeArgumentReferenceExpression("DRIVER_DISPLAY_NAME"))); CodeAttributeDeclaration classInterfaceAttribute = new CodeAttributeDeclaration("ClassInterface", new CodeAttributeArgument(new CodeArgumentReferenceExpression("ClassInterfaceType.None"))); CodeAttributeDeclarationCollection customAttributes = new CodeAttributeDeclarationCollection() { guidAttribute, progIdAttribute, servedClassNameAttribute, classInterfaceAttribute }; TL.LogMessage("CreateAlpacaClient", "Created custom attributes"); // Add the custom attributes to the class deviceClass.CustomAttributes = customAttributes; // Create some class level private constants CodeMemberField driverNumberConst = new CodeMemberField(typeof(string), "DRIVER_NUMBER"); driverNumberConst.Attributes = MemberAttributes.Private | MemberAttributes.Const; driverNumberConst.InitExpression = new CodePrimitiveExpression(DeviceNumber.ToString()); CodeMemberField deviceTypeConst = new CodeMemberField(typeof(string), "DEVICE_TYPE"); deviceTypeConst.Attributes = MemberAttributes.Private | MemberAttributes.Const; deviceTypeConst.InitExpression = new CodePrimitiveExpression(DeviceType); CodeMemberField driverDisplayNameConst = new CodeMemberField(typeof(string), "DRIVER_DISPLAY_NAME"); driverDisplayNameConst.Attributes = (MemberAttributes.Private | MemberAttributes.Const); driverDisplayNameConst.InitExpression = new CodePrimitiveExpression(DisplayName); CodeMemberField driverProgIDConst = new CodeMemberField(typeof(string), "DRIVER_PROGID"); driverProgIDConst.Attributes = MemberAttributes.Private | MemberAttributes.Const; driverProgIDConst.InitExpression = new CodePrimitiveExpression(ProgId); // Add the constants to the class deviceClass.Members.AddRange(new CodeMemberField[] { driverNumberConst, deviceTypeConst, driverDisplayNameConst, driverProgIDConst }); TL.LogMessage("CreateAlpacaClient", "Added constants to class"); // Declare the class constructor CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public | MemberAttributes.Final; // Add a call to the base class with required parameters constructor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("DRIVER_NUMBER")); constructor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("DRIVER_DISPLAY_NAME")); constructor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("DRIVER_PROGID")); deviceClass.Members.Add(constructor); TL.LogMessage("CreateAlpacaClient", "Added base constructor"); // Add the class to the namespace ns.Types.Add(deviceClass); TL.LogMessage("CreateAlpacaClient", "Added class to name space"); // Add the namespace to the program, which is now complete program.Namespaces.Add(ns); TL.LogMessage("CreateAlpacaClient", "Added name space to program"); // Construct the path to the output DLL String dllName = $"{localServerPath.TrimEnd('\\')}\\{SharedConstants.DRIVER_PROGID_BASE}{DeviceNumber}.{DeviceType}.dll"; TL.LogMessage("CreateAlpacaClient", string.Format("Output file name: {0}", dllName)); // Create relevant compiler options to shape the compilation CompilerParameters cp = new CompilerParameters() { GenerateExecutable = false, // Specify output of a DLL OutputAssembly = dllName, // Specify the assembly file name to generate GenerateInMemory = false, // Save the assembly as a physical file. TreatWarningsAsErrors = false, // Don't treat warnings as errors. IncludeDebugInformation = true // Include debug information }; TL.LogMessage("CreateAlpacaClient", "Created compiler parameters"); // Add required assembly references to make sure the compilation succeeds cp.ReferencedAssemblies.Add(@"ASCOM.Attributes.dll"); // Must be present in the current directory because the compiler doesn't use the GAC cp.ReferencedAssemblies.Add(@"ASCOM.DeviceInterfaces.dll"); // Must be present in the current directory because the compiler doesn't use the GAC cp.ReferencedAssemblies.Add(@"ASCOM.Newtonsoft.Json.dll"); // Must be present in the current directory because the compiler doesn't use the GAC cp.ReferencedAssemblies.Add(@"RestSharp.dll"); // Must be present in the current directory cp.ReferencedAssemblies.Add(@"ASCOM.AlpacaClientDeviceBaseClasses.dll"); // Must be present in the current directory cp.ReferencedAssemblies.Add(SharedConstants.ALPACA_CLIENT_LOCAL_SERVER); // Must be present in the current directory Assembly executingAssembly = Assembly.GetExecutingAssembly(); cp.ReferencedAssemblies.Add(executingAssembly.Location); foreach (AssemblyName assemblyName in executingAssembly.GetReferencedAssemblies()) { cp.ReferencedAssemblies.Add(Assembly.Load(assemblyName).Location); } TL.LogMessage("CreateAlpacaClient", "Added assembly references"); // Create formatting options for the generated code that will be logged into the trace logger CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions() { BracingStyle = "C", IndentString = " ", VerbatimOrder = true, BlankLinesBetweenMembers = false }; // Get a code provider so that we can compile the program CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp"); TL.LogMessage("CreateAlpacaClient", "Created CSharp provider"); // Write the generated code to the trace logger using (MemoryStream outputStream = new MemoryStream()) { using (StreamWriter writer = new StreamWriter(outputStream)) { provider.GenerateCodeFromNamespace(ns, writer, codeGeneratorOptions); } MemoryStream actualStream = new MemoryStream(outputStream.ToArray()); using (StreamReader reader = new StreamReader(actualStream)) { do { TL.LogMessage("GeneratedCode", reader.ReadLine()); } while (!reader.EndOfStream); } } provider.Dispose(); // Compile the source contained in the "program" variable CompilerResults cr = provider.CompileAssemblyFromDom(cp, program); TL.LogMessage("CreateAlpacaClient", string.Format("Compiled assembly - {0} errors", cr.Errors.Count)); // Report success or errors if (cr.Errors.Count > 0) { // Display compilation errors. foreach (CompilerError ce in cr.Errors) { TL.LogMessage("CreateAlpacaClient", string.Format("Compiler error: {0}", ce.ToString())); } } else { // Display a successful compilation message. TL.LogMessage("CreateAlpacaClient", "Assembly compiled OK!"); } TL.BlankLine(); } catch (Exception ex) { TL.LogMessageCrLf("CreateAlpacaClient", ex.ToString()); } }
public void GenerateCodeFromNamespace(CodeNamespace e, TextWriter w, CodeGeneratorOptions o) { provider.GenerateCodeFromNamespace(e, w, o); }