public void Add() { var collection = new CodeNamespaceImportCollection(); var value = new CodeNamespaceImport(); collection.Add(value); Assert.Equal(1, collection.Count); Assert.Same(value, collection[0]); }
public void AddRange_CodeNamespaceArray_Works(CodeNamespaceImport[] value) { var collection = new CodeNamespaceImportCollection(); collection.AddRange(value); Assert.Equal(value.Length, collection.Count); for (int i = 0; i < value.Length; i++) { Assert.Same(value[i], collection[i]); } }
public void Add_SameNamespace_DoesntAdd() { var collection = new CodeNamespaceImportCollection(); var value1 = new CodeNamespaceImport("Namespace"); collection.Add(value1); collection.Add(value1); Assert.Equal(1, collection.Count); var value2 = new CodeNamespaceImport("Namespace"); collection.Add(value2); Assert.Equal(1, collection.Count); }
private void ValidateNamespaceImports(CodeNamespace e) { IEnumerator en = e.Imports.GetEnumerator(); while (en.MoveNext()) { CodeNamespaceImport imp = (CodeNamespaceImport)en.Current; if (imp.LinePragma != null) { ValidateLinePragmaStart(imp.LinePragma); } ValidateNamespaceImport(imp); } }
public void Imports_AddMultiple_ReturnsExpected() { var codeNamespace = new CodeNamespace(); CodeNamespaceImport type1 = new CodeNamespaceImport("Namespace1"); codeNamespace.Imports.Add(type1); Assert.Equal(new CodeNamespaceImport[] { type1 }, codeNamespace.Imports.Cast <CodeNamespaceImport>()); CodeNamespaceImport type2 = new CodeNamespaceImport("Namespace2"); codeNamespace.Imports.Add(type2); Assert.Equal(new CodeNamespaceImport[] { type1, type2 }, codeNamespace.Imports.Cast <CodeNamespaceImport>()); }
private CodeGenUtil() { if (CodeGen.DoJava) { NamespaceImports = new CodeNamespaceImport[] { new CodeNamespaceImport("java.util"), new CodeNamespaceImport("org.apache.avro"), new CodeNamespaceImport("org.apache.avro.specific"), }; } else { NamespaceImports = new CodeNamespaceImport[] { new CodeNamespaceImport("System"), new CodeNamespaceImport("System.Collections.Generic"), new CodeNamespaceImport("System.Text"), new CodeNamespaceImport("Avro"), new CodeNamespaceImport("Avro.Specific") }; } FileComment = new CodeCommentStatement( @"------------------------------------------------------------------------------ <auto-generated> Generated by " + System.AppDomain.CurrentDomain.FriendlyName + ", version " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version + @" Changes to this file may cause incorrect behavior and will be lost if code is regenerated </auto-generated> ------------------------------------------------------------------------------"); // Visual Studio 2010 http://msdn.microsoft.com/en-us/library/x53a06bb.aspx ReservedKeywords = new HashSet <string>() { "abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char", "checked", "class", "const", "continue", "decimal", "default", "delegate", "do", "double", "else", "enum", "event", "explicit", "extern", "false", "finally", "fixed", "float", "for", "foreach", "goto", "if", "implicit", "in", "int", "interface", "internal", "is", "lock", "long", "namespace", "new", "null", "object", "operator", "out", "override", "params", "private", "protected", "public", "readonly", "ref", "return", "sbyte", "sealed", "short", "sizeof", "stackalloc", "static", "string", "struct", "switch", "this", "throw", "true", "try", "typeof", "uint", "ulong", "unchecked", "unsafe", "ushort", "using", "virtual", "void", "volatile", "while", "value", "partial" }; if (CodeGen.DoJava) { ReservedKeywords.Remove("long"); } }
public void Process() { CodeCompileUnit unit = new CodeCompileUnit(); CodeNamespace codeNamespace = new CodeNamespace("MyTest"); CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp"); CodeNamespaceImport import = new CodeNamespaceImport("System"); codeNamespace.Imports.Add(import); unit.Namespaces.Add(codeNamespace); CodeTypeDeclaration myObject = new CodeTypeDeclaration("Headset"); codeNamespace.Types.Add(myObject); CodeMemberField name = new CodeMemberField(typeof(String), "Name"); name.Attributes = MemberAttributes.Public; myObject.Members.Add(name); CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; constructor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(String), "name")); myObject.Members.Add(constructor); var codeExpression = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression("System.Console"), "WriteLine", new CodePrimitiveExpression("Let's get started") ); var codeExpression2 = new CodeAssignStatement( new CodeTypeReferenceExpression("Name"), new CodeTypeReferenceExpression("name") ); constructor.Statements.Add(codeExpression); constructor.Statements.Add(codeExpression2); using (var streamWriter = new StreamWriter("MyCode.cs")) { provider.GenerateCodeFromCompileUnit(unit, streamWriter, new CodeGeneratorOptions()); } }
public sealed override void GenerateCode(DeclarationArray array, StreamWriter writer) { IDeclaration[] declarations = array.Declarations; CodeCompileUnit unit = new CodeCompileUnit(); CodeNamespace codeNamespace = new CodeNamespace(); codeNamespace.Comments.Add(new CodeCommentStatement("扩展类型请使用partial关键字在其他文件扩展,否则更改可能会丢失。", false)); List <IDeclaration> declarations1 = new List <IDeclaration>(Predefines); declarations1.AddRange(declarations); foreach (IDeclaration declaration in declarations1) { switch (declaration) { case PackageDeclaration packageDeclaration: codeNamespace.Name = packageDeclaration.PackageName; break; case UsingDeclaration usingDeclaration: CodeNamespaceImport import = new CodeNamespaceImport(usingDeclaration.PackageName); codeNamespace.Imports.Add(import); break; case UsingAsDeclaration usingAsDeclaration: CodeNamespaceImport alias = new CodeNamespaceImport($"{usingAsDeclaration.AliasName} = {usingAsDeclaration.TypeName.RawString}"); codeNamespace.Imports.Add(alias); break; case StructDeclaration structDeclaration: CodeTypeDeclaration type = GetTypeDecalaration(structDeclaration); codeNamespace.Types.Add(type); break; } } unit.Namespaces.Add(codeNamespace); CodeDomProvider provider = CodeDomProvider.CreateProvider(LanguageName); CodeGeneratorOptions options = new CodeGeneratorOptions { BracingStyle = "C", BlankLinesBetweenMembers = true }; provider.GenerateCodeFromCompileUnit(unit, writer, options); }
private CodeNamespace GenerateNamespace() { CodeNamespace ns = new CodeNamespace(dynamicObject.Namespace); // import system and SIM.Core CodeNamespaceImport system = new CodeNamespaceImport("System"); CodeNamespaceImport simCore = new CodeNamespaceImport("SIM.Core.Objects"); CodeNamespaceImport dataAnnotation = new CodeNamespaceImport("System.ComponentModel.DataAnnotations"); ns.Imports.Add(system); ns.Imports.Add(simCore); ns.Imports.Add(dataAnnotation); // Add new namespace compileUnit.Namespaces.Add(ns); return ns; }
private void CreateTypeManager() { string rootClrNamespace = settings.GetClrNamespace(rootElementName.Namespace); var typeVisibility = settings.NamespaceTypesVisibilityMap.ValueForKey(rootClrNamespace); CodeNamespace rootCodeNamespace = null; if (!codeNamespacesTable.TryGetValue(rootClrNamespace, out rootCodeNamespace)) { //This might happen if the schema set has no global elements and only global types rootCodeNamespace = codeNamespacesTable.Values.FirstOrDefault(); //then you can create a root tag with xsi:type } if (rootCodeNamespace != null) { //It might be null if schema has only simple typed global elements or simple types which we are ignoring for now var typeManagerDeclaration = TypeBuilder.CreateTypeManager( rootElementName: rootElementName, enableServiceReference: settings.EnableServiceReference, typeDictionaryStatements: typeDictionaryAddStatements, elementDictionaryStatements: elementDictionaryAddStatements, wrapperDictionaryStatements: wrapperDictionaryAddStatements, visibility: typeVisibility); rootCodeNamespace.Types.Add(typeManagerDeclaration); //Add using statements in the rest of the namespaces for the root namespace to avoid error on TypeManager reference //Add using statements in the root namespace for the rest of the namespaces to avoid errors while building type dictionaries CodeNamespaceImport rootImport = new CodeNamespaceImport(rootCodeNamespace.Name); foreach (CodeNamespace cns in codeNamespacesTable.Values) { if (cns != rootCodeNamespace) { if (rootCodeNamespace.Name.Length > 0) { cns.Imports.Add(rootImport); } if (cns.Name.Length > 0) { rootCodeNamespace.Imports.Add(new CodeNamespaceImport(cns.Name)); } } } } }
public static void Main(string[] args) { var employeConstructor = new CodeConstructor(); var nameParameter = new CodeParameterDeclarationExpression(typeof(string), "name"); var salaryParameter = new CodeParameterDeclarationExpression(typeof(int), "salary"); var nameAssignStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("Name"), new CodeVariableReferenceExpression("name")); var salaryAssingStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("Salary"), new CodeVariableReferenceExpression("salary")); employeConstructor.Attributes = MemberAttributes.Public; employeConstructor.Parameters.Add(nameParameter); employeConstructor.Parameters.Add(salaryParameter); employeConstructor.Statements.Add(nameAssignStatement); employeConstructor.Statements.Add(salaryAssingStatement); var employeClass = new CodeTypeDeclaration("Employe"); var nameMemberField = new CodeMemberField(typeof(string), "Name"); var salaryMemberField = new CodeMemberField(typeof(int), "Salary"); salaryMemberField.Attributes = MemberAttributes.Public; nameMemberField.Attributes = MemberAttributes.Public; employeClass.Members.Add(employeConstructor); employeClass.Members.Add(nameMemberField); employeClass.Members.Add(salaryMemberField); var codeNamespace = new CodeNamespace("Section10.GeneratingCode"); var systemImport = new CodeNamespaceImport("System"); codeNamespace.Imports.Add(systemImport); codeNamespace.Types.Add(employeClass); var unit = new CodeCompileUnit(); unit.Namespaces.Add(codeNamespace); using var codeDomProvider = CodeDomProvider.CreateProvider("CSharp"); using var file = new StreamWriter("Employe.cs"); codeDomProvider.GenerateCodeFromCompileUnit(unit, file, null); Console.WriteLine("File was generated."); var employe = new Employe("Fernando", 100000); Console.WriteLine(employe.Name); Console.WriteLine(employe.Salary); }
public override string Build(IList <string> imports) { var builder = new StringBuilder(); using (var writer = new StringWriter(builder)) { var compileUnit = new CodeCompileUnit(); // Declares a namespace named TestNamespace. var testNamespace = new CodeNamespace(); //testNamespace.Name = "TempNHamlNamespace"; // Adds the namespace to the namespace collection of the compile unit. compileUnit.Namespaces.Add(testNamespace); foreach (var import in imports) { var namespaceImport = new CodeNamespaceImport(import); testNamespace.Imports.Add(namespaceImport); } var generator = CodeDomProvider.CreateGenerator(writer); var options = new CodeGeneratorOptions(); var declaration = new CodeTypeDeclaration { Name = ClassName, IsClass = true }; declaration.BaseTypes.Add(BaseType); declaration.Members.Add(RenderMethod); declaration.Members.AddRange(Members.ToArray()); // var codeNamespace = new CodeNamespace(); testNamespace.Types.Add(declaration); generator.GenerateCodeFromNamespace(testNamespace, writer, options); //TODO: implement IDisposable writer.Close(); } return(builder.ToString()); }
public static void Run(string[] args) { CodeCompileUnit codeCompileUnit = new CodeCompileUnit(); CodeNamespace codeNameSpace = new CodeNamespace("MyNamespace"); CodeNamespaceImport codeNamespaceImport = new CodeNamespaceImport("System"); CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration("MyClass"); CodeEntryPointMethod codeEntryPointMethod = new CodeEntryPointMethod(); CodeMethodInvokeExpression codeMethodInvokeExpression = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Test!") ); codeCompileUnit.Namespaces.Add(codeNameSpace); codeNameSpace.Imports.Add(codeNamespaceImport); codeNameSpace.Types.Add(codeTypeDeclaration); codeTypeDeclaration.Members.Add(codeEntryPointMethod); codeEntryPointMethod.Statements.Add(codeMethodInvokeExpression); }
private CodeNamespaceImport[] createUsingDependencies() { IList <CodeNamespaceImport> using_dependencies_list = new List <CodeNamespaceImport>(); IList <Slice> slice_list = BackEnd.sdao.listByInterface(id_abstract, id_interface); foreach (Slice s in slice_list) { InnerComponent ic = BackEnd.icdao.retrieve(s.Id_abstract, s.Id_inner); IList <string> package_list = fetchPackages(ic.Id_functor_app); foreach (string package in package_list) { CodeNamespaceImport using_dependency = new CodeNamespaceImport(package); using_dependencies_list.Add(using_dependency); } } CodeNamespaceImport[] using_dependencies = new CodeNamespaceImport[using_dependencies_list.Count]; using_dependencies_list.CopyTo(using_dependencies, 0); return(using_dependencies); }
private void configurationGenerate(string configurationFilePath, string tableName, SqlConnection conn) { CodeNamespaceImport[] lcnmSpace = new CodeNamespaceImport[7]; lcnmSpace[0] = new CodeNamespaceImport("System"); lcnmSpace[1] = new CodeNamespaceImport("System.Collections.Generic"); lcnmSpace[2] = new CodeNamespaceImport("System.Linq"); lcnmSpace[3] = new CodeNamespaceImport("System.Text"); lcnmSpace[4] = new CodeNamespaceImport("System.Data.Entity.ModelConfiguration"); lcnmSpace[5] = new CodeNamespaceImport("DXInfo.Models"); lcnmSpace[6] = new CodeNamespaceImport("System.ComponentModel.DataAnnotations.Schema"); string nmSpace = "DXInfo.Data.Configuration"; CodeTypeReference[] baseClass = new CodeTypeReference[1]; baseClass[0] = new CodeTypeReference("EntityTypeConfiguration<" + tableName + ">"); ConfigurationGenerate cg = new ConfigurationGenerate(lcnmSpace, nmSpace, tableName, tableStructSql, conn, tableName + "Configuration", baseClass, configurationFilePath); cg.AddConstructor(); cg.GenerateCSharpCode(); }
public static CodeNamespace GenerateFactoryClass(IClassMap classMap) { CodeNamespace domainNamespace = new CodeNamespace(classMap.DomainMap.RootNamespace + ".Factories"); CodeTypeDeclaration classDecl = new CodeTypeDeclaration(GetFactoryClassName(classMap)); CodeNamespaceImport import = new CodeNamespaceImport(classMap.GetFullNamespace()); CodeNamespaceImport importNPersist = new CodeNamespaceImport("Puzzle.NPersist.Framework"); domainNamespace.Imports.Add(import); domainNamespace.Imports.Add(importNPersist); classDecl.IsClass = true; GenerateConstructor(classDecl); GenerateContextField(classDecl); GenerateFactoryMethods(classMap, classDecl); domainNamespace.Types.Add(classDecl); return(domainNamespace); }
public void AddRange() { CodeNamespaceImport ni1 = new CodeNamespaceImport("A"); CodeNamespaceImport ni2 = new CodeNamespaceImport("B"); CodeNamespaceImport ni3 = new CodeNamespaceImport("b"); CodeNamespaceImport ni4 = new CodeNamespaceImport("B"); CodeNamespaceImport ni5 = new CodeNamespaceImport("C"); CodeNamespaceImportCollection coll = new CodeNamespaceImportCollection(); coll.AddRange(new CodeNamespaceImport[] { ni1, ni2 }); Assert.AreEqual(2, coll.Count, "#1"); Assert.AreEqual(0, ((IList)coll).IndexOf(ni1), "#2"); Assert.AreEqual(1, ((IList)coll).IndexOf(ni2), "#3"); coll.AddRange(new CodeNamespaceImport[] { ni3, ni4, ni5 }); Assert.AreEqual(3, coll.Count, "#4"); Assert.AreEqual(0, ((IList)coll).IndexOf(ni1), "#5"); Assert.AreEqual(1, ((IList)coll).IndexOf(ni2), "#6"); Assert.AreEqual(-1, ((IList)coll).IndexOf(ni3), "#7"); Assert.AreEqual(-1, ((IList)coll).IndexOf(ni4), "#8"); Assert.AreEqual(2, ((IList)coll).IndexOf(ni5), "#9"); }
protected virtual void BuildNamespace(CodeNamespace codeNamespace) { CodeTypeDeclaration codeType = new CodeTypeDeclaration { Name = GeneratedTypeName, IsClass = true }; foreach (ParsedValue <string> item in this.parser.Namespaces) { var import = new CodeNamespaceImport(item.Value); if (item.FileName != null) { import.LinePragma = new CodeLinePragma(item.FileName, item.LineNumber); } codeNamespace.Imports.Add(import); } BuildPageClass(codeType); codeNamespace.Types.Add(codeType); }
public CodeCompileUnit GenerateCompileUnit() { CodeCompileUnit compileUnit = new CodeCompileUnit(); foreach (var reference in ReferencedAssemblies) { compileUnit.ReferencedAssemblies.Add(reference); } currentNamespace.Imports.Clear(); var imports = new List <CodeNamespaceImport>(); foreach (var ns in NamespaceImports) { var cuNamespace = new CodeNamespaceImport(ns); imports.Add(cuNamespace); currentNamespace.Imports.Add(cuNamespace); } compileUnit.Namespaces.Add(currentNamespace); return(compileUnit); }
private void UomGenerate() { string dbContextFilePath = ConfigurationManager.AppSettings["UowFilePath"]; SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings[this.ConnectiongStringName].ConnectionString); conn.Open(); SqlCommand command = new SqlCommand(this.TableListSql, conn); SqlDataAdapter ad = new SqlDataAdapter(command); DataSet ds = new DataSet(); ad.Fill(ds); CodeNamespaceImport[] lcnmSpace = new CodeNamespaceImport[6]; lcnmSpace[0] = new CodeNamespaceImport("System"); lcnmSpace[1] = new CodeNamespaceImport("System.Collections.Generic"); lcnmSpace[2] = new CodeNamespaceImport("System.Linq"); lcnmSpace[3] = new CodeNamespaceImport("System.Text"); lcnmSpace[4] = new CodeNamespaceImport("DXInfo.Data.Contracts"); lcnmSpace[5] = new CodeNamespaceImport("DXInfo.Models"); string nmSpace = "DXInfo.Data"; CodeTypeReference[] baseClass = new CodeTypeReference[2]; baseClass[0] = new CodeTypeReference("Uow<" + this.ConnectiongStringName + "DbContext>"); baseClass[1] = new CodeTypeReference("I" + this.ConnectiongStringName + "Uow"); UowGenerate ug = new UowGenerate(lcnmSpace, nmSpace, this.ConnectiongStringName, baseClass, dbContextFilePath); ug.AddConstructor(); foreach (DataRow dr in ds.Tables[0].Rows) { string tableName = dr[0].ToString(); ug.AddProperty(tableName); } ug.GenerateCSharpCode(); }
/// <summary> /// Prevents a default instance of the <see cref="CodeGenUtil"/> class from being created. /// </summary> private CodeGenUtil() { NamespaceImports = new CodeNamespaceImport[] { new CodeNamespaceImport("System"), new CodeNamespaceImport("System.Collections.Generic"), new CodeNamespaceImport("System.Text"), new CodeNamespaceImport("global::Avro"), new CodeNamespaceImport("global::Avro.Specific") }; FileComment = new CodeCommentStatement( @"------------------------------------------------------------------------------ <auto-generated> Generated by " + System.AppDomain.CurrentDomain.FriendlyName + ", version " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version + @" Changes to this file may cause incorrect behavior and will be lost if code is regenerated </auto-generated> ------------------------------------------------------------------------------"); // Visual Studio 2010 https://msdn.microsoft.com/en-us/library/x53a06bb.aspx // Note: // 1. Contextual keywords are not reserved keywords e.g. value, partial // 2. __arglist, __makeref, __reftype, __refvalue are undocumented keywords, but recognised by the C# compiler ReservedKeywords = new HashSet <string>() { "abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char", "checked", "class", "const", "continue", "decimal", "default", "delegate", "do", "double", "else", "enum", "event", "explicit", "extern", "false", "finally", "fixed", "float", "for", "foreach", "goto", "if", "implicit", "in", "int", "interface", "internal", "is", "lock", "long", "namespace", "new", "null", "object", "operator", "out", "override", "params", "private", "protected", "public", "readonly", "ref", "return", "sbyte", "sealed", "short", "sizeof", "stackalloc", "static", "string", "struct", "switch", "this", "throw", "true", "try", "typeof", "uint", "ulong", "unchecked", "unsafe", "ushort", "using", "virtual", "void", "volatile", "while", "__arglist", "__makeref", "__reftype", "__refvalue" }; }
static CodeCompileUnit _ParseCompileUnit(_PC pc) { var l = pc.Line; var c = pc.Column; var p = pc.Position; var result = new CodeCompileUnit().Mark(l, c, p); var ns = new CodeNamespace().Mark(l, c, p); result.Namespaces.Add(ns); while (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId) { switch (pc.SymbolId) { case ST.directive: var d = _ParseDirective(pc) as CodeDirective; if (null != d) { result.StartDirectives.Add(d); } break; case ST.blockComment: ns.Comments.Add(_ParseCommentStatement(pc)); break; case ST.lineComment: ns.Comments.Add(_ParseCommentStatement(pc, true)); break; } } while (ST.usingKeyword == pc.SymbolId) { while (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId) { pc.Advance(false); } var l2 = pc.Line; var c2 = pc.Column; var p2 = pc.Position; pc.Advance(); var nsi = new CodeNamespaceImport(_ParseNamespaceName(pc)).SetLoc(l2, c2, p2); if (ST.semi != pc.SymbolId) { pc.Error("Expecting ; in using declaration"); } pc.Advance(false); ns.Imports.Add(nsi); } while (ST.lbracket == pc.SymbolId) { var pc2 = pc.GetLookAhead(true); pc2.Advance(); if (ST.assemblyKeyword != pc2.SymbolId) { break; } result.AssemblyCustomAttributes.AddRange(_ParseAttributeGroup(pc, false).Value); } while (!pc.IsEnded) { var startDirs = new CodeDirectiveCollection(); var comments = new CodeCommentStatementCollection(); CodeLinePragma lp = null; while (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId) { switch (pc.SymbolId) { case ST.directive: var d = _ParseDirective(pc); var llp = d as CodeLinePragma; if (null != llp) { lp = llp; } else if (null != d) { startDirs.Add(d as CodeDirective); } break; case ST.blockComment: comments.Add(_ParseCommentStatement(pc)); break; case ST.lineComment: comments.Add(_ParseCommentStatement(pc, true)); break; } } if (ST.namespaceKeyword == pc.SymbolId) { var nns = _ParseNamespace(pc); nns.Comments.AddRange(comments); result.Namespaces.Add(nns); } else { var t = _ParseTypeDecl(pc, false, pc.Line, pc.Column, pc.Position, null); t.Comments.AddRange(comments); t.StartDirectives.AddRange(startDirs); t.LinePragma = lp; ns.Types.Add(t); } } return(result); }
static CodeNamespace _ParseNamespace(_PC pc) { var l = pc.Line; var c = pc.Column; var p = pc.Position; var result = new CodeNamespace().Mark(l, c, p); while (ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId || ST.directive == pc.SymbolId) { if (ST.directive != pc.SymbolId) { result.Comments.Add(_ParseCommentStatement(pc, true)); } } if (ST.namespaceKeyword != pc.SymbolId) { pc.Error("Expecting namespace"); } pc.Advance(); result.Name = _ParseNamespaceName(pc); if (ST.lbrace != pc.SymbolId) { pc.Error("Expecing { in namespace declaration"); } pc.Advance(false); if (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId) { var pc2 = pc.GetLookAhead(true); if (ST.usingKeyword == pc2.SymbolId) { pc.Advance(); } } while (ST.usingKeyword == pc.SymbolId) { while (ST.directive == pc.SymbolId || ST.lineComment == pc.SymbolId || ST.blockComment == pc.SymbolId) { pc.Advance(false); } var l2 = pc.Line; var c2 = pc.Column; var p2 = pc.Position; pc.Advance(); var nsi = new CodeNamespaceImport(_ParseNamespaceName(pc)).SetLoc(l2, c2, p2); if (ST.semi != pc.SymbolId) { pc.Error("Expecting ; in using declaration"); } pc.Advance(false); result.Imports.Add(nsi); } while (ST.rbrace != pc.SymbolId) { result.Types.Add(_ParseTypeDecl(pc, false, pc.Line, pc.Column, pc.Position, null)); } if (ST.rbrace != pc.SymbolId) { pc.Error("Unterminated namespace declaration", l, c, p); } pc.Advance(false); return(result); }
private static void ValidateNamespaceImport(CodeNamespaceImport e) { ValidateTypeName(e, "Namespace", e.Namespace); }
protected override void GenerateNamespaceImport(CodeNamespaceImport e) { }
internal static CodeNamespaceCollection GenerateCodeFromXomlDocument(Activity rootActivity, string filePath, string rootNamespace, SupportedLanguages language, IServiceProvider serviceProvider) { CodeNamespaceCollection codeNamespaces = new CodeNamespaceCollection(); CodeDomProvider codeDomProvider = CompilerHelpers.GetCodeDomProvider(language); // generate activity class string activityFullClassName = rootActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string; CodeTypeDeclaration activityTypeDeclaration = null; if (codeDomProvider != null && !string.IsNullOrEmpty(activityFullClassName)) { // get class and namespace names string activityNamespaceName, activityClassName; Helpers.GetNamespaceAndClassName(activityFullClassName, out activityNamespaceName, out activityClassName); if (codeDomProvider.IsValidIdentifier(activityClassName)) { DesignerSerializationManager designerSerializationManager = new DesignerSerializationManager(serviceProvider); using (designerSerializationManager.CreateSession()) { ActivityCodeDomSerializationManager codeDomSerializationManager = new ActivityCodeDomSerializationManager(designerSerializationManager); TypeCodeDomSerializer typeCodeDomSerializer = codeDomSerializationManager.GetSerializer(rootActivity.GetType(), typeof(TypeCodeDomSerializer)) as TypeCodeDomSerializer; // get all activities bool generateCode = true; ArrayList allActivities = new ArrayList(); allActivities.Add(rootActivity); if (rootActivity is CompositeActivity) { foreach (Activity activity in Helpers.GetNestedActivities((CompositeActivity)rootActivity)) { if (Helpers.IsActivityLocked(activity)) { continue; } if (codeDomProvider.IsValidIdentifier(codeDomSerializationManager.GetName(activity))) { // WinOE Bug 14561. This is to fix a performance problem. When an activity is added to the activity // tree at the runtime, it's much faster if the ID of the activity is already set. The code that // the CodeDomSerializer generates will add the activity first before it sets the ID for the child // activity. We can change that order by always serializing the children first. Therefore, we // construct a list where we guarantee that the child will be serialized before its parent. allActivities.Insert(0, activity); } else { generateCode = false; break; } } } if (generateCode) { // Work around!! TypeCodeDomSerializer checks that root component has a site or not, otherwise it // does not serialize it look at ComponentTypeCodeDomSerializer.cs DummySite dummySite = new DummySite(); foreach (Activity nestedActivity in allActivities) { ((IComponent)nestedActivity).Site = dummySite; } ((IComponent)rootActivity).Site = dummySite; // create activity partial class activityTypeDeclaration = typeCodeDomSerializer.Serialize(codeDomSerializationManager, rootActivity, allActivities); activityTypeDeclaration.IsPartial = true; // add checksum attribute if (filePath != null && filePath.Length > 0) { MD5 md5 = new MD5CryptoServiceProvider(); byte[] checksumBytes = null; using (StreamReader streamReader = new StreamReader(filePath)) checksumBytes = md5.ComputeHash(streamReader.BaseStream); string checksum = string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}{14}{15}", new object[] { checksumBytes[0].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[1].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[2].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[3].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[4].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[5].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[6].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[7].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[8].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[9].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[10].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[11].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[12].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[13].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[14].ToString("X2", CultureInfo.InvariantCulture), checksumBytes[15].ToString("X2", CultureInfo.InvariantCulture) }); CodeAttributeDeclaration xomlSourceAttribute = new CodeAttributeDeclaration(typeof(WorkflowMarkupSourceAttribute).FullName); xomlSourceAttribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(filePath))); xomlSourceAttribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(checksum))); activityTypeDeclaration.CustomAttributes.Add(xomlSourceAttribute); } // create a new namespace and add activity class into that CodeNamespace activityCodeNamespace = new CodeNamespace(activityNamespaceName); activityCodeNamespace.Types.Add(activityTypeDeclaration); codeNamespaces.Add(activityCodeNamespace); } } } } // generate code for x:Code if (activityTypeDeclaration != null) { Queue activitiesQueue = new Queue(new object[] { rootActivity }); while (activitiesQueue.Count > 0) { Activity activity = (Activity)activitiesQueue.Dequeue(); if (Helpers.IsActivityLocked(activity)) { continue; } Queue childActivities = new Queue(new object[] { activity }); while (childActivities.Count > 0) { Activity childActivity = (Activity)childActivities.Dequeue(); if (childActivity is CompositeActivity) { foreach (Activity nestedChildActivity in ((CompositeActivity)childActivity).Activities) { childActivities.Enqueue(nestedChildActivity); } } // generate x:Code CodeTypeMemberCollection codeSegments = childActivity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection; if (codeSegments != null) { foreach (CodeSnippetTypeMember codeSegmentMember in codeSegments) { activityTypeDeclaration.Members.Add(codeSegmentMember); } } } } if (language == SupportedLanguages.CSharp) { activityTypeDeclaration.LinePragma = new CodeLinePragma((string)rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int)rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1)); } //Now make sure we that we also emit line pragma around the constructor CodeConstructor constructor = null; CodeMemberMethod method = null; foreach (CodeTypeMember typeMember in activityTypeDeclaration.Members) { if (constructor == null && typeMember is CodeConstructor) { constructor = typeMember as CodeConstructor; } if (method == null && typeMember is CodeMemberMethod && typeMember.Name.Equals("InitializeComponent", StringComparison.Ordinal)) { method = typeMember as CodeMemberMethod; } if (constructor != null && method != null) { break; } } if (constructor != null) { constructor.LinePragma = new CodeLinePragma((string)rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int)rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1)); } if (method != null && language == SupportedLanguages.CSharp) { method.LinePragma = new CodeLinePragma((string)rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int)rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1)); } } // generate mappings List <String> clrNamespaces = rootActivity.GetValue(WorkflowMarkupSerializer.ClrNamespacesProperty) as List <String>; if (clrNamespaces != null) { // foreach namespace add these mappings foreach (CodeNamespace codeNamespace in codeNamespaces) { foreach (string clrNamespace in clrNamespaces) { if (!String.IsNullOrEmpty(clrNamespace)) { CodeNamespaceImport codeNamespaceImport = new CodeNamespaceImport(clrNamespace); codeNamespaceImport.LinePragma = new CodeLinePragma((string)rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int)rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1)); codeNamespace.Imports.Add(codeNamespaceImport); } } } } // return namespaces return(codeNamespaces); }
protected override void Visit(CodeNamespaceImport ns) { Enumerate(ns.LinePragma); base.Visit(ns); }
protected abstract void GenerateNamespaceImport(CodeNamespaceImport e);
private void CreateInteropFormProxiesForDocument(List <CodeClass> interopFormClasses, Project currentAssembly, ProjectItem interopFormDoc) { if (checkFileExists(currentAssembly, interopFormDoc)) { return; } if (interopFormClasses.Count <= 0) { return; } CodeCompileUnit unit1 = new CodeCompileUnit(); CodeNamespaceImport import1 = new CodeNamespaceImport(this._attrTypeForm.Namespace); System.CodeDom.CodeNamespace namespace1 = new System.CodeDom.CodeNamespace(); namespace1.Name = "Interop"; unit1.Namespaces.Add(namespace1); namespace1.Imports.Add(import1); namespace1.Imports.Add(new CodeNamespaceImport("System")); foreach (CodeClass class1 in interopFormClasses) { string text2 = class1.FullName; CodeTypeDeclaration declaration1 = new CodeTypeDeclaration(class1.Name); namespace1.Types.Add(declaration1); declaration1.IsClass = true; declaration1.IsPartial = true; CodePrimitiveExpression expression2 = new CodePrimitiveExpression(true); CodeSnippetExpression expression1 = new CodeSnippetExpression("System.Runtime.InteropServices.ClassInterfaceType.AutoDual"); declaration1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.ClassInterface", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(expression1) })); declaration1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.ComVisible", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(expression2) })); declaration1.BaseTypes.Add(new CodeTypeReference(typeof(InteropFormProxyBase).Name)); CodeTypeDeclaration declaration2 = new CodeTypeDeclaration("I" + declaration1.Name + "EventSink"); declaration2.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.InterfaceTypeAttribute", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(new CodeSnippetExpression("System.Runtime.InteropServices.ComInterfaceType.InterfaceIsIDispatch")) })); declaration2.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.ComVisible", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(expression2) })); declaration2.IsInterface = true; CodeConstructor constructor1 = new CodeConstructor(); CodeSnippetStatement statement1 = GetStatementInitializeForm(text2); CodeSnippetStatement statement2 = GetStatementRegisterForm(); constructor1.Statements.Add(statement1); constructor1.Statements.Add(statement2); constructor1.Attributes = MemberAttributes.Public; declaration1.Members.Add(constructor1); if (class1.Members.Count > 0) { foreach (CodeElement element1 in class1.Members) { switch (element1.Kind) { case vsCMElement.vsCMElementFunction: CodeFunction2 function1 = (CodeFunction2)element1; if (function1.Access == vsCMAccess.vsCMAccessPublic) { foreach (CodeElement element2 in function1.Attributes) { if (this.AttributesMatch(element2, this._attrTypeInitializer)) { this.AddInitializeMethodForConstructor(declaration1, class1, function1); break; } if (this.AttributesMatch(element2, this._attrTypeMethod)) { this.AddMethod(declaration1, class1, function1); break; } } } break; case vsCMElement.vsCMElementProperty: CodeProperty property1 = (CodeProperty)element1; if (property1.Access == vsCMAccess.vsCMAccessPublic) { foreach (CodeElement element3 in property1.Attributes) { if (this.AttributesMatch(element3, this._attrTypeProperty)) { this.AddProperty(declaration1, class1, property1); break; } } } break; case vsCMElement.vsCMElementEvent: CodeEvent event1 = (CodeEvent)element1; if (event1.Access == vsCMAccess.vsCMAccessPublic) { foreach (CodeElement element3 in event1.Attributes) { if (this.AttributesMatch(element3, this._attrTypeEvent)) { this.AddEvent(currentAssembly, declaration1, class1, event1, declaration2); break; } } } break; } } } if (declaration2.Members.Count > 0) { namespace1.Types.Add(declaration2); declaration1.CustomAttributes.Add(new CodeAttributeDeclaration("System.Runtime.InteropServices.ComSourceInterfaces", new System.CodeDom.CodeAttributeArgument[] { new System.CodeDom.CodeAttributeArgument(new CodeTypeOfExpression(declaration2.Name)) })); } } ProjectItem generatedFolderItem = GetGeneratedFolderItem(currentAssembly); FileInfo generatedItemInfo = getGeneratedItem(currentAssembly, generatedFolderItem, interopFormDoc); StreamWriter writer1 = new StreamWriter(generatedItemInfo.Create()); writer1.AutoFlush = true; CodeDomProvider provider = GetProvider(); CodeGeneratorOptions options1 = new CodeGeneratorOptions(); provider.GenerateCodeFromCompileUnit(unit1, writer1, options1); writer1.Close(); writer1.Dispose(); generatedFolderItem.ProjectItems.AddFromFile(generatedItemInfo.FullName); }
private bool GenerateOutput() { string shortClassName, classNamespace; int dot = className.LastIndexOf('.'); if (dot >= 0) { classNamespace = className.Substring(0, dot); shortClassName = className.Substring(dot + 1); } else { classNamespace = null; shortClassName = className; } bool isPrivate = false; if (classModifier != null) { string publicModifier = null, privateModifier = null; if (typeAttributesConverter != null && typeAttributesConverter.CanConvertTo(typeof(string))) { try { publicModifier = typeAttributesConverter.ConvertTo(TypeAttributes.Public, typeof(string)) as string; privateModifier = typeAttributesConverter.ConvertTo(TypeAttributes.NotPublic, typeof(string)) as string; } catch (NotSupportedException) { } } if (string.Equals(classModifier, privateModifier, StringComparison.OrdinalIgnoreCase)) { isPrivate = true; } else if (!string.Equals(classModifier, publicModifier, StringComparison.OrdinalIgnoreCase)) { LogError(classModifierLineNumber, 1503, "Language '" + Language + "' does not support x:ClassModifier '" + classModifier + "'."); return(false); } } var unit = new CodeCompileUnit(); var ns = new CodeNamespace(classNamespace); unit.Namespaces.Add(ns); foreach (string importName in importedNamespaces) { var import = new CodeNamespaceImport(importName); if (importedNamespacesLineNumber != 0) { import.LinePragma = new CodeLinePragma(InputFileName.ItemSpec, importedNamespacesLineNumber); } ns.Imports.Add(import); } var type = new CodeTypeDeclaration { Name = shortClassName, IsPartial = true, BaseTypes = { typeof(ILambdaConverterProvider) } }; ns.Types.Add(type); if (isPrivate) { type.TypeAttributes &= ~TypeAttributes.Public; } var method = new CodeMemberMethod { Name = "GetConverterForLambda", PrivateImplementationType = new CodeTypeReference(typeof(ILambdaConverterProvider)), ReturnType = new CodeTypeReference(typeof(LambdaConverter)), Parameters = { new CodeParameterDeclarationExpression { Name = "lambda__", Type = new CodeTypeReference(typeof(string)) } }, CustomAttributes = { new CodeAttributeDeclaration(new CodeTypeReference(typeof(GeneratedCodeAttribute))) { Arguments = { new CodeAttributeArgument(new CodePrimitiveExpression(ToolName)), new CodeAttributeArgument(new CodePrimitiveExpression(typeof(ExtractLambdasFromXaml).Assembly.GetName().Version.ToString())) } } } }; type.Members.Add(method); foreach (var lambda in lambdas) { var cond = new CodeConditionStatement { Condition = new CodeBinaryOperatorExpression { Operator = CodeBinaryOperatorType.ValueEquality, Left = new CodeArgumentReferenceExpression("lambda__"), Right = new CodePrimitiveExpression(lambda.Code) }, TrueStatements = { new CodeMethodReturnStatement { Expression = new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { TargetObject = new CodeTypeReferenceExpression(typeof(LambdaConverter)), MethodName = "Create" }, Parameters = { new CodeSnippetExpression(lambda.Code) } }, LinePragma = new CodeLinePragma { FileName = InputFileName.ItemSpec, LineNumber = lambda.LineNumber } } } }; method.Statements.Add(cond); } method.Statements.Add( new CodeThrowExceptionStatement { ToThrow = new CodeObjectCreateExpression { CreateType = new CodeTypeReference(typeof(ArgumentOutOfRangeException)), Parameters = { new CodePrimitiveExpression("lambda__") } } }); try { using (var writer = File.CreateText(OutputFileName.ItemSpec)) { var options = new CodeGeneratorOptions(); codeDomProvider.GenerateCodeFromCompileUnit(unit, writer, options); } } catch (IOException ex) { LogError(2002, ex.Message); return(false); } return(true); }
protected override void GenerateNamespaceImport(CodeNamespaceImport e) { Output.Write("namespaceImport"); }
public void AddRange(CodeNamespaceImport[] value) {}
protected virtual void Visit(CodeNamespaceImport ns) { }
// Methods public void Add(CodeNamespaceImport value) {}
private void GenerateNamespaceImport(CodeNamespaceImport e) { Output.Write("import "); OutputIdentifier(e.Namespace); Output.WriteLine(";"); }
private static void ValidateNamespaceImport(CodeNamespaceImport e) { ValidateTypeName(e, nameof(e.Namespace), e.Namespace); }
private bool BuildSourceDataTree() { this._compilParams = this.Parser.CompilParams; this._codeCompileUnit = new CodeCompileUnit(); this._codeCompileUnit.UserData["AllowLateBound"] = !this.Parser.FStrict; this._codeCompileUnit.UserData["RequireVariableDeclaration"] = this.Parser.FExplicit; this._usingVJSCompiler = this._codeDomProvider.FileExtension == ".jsl"; this._sourceDataNamespace = new CodeNamespace(this.Parser.GeneratedNamespace); string generatedClassName = this.GetGeneratedClassName(); if (this.Parser.BaseTypeName != null) { CodeNamespace namespace2 = new CodeNamespace(this.Parser.BaseTypeNamespace); this._codeCompileUnit.Namespaces.Add(namespace2); this._intermediateClass = new CodeTypeDeclaration(this.Parser.BaseTypeName); if (this._designerMode) { this._intermediateClass.UserData["BaseClassDefinition"] = this.Parser.DefaultBaseType; } else { this._intermediateClass.UserData["BaseClassDefinition"] = this.Parser.BaseType; } namespace2.Types.Add(this._intermediateClass); this._intermediateClass.IsPartial = true; if (!this.PrecompilingForUpdatableDeployment) { this._sourceDataClass = new CodeTypeDeclaration(generatedClassName); this._sourceDataClass.BaseTypes.Add(CodeDomUtility.BuildGlobalCodeTypeReference(Util.MakeFullTypeName(this.Parser.BaseTypeNamespace, this.Parser.BaseTypeName))); this._sourceDataNamespace.Types.Add(this._sourceDataClass); } } else { this._intermediateClass = new CodeTypeDeclaration(generatedClassName); this._intermediateClass.BaseTypes.Add(CodeDomUtility.BuildGlobalCodeTypeReference(this.Parser.BaseType)); this._sourceDataNamespace.Types.Add(this._intermediateClass); this._sourceDataClass = this._intermediateClass; } this._codeCompileUnit.Namespaces.Add(this._sourceDataNamespace); if (this.PrecompilingForUpdatableDeployment && (this.Parser.CodeFileVirtualPath == null)) { return(false); } this.GenerateClassAttributes(); if (this._codeDomProvider is VBCodeProvider) { this._sourceDataNamespace.Imports.Add(new CodeNamespaceImport("Microsoft.VisualBasic")); } if (this.Parser.NamespaceEntries != null) { foreach (NamespaceEntry entry in this.Parser.NamespaceEntries.Values) { CodeLinePragma pragma; if (entry.VirtualPath != null) { pragma = this.CreateCodeLinePragma(entry.VirtualPath, entry.Line); } else { pragma = null; } CodeNamespaceImport import = new CodeNamespaceImport(entry.Namespace) { LinePragma = pragma }; this._sourceDataNamespace.Imports.Add(import); } } if (this._sourceDataClass != null) { CodeTypeReference type = CodeDomUtility.BuildGlobalCodeTypeReference(Util.MakeFullTypeName(this._sourceDataNamespace.Name, this._sourceDataClass.Name)); this._classTypeExpr = new CodeTypeReferenceExpression(type); } this.GenerateInterfaces(); this.BuildMiscClassMembers(); if (!this._designerMode && (this._sourceDataClass != null)) { this._ctor = new CodeConstructor(); this.AddDebuggerNonUserCodeAttribute(this._ctor); this._sourceDataClass.Members.Add(this._ctor); this.BuildDefaultConstructor(); } return(true); }
protected override void GenerateNamespaceImport(CodeNamespaceImport e) { Output.Write("using "); OutputIdentifier(e.Namespace); Output.WriteLine(";"); }