public MainForm() { // // The InitializeComponent() call is required for Windows Forms designer support. // InitializeComponent(); CodeCompileUnit cu = GeneraCodigo(); CodeDomProvider dp = CodeDomProvider.CreateProvider("CSharp"); //Imprimir el código StringWriter sw = new StringWriter(); System.CodeDom.Compiler.IndentedTextWriter itw = new IndentedTextWriter(sw); CodeGeneratorOptions go = new CodeGeneratorOptions(); go.BlankLinesBetweenMembers = false; dp.GenerateCodeFromCompileUnit(cu,sw,go); this.tbFuenteGenerado.Text = sw.ToString(); //Compilar desde dom CompilerParameters cp = new CompilerParameters(new string[]{},"borrame.dll"); CompilerResults cr = dp.CompileAssemblyFromDom(cp,cu); tbErrores.Text = ""; foreach(CompilerError ce in cr.Errors){ tbErrores.Text += String.Format("{0}){1} in {2} at line {3} column {4} isWarning{5}",ce.ErrorNumber,ce.ErrorText,ce.FileName,ce.Line,ce.Column,ce.IsWarning); } }
public void Deny_Unrestricted () { VBCodeProvider vbprov = new VBCodeProvider (); Assert.AreEqual ("vb", vbprov.FileExtension, "FileExtension"); Assert.AreEqual (LanguageOptions.CaseInsensitive, vbprov.LanguageOptions, "LanguageOptions"); Assert.IsNotNull (vbprov.CreateCompiler (), "CreateCompiler"); Assert.IsNotNull (vbprov.CreateGenerator (), "CreateGenerator"); try { Assert.IsNotNull (vbprov.GetConverter (typeof (string)), "GetConverter"); } catch (NotImplementedException) { // mono } #if NET_2_0 CodeTypeMember ctm = new CodeTypeMember (); StringWriter sw = new StringWriter (); CodeGeneratorOptions cgo = new CodeGeneratorOptions (); try { vbprov.GenerateCodeFromMember (ctm, sw, cgo); } catch (NotImplementedException) { // mono } #endif }
public void Build(DataStructure dataStructure, string rendererFilename = "") { if (string.IsNullOrEmpty(rendererFilename)) { rendererFilename = this.GetFilename(dataStructure); } var rendererType = new CodeTypeDeclaration(dataStructure.RendererName); rendererType.IsClass = true; rendererType.IsPartial = true; rendererType.BaseTypes.Add(typeof(Renderer)); rendererType.Comments.Add(new CodeCommentStatement("<summary>", true)); rendererType.Comments.Add(new CodeCommentStatement(string.Format("Renderer of {0}", dataStructure.TargetName), true)); rendererType.Comments.Add(new CodeCommentStatement("</summary>", true)); BuildCreate(rendererType, dataStructure); BuildConstructor(rendererType, dataStructure); BuildDoInitialize(rendererType, dataStructure); BuildDoRender(rendererType, dataStructure); var parserNamespace = new CodeNamespace("CSharpGL"); parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Object).Namespace)); parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Collections.Generic.List<int>).Namespace)); parserNamespace.Types.Add(rendererType); //生成代码 using (var stream = new StreamWriter(rendererFilename, false)) { CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions opentions = new CodeGeneratorOptions();//代码生成选项 opentions.BlankLinesBetweenMembers = true; opentions.BracingStyle = "C"; opentions.ElseOnClosing = false; opentions.IndentString = " "; opentions.VerbatimOrder = true; codeProvider.GenerateCodeFromNamespace(parserNamespace, stream, opentions); } }
public TypescriptSnippetTypeMember( CodeSnippetTypeMember member, CodeGeneratorOptions options) { _member = member; _options = options; }
public void Nullify () { CodeGeneratorOptions cgo = new CodeGeneratorOptions (); cgo.BlankLinesBetweenMembers = false; Assert.IsFalse (cgo.BlankLinesBetweenMembers, "BlankLinesBetweenMembers-1"); cgo["BlankLinesBetweenMembers"] = null; Assert.IsTrue (cgo.BlankLinesBetweenMembers, "BlankLinesBetweenMembers-2"); cgo.BracingStyle = "C"; Assert.AreEqual ("C", cgo.BracingStyle, "BracingStyle-1"); cgo["BracingStyle"] = null; Assert.AreEqual ("Block", cgo.BracingStyle, "BracingStyle-2"); cgo.ElseOnClosing = true; Assert.IsTrue (cgo.ElseOnClosing, "ElseOnClosing-1"); cgo["ElseOnClosing"] = null; Assert.IsFalse (cgo.ElseOnClosing, "ElseOnClosing-2"); cgo.IndentString = "\t"; Assert.AreEqual ("\t", cgo.IndentString, "IndentString-1"); cgo["IndentString"] = null; Assert.AreEqual (" ", cgo.IndentString, "IndentString-2"); cgo.VerbatimOrder = true; Assert.IsTrue (cgo.VerbatimOrder, "VerbatimOrder-1"); cgo["VerbatimOrder"] = null; Assert.IsFalse (cgo.VerbatimOrder, "VerbatimOrder-2"); }
private void GenerateCS() { using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider()) { CodeGeneratorOptions opts = new CodeGeneratorOptions(); StringWriter sw = new StringWriter(); provider.GenerateCodeFromMember(_method, sw, opts); StringReader sr = new StringReader(sw.GetStringBuilder().ToString()); string line = sr.ReadLine(); while (string.IsNullOrEmpty(line)) line = sr.ReadLine(); int idx = line.IndexOf(" " + _method.Name + "("); idx = line.LastIndexOf(' ', idx - 1); if (_method.Statements.Count > 0) { Text = "partial" + line.Remove(0, idx); Text = sw.GetStringBuilder().Replace(line, Text).ToString(); } else { line = "partial" + line.Remove(0, idx); idx = line.LastIndexOf(')'); Text = line.Remove(idx + 1) + ";" + Environment.NewLine; } } }
public GeneratorResults ParseToCode(string TemplateCode, string defaultnamespace, string defaultclassname, string baseClassFullName) { GeneratorResults razorResults; var host = new RazorEngineHost(new CSharpRazorCodeLanguage()); host.DefaultBaseClass = baseClassFullName;//typeof(BulaqTemplateForRazorBase).FullName; host.DefaultNamespace = defaultnamespace; host.DefaultClassName = defaultclassname; host.NamespaceImports.Add("System"); host.NamespaceImports.Add("BulaqCMS.Models"); host.GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral"); var engine = new RazorTemplateEngine(host); using (var reader = new StringReader(TemplateCode)) { razorResults = engine.GenerateCode(reader); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); options.BracingStyle = "C"; using (StringWriter writer = new StringWriter()) { IndentedTextWriter indentwriter = new IndentedTextWriter(writer, " "); codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, indentwriter, options); indentwriter.Flush(); indentwriter.Close(); LastGeneratedCode = writer.GetStringBuilder().ToString(); string codePath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\code.cs"; File.WriteAllText(codePath, LastGeneratedCode, Encoding.UTF8); } } return razorResults; }
private void GenerateCS() { IMemberOperatorGenerator gen = null; switch (Operator) { case OperatorType.Explicit: gen = new ExplicitOperatorGeneratorCS(); break; case OperatorType.Implicit: gen = new ImplicitOperatorGeneratorCS(); break; default: throw new NotImplementedException(string.Format("Какая-то несанкционированная xуйня")); } using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider()) { System.CodeDom.Compiler.CodeGeneratorOptions opts = new System.CodeDom.Compiler.CodeGeneratorOptions(); using (System.CodeDom.Compiler.IndentedTextWriter tw = new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(), opts.IndentString)) { gen.GenerateDeclaration(tw, provider, opts, ReturnType, Parameters); tw.WriteLine("{"); tw.Indent++; gen.GenerateStatemets(tw, provider, opts, Statements); tw.Indent--; tw.WriteLine("}"); Text = tw.InnerWriter.ToString(); } } }
private void GenerateHelper() { using (GenParamsForm gpf = new GenParamsForm()) { gpf.Namespace = _rootCategory.Name; if (gpf.ShowDialog(this) == DialogResult.OK) { CodeCompileUnit ccu = HelperGenerator.Generate(_rootCategory, gpf.Namespace, gpf.IsInternal); CSharpCodeProvider cscp = new CSharpCodeProvider(); CodeGeneratorOptions cgo = new CodeGeneratorOptions(); cgo.BracingStyle = "C"; using (StreamWriter sw = new StreamWriter( Path.Combine(_directory, _rootCategory.TreeName + ".cs"))) cscp.GenerateCodeFromCompileUnit(ccu, sw, cgo); if (gpf.ShowResult) using (ShowResultForm srf = new ShowResultForm()) using (StringWriter strW = new StringWriter()) { cscp.GenerateCodeFromCompileUnit(ccu, strW, cgo); srf.Result = strW.ToString(); srf.ShowDialog(this); } } } }
/// <summary> /// This method Parses and compiles the source code into an Assembly and returns it /// </summary> /// <param name="baseClassType">The Type of the Base class the generated class descends from</param> /// <param name="namespaceOfGeneratedClass">The Namespace of the generated class</param> /// <param name="generatedClassName">The Class Name of the generated class</param> /// <param name="sourceCodeReader">A Text reader that is a warpper around the "Template" that is to be parsed and compiled</param> /// <returns>An instance of a generated assembly that contains the generated class</returns> public Assembly ParseAndCompileTemplate(Type baseClassType, string namespaceOfGeneratedClass, string generatedClassName, TextReader sourceCodeReader) { RazorTemplateEngine engine = InitializeRazorEngine(baseClassType, namespaceOfGeneratedClass, generatedClassName); GeneratorResults razorResults = engine.GenerateCode(sourceCodeReader); CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); string generatedCode = null; using (StringWriter writer = new StringWriter()) { codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, writer, options); generatedCode = writer.GetStringBuilder().ToString(); } var outputAssemblyName = Path.GetTempPath() + Guid.NewGuid().ToString("N") + ".dll"; CompilerParameters compilerParameters = new CompilerParameters(new string[]{}, outputAssemblyName); compilerParameters.ReferencedAssemblies.Add("System.dll"); compilerParameters.ReferencedAssemblies.Add("System.Core.dll"); compilerParameters.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().CodeBase.Substring(8)); compilerParameters.GenerateInMemory = false; CompilerResults compilerResults = codeProvider.CompileAssemblyFromDom(compilerParameters, razorResults.GeneratedCode); if (compilerResults.Errors.Count > 0) { var compileErrors = new StringBuilder(); foreach (System.CodeDom.Compiler.CompilerError compileError in compilerResults.Errors) compileErrors.Append(String.Format("Line: {0}\t Col: {1}\t Error: {2}\r\n", compileError.Line, compileError.Column, compileError.ErrorText)); throw new Exception(compileErrors.ToString() + generatedCode); } return compilerResults.CompiledAssembly; }
/// <summary> /// Writes the code to the disk according to the given options. /// </summary> private void WriteCodeFiles() { // Ensure the output directory exist in the file system. EnsureDirectoryExists(options.OutputLocation); // Create the CodeGenerationOptions instance. codeGenerationOptions = CodeWriter.CreateCodeGeneratorOptions(); // Do we have to generate separate files? if (options.GenerateSeparateFiles) { // Write the code into separate files. WriteSeparateCodeFiles(); } else { // Write the code into a singl file. WriteSingleCodeFile(); } // Finally write the configuration file. if (configuration != null) { WriteConfigurationFile(); } WriteTextFiles(); }
public void CodeSnippetBlankLines () { var opt = new CodeGeneratorOptions () { BlankLinesBetweenMembers = false, VerbatimOrder = false }; var ccu = new CodeCompileUnit (); var ns = new CodeNamespace ("Foo"); ccu.Namespaces.Add (ns); var t = new CodeTypeDeclaration ("Bar"); ns.Types.Add (t); t.Members.Add (new CodeSnippetTypeMember ("#line hidden")); t.Members.Add (new CodeSnippetTypeMember ("#line hidden2")); t.Members.Add (new CodeMemberMethod () { Name = "Foo" }); using (var sw = new StringWriter ()) { new CSharpCodeProvider ().GenerateCodeFromCompileUnit (ccu, sw, opt); var str = sw.ToString (); Assert.IsFalse (str.Contains ("hidden2private"), "#0"); Assert.IsTrue (str.Contains( "#line hidden#line hidden2"), "#1"); } }
public string CreateSpecs(out int specCount) { var files = FindSpecFiles().ToArray(); specCount = files.Length; if (specCount < 1) return string.Empty; var compile = new CodeCompileUnit(); var globalns = new CodeNamespace(); globalns.Imports.Add(new CodeNamespaceImport("NUnit.Framework")); globalns.Imports.Add(new CodeNamespaceImport(config.MyNamespace)); compile.Namespaces.Add(globalns); var specNamespace = new CodeNamespace(config.TargetNamespace + ".ChutzpahSpecs"); compile.Namespaces.Add(specNamespace); foreach (var fileInfo in files) { AddSpec(specNamespace, fileInfo); } //specNamespace.Types.AddRange(files.Select(CreateSpec).ToArray()); var provider = CreateProvider(); var options = new CodeGeneratorOptions { BracingStyle = "C", BlankLinesBetweenMembers = false }; var stringBuilder = new StringBuilder(); using (var writer = new StringWriter(stringBuilder)) { provider.GenerateCodeFromCompileUnit(compile, writer, options); writer.Flush(); writer.Close(); } var result = stringBuilder.ToString(); return result; }
public override void GenerateCodeFromStatement(CodeStatement statement, TextWriter writer, CodeGeneratorOptions options) { var codeExpressionStatement = statement as CodeExpressionStatement; if (codeExpressionStatement != null) { var methodInvokeExpression = codeExpressionStatement.Expression as CodeMethodInvokeExpression; if (methodInvokeExpression != null) { if (methodInvokeExpression.Method.MethodName == "Write" && methodInvokeExpression.Parameters.Count == 1) { var parameter = methodInvokeExpression.Parameters[0] as CodeSnippetExpression; if ((parameter != null) && (!string.IsNullOrEmpty(parameter.Value))) { // Appears to be a candidate for rewriting string originalValue = parameter.Value; var processor = SnippetModifiers.OfType<ICodeSnippetTextModifier>() .FirstOrDefault(m => m.CanProcessString(originalValue)); if (processor != null) originalValue = processor.ProcessString(originalValue); parameter.Value = "global::" + GetType().FullName + ".PreProcessObject(this, " + originalValue + ")"; } } } } base.GenerateCodeFromStatement(statement, writer, options); }
public override string CreateContent (Project project, Dictionary<string, string> tags, string language) { if (language == null || language == "") throw new InvalidOperationException ("Language not defined in CodeDom based template."); var binding = GetLanguageBinding (language); CodeDomProvider provider = null; if (binding != null) provider = binding.GetCodeDomProvider (); if (provider == null) throw new InvalidOperationException ("The language '" + language + "' does not have support for CodeDom."); var xcd = new XmlCodeDomReader (); var cu = xcd.ReadCompileUnit (domContent); foreach (CodeNamespace cns in cu.Namespaces) cns.Name = StripImplicitNamespace (project, tags, cns.Name); CodeGeneratorOptions options = new CodeGeneratorOptions (); options.IndentString = "\t"; options.BracingStyle = "C"; StringWriter sw = new StringWriter (); provider.GenerateCodeFromCompileUnit (cu, sw, options); sw.Close (); return StripHeaderAndBlankLines (sw.ToString (), provider); }
public override SyntaxTree GetSyntaxTree(string sourcePath, Stream sourceStream) { try { var viewFullPath = sourcePath; var viewVirtualPath = GetRelativeUri(sourcePath, Compilation.CurrentDirectory.FullName); var viewConfig = WebConfigurationManager.OpenMappedWebConfiguration(_configMap, viewVirtualPath); var razorConfig = viewConfig.GetSectionGroup("system.web.webPages.razor") as RazorWebSectionGroup; var host = razorConfig == null ? WebRazorHostFactory.CreateDefaultHost(viewVirtualPath, viewFullPath) : WebRazorHostFactory.CreateHostFromConfig(razorConfig, viewVirtualPath, viewFullPath); using (var rdr = new StreamReader(sourceStream, Compilation.Encoding, detectEncodingFromByteOrderMarks: true)) using (var provider = CodeDomProvider.CreateProvider("csharp")) using (var generatedStream = new MemoryStream()) using (var generatedWriter = new StreamWriter(generatedStream, Compilation.Encoding)) { var engine = new RazorTemplateEngine(host); var razorOut = engine.GenerateCode(rdr, null, null, viewFullPath); var codeGenOptions = new CodeGeneratorOptions { VerbatimOrder = true, ElseOnClosing = false, BlankLinesBetweenMembers = false }; provider.GenerateCodeFromCompileUnit(razorOut.GeneratedCode, generatedWriter, codeGenOptions); // rewind generatedWriter.Flush(); generatedStream.Position = 0; return base.GetSyntaxTree(sourcePath, generatedStream); } } catch (Exception ex) { Compilation.Diagnostics.Add(Diagnostic.Create(Compilation.ViewGenerationFailed, Compilation.AsLocation(sourcePath), ex.ToString())); return null; } }
public void Write(TranslateAttribute attr, string pathName) { using (var writer = new StreamWriter(pathName, false)) { var options = new CodeGeneratorOptions { BracingStyle = "C", IndentString = "\t", }; var codeNamespace = new CodeNamespace(attr.SourceType.Namespace); codeNamespace.Imports.Add(new CodeNamespaceImport("System")); codeNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); var declaration = DeclareType(attr.SourceType); codeNamespace.Types.Add(declaration); declaration.Members.Add(ConvertToTargetMethod(attr)); declaration.Members.Add(ConvertToTargetsMethod(attr)); declaration.Members.Add(UpdateTargetMethod(attr)); declaration.Members.Add(ConvertToSourceMethod(attr)); declaration.Members.Add(ConvertToSourcesMethod(attr)); generator.GenerateCodeFromNamespace(codeNamespace, writer, options); } }
/// <summary> /// Generates code from the specified <paramref name="constructor"/>. /// </summary> /// <param name="constructor">Class constructor for which code needs to be generated.</param> /// <param name="type">Type declaration.</param> /// <param name="namespace">Namespace declaration.</param> /// <param name="options">Code generation options.</param> /// <remarks> /// This method is a workaround for <see cref="CodeDomProvider.GenerateCodeFromMember"/> /// not generating constructors properly. /// </remarks> private void GenerateCodeFromConstructor( CodeConstructor constructor, CodeTypeDeclaration type, CodeNamespace @namespace, CodeGeneratorOptions options) { const string StartMarker = "___startMarker___"; const string EndMarker = "___endMarker___"; // Insert marker fields around the target constructor int indexOfMember = type.Members.IndexOf(constructor); type.Members.Insert(indexOfMember + 1, new CodeMemberField(typeof(int), EndMarker)); type.Members.Insert(indexOfMember, new CodeMemberField(typeof(int), StartMarker)); using (StringWriter buffer = new StringWriter(CultureInfo.InvariantCulture)) { // Generate type declaration in verbatim order to preserve placement of marker fields options = options ?? new CodeGeneratorOptions(); options.VerbatimOrder = true; this.LanguageProvider.GenerateCodeFromNamespace(@namespace, buffer, options); // Extract constructor code from the generated type code const string ConstructorCode = "constructor"; Regex regex = new Regex( @"^[^\r\n]*" + StartMarker + @"[^\n]*$" + @"(?<" + ConstructorCode + @">.*)" + @"^[^\r\n]*" + EndMarker + @"[^\n]*$", RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.ExplicitCapture); string code = regex.Match(buffer.ToString()).Groups[ConstructorCode].Value; // Write constructor code to the output buffer this.ClassCode.Write(code); } }
public static string CreatePublicApiForAssembly(Assembly assembly) { var publicApiBuilder = new StringBuilder(); var cgo = new CodeGeneratorOptions { BracingStyle = "C", BlankLinesBetweenMembers = false }; using (var provider = new CSharpCodeProvider()) { var publicTypes = assembly.GetTypes() .Where(t => t.IsPublic && t.Name != "GeneratedInternalTypeHelper") //GeneratedInternalTypeHelper seems to be a r# runner side effect .OrderBy(t => t.FullName); foreach (var publicType in publicTypes) { var writer = new StringWriter(); var genClass = CreateClassDeclaration(publicType); foreach (var memberInfo in publicType.GetMembers().Where(m => !IsDotNetTypeMember(m)).OrderBy(m => m.Name)) { AddMemberToClassDefinition(genClass, memberInfo); } provider.GenerateCodeFromType(genClass, writer, cgo); var gennedClass = GenerateClassCode(writer); publicApiBuilder.AppendLine(gennedClass); } } var publicApi = publicApiBuilder.ToString(); return publicApi.Trim(); }
/// <summary> /// Generates CSharp text from a compile unit and writes it to a text writer with the given options. /// </summary> /// <param name="compileUnit">The compile unit to generate text from.</param> /// <param name="writer">The text writer to write to.</param> /// <param name="options">The generation options.</param> public static void GenerateCSharpTo(this CodeCompileUnit compileUnit, TextWriter writer, CodeGeneratorOptions options) { using (var provider = new CSharpCodeProvider()) { provider.GenerateCodeFromCompileUnit(compileUnit, writer, options); } }
static void Main(string[] args) { // 输出所有支持生成代码的语言 foreach (CompilerInfo ci in CodeDomProvider.GetAllCompilerInfo()) { foreach (var language in ci.GetLanguages()) { Console.Write("{0} ", language); } Console.WriteLine(); } CodeNamespace prgNamespace = BuildProgram(); var compilerOptions = new CodeGeneratorOptions() { IndentString = " ", BracingStyle = "C", // 花括号的风格 BlankLinesBetweenMembers = false }; var codeText = new StringBuilder(); using (var codeWriter = new StringWriter(codeText)) { CodeDomProvider.CreateProvider("c#").GenerateCodeFromNamespace( prgNamespace, codeWriter, compilerOptions); } var script = codeText.ToString(); Console.WriteLine(script); Console.Read(); }
static void DumpToFile(string enumName, IEnumerable<string> names, int first) { // TODO: Необходимо задавать провайдер из параметров командной строки // по умолчанию брать Cpp провайдер var @enum = new CodeTypeDeclaration(enumName) { IsEnum = true, }; foreach(var name in names) { var field = new CodeMemberField(string.Empty, name) { InitExpression = new CodePrimitiveExpression(first), }; @enum.Members.Add(field); first++; } var codeProvider = CodeDomProvider.CreateProvider("CSharp"); var options = new CodeGeneratorOptions { BlankLinesBetweenMembers = false, BracingStyle = "C", }; using(var writer = new StreamWriter(enumName + "." + codeProvider.FileExtension)) { codeProvider.GenerateCodeFromType(@enum, writer, options); } }
public void Build(DataStructure dataStructure, string modelFilename = "") { if (string.IsNullOrEmpty(modelFilename)) { modelFilename = this.GetFilename(dataStructure); } // public class DemoModel : IBufferable { } var modelType = new CodeTypeDeclaration(dataStructure.ModelName); modelType.IsClass = true; modelType.IsPartial = true; modelType.BaseTypes.Add(typeof(IBufferable)); modelType.Comments.Add(new CodeCommentStatement("<summary>", true)); modelType.Comments.Add(new CodeCommentStatement(string.Format("Model of {0}", dataStructure.TargetName), true)); modelType.Comments.Add(new CodeCommentStatement("</summary>", true)); BuildFields(modelType, dataStructure); BuildGetVertexAttributeBuffer(modelType, dataStructure); BuildGetIndex(modelType, dataStructure); var parserNamespace = new CodeNamespace("CSharpGL"); parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Object).Namespace)); parserNamespace.Imports.Add(new CodeNamespaceImport(typeof(System.Collections.Generic.List<int>).Namespace)); parserNamespace.Types.Add(modelType); //生成代码 using (var stream = new StreamWriter(modelFilename, false)) { CSharpCodeProvider codeProvider = new CSharpCodeProvider(); CodeGeneratorOptions opentions = new CodeGeneratorOptions();//代码生成选项 opentions.BlankLinesBetweenMembers = true; opentions.BracingStyle = "C"; opentions.ElseOnClosing = false; opentions.IndentString = " "; opentions.VerbatimOrder = true; codeProvider.GenerateCodeFromNamespace(parserNamespace, stream, opentions); } }
/// <summary> /// Generate the actual code to the given writer. /// </summary> public void Generate(TextWriter writer) { var provider = CodeDomProvider.CreateProvider("CSharp"); var options = new CodeGeneratorOptions { BracingStyle = "C" }; provider.GenerateCodeFromCompileUnit(codeCompileUnit, writer, options); writer.Flush(); }
private static void GenerateCSharpCode(Entity entity, string path) { var targetUnit = new CodeCompileUnit(); var targetNamespace = new CodeNamespace(entity.FullName.Substring(0, entity.FullName.LastIndexOf('.'))); targetNamespace.Imports.Add(new CodeNamespaceImport("System")); var targetClass = new CodeTypeDeclaration(entity.FullName.Substring(entity.FullName.LastIndexOf('.') + 1)) { IsClass = true, IsPartial = true, TypeAttributes = TypeAttributes.Public }; targetNamespace.Types.Add(targetClass); targetUnit.Namespaces.Add(targetNamespace); foreach (var property in entity.Properties) { CodeTypeReference propertyType; if (property.IsNavigable) { propertyType = new CodeTypeReference(typeof(List<>)); propertyType.TypeArguments.Add((string)RemapTypeForCSharp(property.Type)); } else { propertyType = new CodeTypeReference(RemapTypeForCSharp(property.Type)); } var backingField = new CodeMemberField(propertyType, "_" + property.Name) {Attributes = MemberAttributes.Private}; if (property.IsNavigable) backingField.InitExpression = new CodeObjectCreateExpression(propertyType); targetClass.Members.Add(backingField); var codeProperty = new CodeMemberProperty { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = property.Name, HasGet = true, HasSet = true, Type = propertyType, }; codeProperty.GetStatements.Add(new CodeMethodReturnStatement( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), backingField.Name))); codeProperty.SetStatements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), backingField.Name), new CodeVariableReferenceExpression("value"))); targetClass.Members.Add(codeProperty); } var provider = CodeDomProvider.CreateProvider("CSharp"); var options = new CodeGeneratorOptions {BracingStyle = "C"}; using (var writer = new StreamWriter(Path.Combine(path, entity.FullName + '.' + provider.FileExtension))) { provider.GenerateCodeFromCompileUnit(targetUnit, writer, options); } }
public IExpression GetExpression(CodeExpression expression, CodeGeneratorOptions options) { if (expression==null) { throw new ArgumentNullException("expression"); } return _expressionMap[expression.GetType()](expression, options); }
public override string GetClassCodeForProcessingRun () { var options = new CodeGeneratorOptions (); using (var sw = new StringWriter ()) { GenerateCodeFromMembers (sw, options); return Indent (sw.ToString (), " "); } }
private static void WriteCSharpCodeFile(CodeNamespace code, string outputFileName) { CSharpCodeProvider provider = new CSharpCodeProvider(); CodeGeneratorOptions options = new CodeGeneratorOptions(); using (StreamWriter writer = new StreamWriter(outputFileName, false)) provider.GenerateCodeFromNamespace(code, writer, options); }
public TypescriptThisReferenceExpression( CodeThisReferenceExpression codeExpression, CodeGeneratorOptions options) { _codeExpression = codeExpression; _options = options; System.Diagnostics.Debug.WriteLine("TypescriptThisReferenceExpression Created"); }
private void GenerateCS() { using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider()) { CodeGeneratorOptions opts = new CodeGeneratorOptions(); StringWriter sw = new StringWriter(); List<CodeTypeReference> implTypes = new List<CodeTypeReference>(); if (_property.ImplementationTypes != null) { var arr = new CodeTypeReference[_property.ImplementationTypes.Count]; _property.ImplementationTypes.CopyTo(arr, 0); _property.ImplementationTypes.Clear(); _property.PrivateImplementationType = null; implTypes.AddRange(arr); } provider.GenerateCodeFromMember(_property, sw, opts); foreach (CodeTypeReference tr in implTypes) { _property.ImplementationTypes.Add(tr); } //StringReader sr = new StringReader(sw.GetStringBuilder().ToString()); //string line = sr.ReadLine(); //while (string.IsNullOrEmpty(line) || line.StartsWith("/") || line.StartsWith("[")) // line = sr.ReadLine(); StringBuilder sb = new StringBuilder(); if (InterfaceProperties != null) { foreach (CodeTypeReference tr in implTypes) { string prop; if (InterfaceProperties.TryGetValue(tr, out prop)) { var newProp = Define.Property(_property.Type, MemberAttributes.Private, prop).Implements(tr); if (_property.HasGet) { newProp.GetStatements.Add(Emit.@return(()=>[email protected](_property.Name))); newProp.HasGet = true; } if (_property.HasSet) { newProp.SetStatements.Add(Emit.assignProperty(_property.Name, () => CodeDom.VarRef("value"))); newProp.HasSet = true; } StringWriter swNew = new StringWriter(); provider.GenerateCodeFromMember(CodeDomTreeProcessor.ProcessMember(newProp, CodeDomGenerator.Language.CSharp), swNew, opts); sb.Append(swNew.ToString()); } } if (sb.Length > 0) sb.Insert(0, Environment.NewLine); } Text = sw.GetStringBuilder().ToString() + sb.ToString(); } }
/// <summary> /// Initialize the static members of the Middle Tier Compiler. /// </summary> static MiddleTierCompiler() { // Initialize the object MiddleTierCompiler.codeProvider = CodeDomProvider.CreateProvider("C#"); MiddleTierCompiler.codeGeneratorOptions = new CodeGeneratorOptions(); MiddleTierCompiler.codeGeneratorOptions.BlankLinesBetweenMembers = true; MiddleTierCompiler.codeGeneratorOptions.BracingStyle = "C"; MiddleTierCompiler.codeGeneratorOptions.IndentString = "\t"; }
public static CodeGeneratorOptions getCodeGeneratorOptions() { CodeGeneratorOptions genOptions = new CodeGeneratorOptions(); genOptions.BracingStyle = "C"; //Brackets start on the next line, set to "Block" for the same line genOptions.BlankLinesBetweenMembers = true; //True by default but let's be certain... genOptions.IndentString = " "; //The amount of indenting we want to apply to the code genOptions.VerbatimOrder = true; //Output code in the order we've processed it return genOptions; }
private static void GenerateViaCodeDOM(string outputFileName, System.CodeDom.Compiler.CodeDomProvider provider, System.CodeDom.CodeCompileUnit compileUnit) { System.CodeDom.Compiler.ICodeGenerator gen = provider.CreateGenerator(); System.CodeDom.Compiler.IndentedTextWriter tw; tw = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFileName, false), " "); System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions(); options.BracingStyle = "C"; gen.GenerateCodeFromCompileUnit(compileUnit, tw, options); tw.Flush(); tw.Close(); }
internal static void GenerateCode(ITextTemplatingEngineHost host, string content, string namespac, string name, TextWriter writer) { ParsedTemplate pt = ParsedTemplate.FromText(content, host); if (pt.Errors.HasErrors) { host.LogErrors(pt.Errors); return; } TemplateSettings settings = TemplatingEngine.GetSettings(host, pt); if (name != null) { settings.Name = name; } if (namespac != null) { settings.Namespace = namespac; } if (pt.Errors.HasErrors) { host.LogErrors(pt.Errors); return; } var ccu = TemplatingEngine.GenerateCompileUnit(host, pt, settings); if (pt.Errors.HasErrors) { host.LogErrors(pt.Errors); return; } var opts = new System.CodeDom.Compiler.CodeGeneratorOptions(); settings.Provider.GenerateCodeFromCompileUnit(ccu, writer, opts); }
string GenerateCode(ITextTemplatingEngineHost host, string content, string name, string generatorNewline) { ParsedTemplate pt = ParsedTemplate.FromText(content, host); if (pt.Errors.HasErrors) { host.LogErrors(pt.Errors); return(null); } TemplateSettings settings = TemplatingEngine.GetSettings(host, pt); if (name != null) { settings.Namespace = name; } if (pt.Errors.HasErrors) { host.LogErrors(pt.Errors); return(null); } var ccu = TemplatingEngine.GenerateCompileUnit(host, content, pt, settings); if (pt.Errors.HasErrors) { host.LogErrors(pt.Errors); return(null); } var opts = new System.CodeDom.Compiler.CodeGeneratorOptions(); using (var writer = new System.IO.StringWriter()) { writer.NewLine = generatorNewline; settings.Provider.GenerateCodeFromCompileUnit(ccu, writer, opts); return(writer.ToString()); } }
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromStatement(System.CodeDom.CodeStatement e, TextWriter w, CodeGeneratorOptions o) { }
/// <devdoc> /// <para> /// Outputs the language specific representaion of the CodeDom tree /// refered to by codeNamespace, into writer. /// </para> /// </devdoc> public virtual void GenerateCodeFromNamespace(CodeNamespace codeNamespace, TextWriter writer, CodeGeneratorOptions options) { CreateGeneratorHelper().GenerateCodeFromNamespace(codeNamespace, writer, options); }
void ICodeGenerator.GenerateCodeFromCompileUnit(CodeCompileUnit e, TextWriter w, CodeGeneratorOptions o) { throw new NotImplementedException(); }
void ICodeGenerator.GenerateCodeFromType(CodeTypeDeclaration e, TextWriter w, CodeGeneratorOptions o) { throw new NotImplementedException(); }
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromExpression(System.CodeDom.CodeExpression e, TextWriter w, CodeGeneratorOptions o) { }
public virtual void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) { // Documented to always throw an exception (if not overriden) throw GetNotImplemented(); // Note: the pattern is different from other GenerateCodeFrom* because // ICodeGenerator doesn't have a GenerateCodeFromMember member }
public virtual void GenerateCodeFromNamespace(CodeNamespace codeNamespace, TextWriter writer, CodeGeneratorOptions options) { ICodeGenerator cg = CreateGenerator(); if (cg == null) { throw GetNotImplemented(); } cg.GenerateCodeFromNamespace(codeNamespace, writer, options); }
public virtual void GenerateCodeFromStatement(CodeStatement statement, TextWriter writer, CodeGeneratorOptions options) { ICodeGenerator cg = CreateGenerator(); if (cg == null) { throw GetNotImplemented(); } cg.GenerateCodeFromStatement(statement, writer, options); }
public virtual void GenerateCodeFromType(CodeTypeDeclaration codeType, TextWriter writer, CodeGeneratorOptions options) { ICodeGenerator cg = CreateGenerator(); if (cg == null) { throw GetNotImplemented(); } cg.GenerateCodeFromType(codeType, writer, options); }
/// <devdoc> /// <para> /// Generates code from the specified expression and /// outputs it to the specified textwriter. /// </para> /// </devdoc> public virtual void GenerateCodeFromExpression(CodeExpression expression, TextWriter writer, CodeGeneratorOptions options) { CreateGeneratorHelper().GenerateCodeFromExpression(expression, writer, options); }
/// <devdoc> /// <para> /// Outputs the language specific representaion of the CodeDom tree /// refered to by statement, into writer. /// </para> /// </devdoc> public virtual void GenerateCodeFromStatement(CodeStatement statement, TextWriter writer, CodeGeneratorOptions options) { CreateGeneratorHelper().GenerateCodeFromStatement(statement, writer, options); }
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromNamespace(System.CodeDom.CodeNamespace e, TextWriter w, CodeGeneratorOptions o) { }
private static void GenerateCode(Options options) { var packageTransform = new NMF.Models.Meta.Meta2ClassesTransformation(); var stopWatch = new Stopwatch(); packageTransform.ForceGeneration = options.Force; packageTransform.CreateOperations = options.Operations; packageTransform.DefaultNamespace = options.OverallNamespace; Dictionary <Uri, string> mappings = null; if (options.NamespaceMappings != null && options.NamespaceMappings.Count > 0) { mappings = new Dictionary <Uri, string>(); foreach (var mapping in options.NamespaceMappings) { if (string.IsNullOrEmpty(mapping)) { continue; } var lastIdx = mapping.LastIndexOf('='); if (lastIdx == -1) { Console.WriteLine("Namespace mapping {0} is missing required separator =", mapping); continue; } Uri uri; if (!Uri.TryCreate(mapping.Substring(0, lastIdx), UriKind.Absolute, out uri)) { uri = new Uri(mapping.Substring(0, lastIdx), UriKind.Relative); } mappings.Add(uri, mapping.Substring(lastIdx + 1)); } } var metaPackage = LoadPackageFromFiles(options.InputFiles, options.OverallNamespace, mappings); if (options.Uri != null) { Uri uri; if (Uri.TryCreate(options.Uri, UriKind.Absolute, out uri)) { metaPackage.Uri = uri; } else { Console.Error.WriteLine("The provided string {0} could not be parsed as an absolute URI.", options.Uri); } } if (metaPackage.Uri == null) { Console.Error.WriteLine("Warning: There is no base Uri for the provided metamodels. Some features of the generated code will be disabled."); } var model = metaPackage.Model; if (model == null) { model = new Model(); model.RootElements.Add(metaPackage); } model.ModelUri = metaPackage.Uri; if (options.NMeta != null) { using (var fs = File.Create(options.NMeta)) { MetaRepository.Instance.Serializer.Serialize(model, fs); } } stopWatch.Start(); var compileUnit = TransformationEngine.Transform <INamespace, CodeCompileUnit>(metaPackage, options.Parallel ? (ITransformationEngineContext) new ParallelTransformationContext(packageTransform) : new TransformationContext(packageTransform)); stopWatch.Stop(); Console.WriteLine("Operation took {0}ms", stopWatch.Elapsed.TotalMilliseconds); CodeDomProvider generator = null; switch (options.Language) { case SupportedLanguage.CS: generator = new Microsoft.CSharp.CSharpCodeProvider(); break; case SupportedLanguage.VB: generator = new Microsoft.VisualBasic.VBCodeProvider(); break; case SupportedLanguage.CPP: generator = new Microsoft.VisualC.CppCodeProvider(); break; case SupportedLanguage.JS: generator = new Microsoft.JScript.JScriptCodeProvider(); break; default: Console.WriteLine("Unknown language detected. Falling back to default C#"); generator = new Microsoft.CSharp.CSharpCodeProvider(); break; } var genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions() { BlankLinesBetweenMembers = true, VerbatimOrder = false, ElseOnClosing = false, BracingStyle = "C", IndentString = " " }; if (options.UseFolders) { foreach (var file in MetaFacade.SplitCompileUnit(compileUnit)) { var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension); CheckDirectoryExists(fileInfo.Directory); using (var fs = fileInfo.Create()) { using (var sw = new StreamWriter(fs)) { generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions); } } } } else { using (var sw = new StreamWriter(options.OutputFile)) { generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions); } } Console.WriteLine("Code generated successfully!"); }
public virtual void GenerateCodeFromExpression(CodeExpression expression, TextWriter writer, CodeGeneratorOptions options) { ICodeGenerator cg = CreateGenerator(); if (cg == null) { throw GetNotImplemented(); } cg.GenerateCodeFromExpression(expression, writer, options); }
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromCompileUnit(System.CodeDom.CodeCompileUnit e, TextWriter w, CodeGeneratorOptions o) { }
public virtual new void GenerateCodeFromMember(System.CodeDom.CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) { }
public virtual void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) { throw new NotImplementedException(); }
/// <devdoc> /// <para> /// Outputs the language specific representaion of the CodeDom tree /// refered to by codeType, into writer. /// </para> /// </devdoc> public virtual void GenerateCodeFromType(CodeTypeDeclaration codeType, TextWriter writer, CodeGeneratorOptions options) { CreateGeneratorHelper().GenerateCodeFromType(codeType, writer, options); }
public virtual void GenerateCodeFromMember(CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options) { throw new NotImplementedException(SR.GetString(SR.NotSupported_CodeDomAPI)); }
void ICodeGenerator.GenerateCodeFromExpression(CodeExpression e, TextWriter w, CodeGeneratorOptions o) { throw new NotImplementedException(); }
void ICodeGenerator.GenerateCodeFromNamespace(CodeNamespace e, TextWriter w, CodeGeneratorOptions o) { throw new NotImplementedException(); }
public void GenerateProxyClass() { EndpointAddress metadataAddress = new EndpointAddress("http://localhost/Sofka.Automation.Dummy.Wcf/Loan.svc?wsdl"); //string = "http://localhost/Sofka.Automation.Dummy.Wcf/Loan.svc"; string outputFile = @"d:\dev\Sofka\Test\TempFiles"; MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress); mexClient.ResolveMetadataReferences = false; MetadataSet metaDocs = mexClient.GetMetadata(); WsdlImporter importer = new WsdlImporter(metaDocs); ServiceContractGenerator generator = new ServiceContractGenerator(); // Add our custom DCAnnotationSurrogate // to write XSD annotations into the comments. object dataContractImporter; XsdDataContractImporter xsdDCImporter; if (!importer.State.TryGetValue(typeof(XsdDataContractImporter), out dataContractImporter)) { Console.WriteLine("Couldn't find the XsdDataContractImporter! Adding custom importer."); xsdDCImporter = new XsdDataContractImporter(); xsdDCImporter.Options = new ImportOptions(); importer.State.Add(typeof(XsdDataContractImporter), xsdDCImporter); } else { xsdDCImporter = (XsdDataContractImporter)dataContractImporter; if (xsdDCImporter.Options == null) { Console.WriteLine("There were no ImportOptions on the importer."); xsdDCImporter.Options = new ImportOptions(); } } //xsdDCImporter.Options.DataContractSurrogate = new DCAnnotationSurrogate(); // Uncomment the following code if you are going to do your work programmatically rather than add // the WsdlDocumentationImporters through a configuration file. /* * // The following code inserts a custom WsdlImporter without removing the other * // importers already in the collection. * System.Collections.Generic.IEnumerable<IWsdlImportExtension> exts = importer.WsdlImportExtensions; * System.Collections.Generic.List<IWsdlImportExtension> newExts * = new System.Collections.Generic.List<IWsdlImportExtension>(); * foreach (IWsdlImportExtension ext in exts) * { * Console.WriteLine("Default WSDL import extensions: {0}", ext.GetType().Name); * newExts.Add(ext); * } * newExts.Add(new WsdlDocumentationImporter()); * System.Collections.Generic.IEnumerable<IPolicyImportExtension> polExts = importer.PolicyImportExtensions; * importer = new WsdlImporter(metaDocs, polExts, newExts); */ System.Collections.ObjectModel.Collection <ContractDescription> contracts = importer.ImportAllContracts(); importer.ImportAllEndpoints(); foreach (ContractDescription contract in contracts) { generator.GenerateServiceContractType(contract); } if (generator.Errors.Count != 0) { throw new Exception("There were errors during code compilation."); } // Write the code dom System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions(); options.BracingStyle = "C"; System.CodeDom.Compiler.CodeDomProvider codeDomProvider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("C#"); System.CodeDom.Compiler.IndentedTextWriter textWriter = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFile)); codeDomProvider.GenerateCodeFromCompileUnit( generator.TargetCompileUnit, textWriter, options ); textWriter.Close(); }
void System.CodeDom.Compiler.ICodeGenerator.GenerateCodeFromType(System.CodeDom.CodeTypeDeclaration e, TextWriter w, CodeGeneratorOptions o) { }
/// <devdoc> /// <para> /// Outputs the language specific representaion of the CodeDom tree /// refered to by compileUnit, into writer. /// </para> /// </devdoc> public virtual void GenerateCodeFromCompileUnit(CodeCompileUnit compileUnit, TextWriter writer, CodeGeneratorOptions options) { CreateGeneratorHelper().GenerateCodeFromCompileUnit(compileUnit, writer, options); }