public CodeNamespace() { this.imports = new CodeNamespaceImportCollection(); this.comments = new CodeCommentStatementCollection(); this.classes = new CodeTypeDeclarationCollection(); this.namespaces = new CodeNamespaceCollection(); }
internal static void FixStandardNamespacesAndRootNamespace(CodeNamespaceCollection codeNamespaces, string rootNS, SupportedLanguages language) { if (language == SupportedLanguages.VB) { foreach (CodeNamespace namespace2 in codeNamespaces) { if (namespace2.Name == rootNS) { namespace2.Name = string.Empty; namespace2.UserData.Add("TruncatedNamespace", null); } else if (namespace2.Name.StartsWith(rootNS + ".", StringComparison.Ordinal)) { namespace2.Name = namespace2.Name.Substring(rootNS.Length + 1); namespace2.UserData.Add("TruncatedNamespace", null); } } } foreach (CodeNamespace namespace3 in codeNamespaces) { Hashtable hashtable = new Hashtable(); foreach (CodeNamespaceImport import in namespace3.Imports) { hashtable.Add(import.Namespace, import); } foreach (string str in standardNamespaces) { if (!hashtable.Contains(str)) { namespace3.Imports.Add(new CodeNamespaceImport(str)); } } } }
private CodeNamespace(SerializationInfo info, StreamingContext context) { this.imports = new CodeNamespaceImportCollection(); this.comments = new CodeCommentStatementCollection(); this.classes = new CodeTypeDeclarationCollection(); this.namespaces = new CodeNamespaceCollection(); }
/// <summary>Finds the client type by name in the provided collection of namespaces.</summary> /// <param name="typeName">The name of the client type for which to search.</param> /// <param name="namespaces">The collection of namespaces to search.</param> /// <returns>The client type if found; otherwise, null.</returns> internal static CodeTypeDeclaration FindClientType(string typeName, CodeNamespaceCollection namespaces) { return (from ns in namespaces.Cast<CodeNamespace>() from type in ns.Types.Cast<CodeTypeDeclaration>() where type.Name == typeName select type).FirstOrDefault(); }
public void Constructor1_NullItem () { CodeNamespace[] namespaces = new CodeNamespace[] { new CodeNamespace (), null }; CodeNamespaceCollection coll = new CodeNamespaceCollection ( namespaces); }
public void Constructor0 () { CodeNamespaceCollection coll = new CodeNamespaceCollection (); Assert.IsFalse (((IList) coll).IsFixedSize, "#1"); Assert.IsFalse (((IList) coll).IsReadOnly, "#2"); Assert.AreEqual (0, coll.Count, "#3"); Assert.IsFalse (((ICollection) coll).IsSynchronized, "#4"); Assert.IsNotNull (((ICollection) coll).SyncRoot, "#5"); }
public void AddRange(CodeNamespaceCollection value) { if (value == null) { throw new ArgumentNullException("value"); } int count = value.Count; for (int i = 0; i < count; i++) { this.Add(value[i]); } }
public void Constructor1 () { CodeNamespace ns1 = new CodeNamespace (); CodeNamespace ns2 = new CodeNamespace (); CodeNamespace[] namespaces = new CodeNamespace[] { ns1, ns2 }; CodeNamespaceCollection coll = new CodeNamespaceCollection ( namespaces); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (ns1), "#2"); Assert.AreEqual (1, coll.IndexOf (ns2), "#3"); }
/// <devdoc> /// <para> /// Adds the contents of another <see cref='System.CodeDom.CodeNamespaceCollection'/> to the end of the collection. /// </para> /// </devdoc> public void AddRange(CodeNamespaceCollection value) { if (value == null) { throw new ArgumentNullException("value"); } int currentCount = value.Count; for (int i = 0; i < currentCount; i = ((i) + (1))) { this.Add(value[i]); } }
public void Constructor1_Deny_Unrestricted () { CodeNamespaceCollection coll = new CodeNamespaceCollection (array); coll.CopyTo (array, 0); Assert.AreEqual (1, coll.Add (cn), "Add"); Assert.AreSame (cn, coll[0], "this[int]"); coll.AddRange (array); coll.AddRange (coll); Assert.IsTrue (coll.Contains (cn), "Contains"); Assert.AreEqual (0, coll.IndexOf (cn), "IndexOf"); coll.Insert (0, cn); coll.Remove (cn); }
public void AddRange(CodeNamespaceCollection value) { if (value == null) { throw new ArgumentNullException("value"); } int count = value.Count; for (int i = 0; i < count; i++) { Add(value[i]); } }
public CodeNamespaceCollection GenerateActivityClasses(List<Activity> activities) { var activityBuilderFactory = new ActivityBuilderFactory(); var activityClasses = new CodeNamespaceCollection(); foreach (var activity in activities) { var activityBuilder = activityBuilderFactory.Get(activity.Type); var activityCodeDom = activityBuilder.Build(activity); activityClasses.AddRange(activityCodeDom.ClassesToGenerate); this.activityNameToServiceNameDictionnary.Add(activity.Name, activityCodeDom.InvocationCode); } return activityClasses; }
private CodeTypeDeclaration CreateOrGetServiceDeclaration(Activity rootActivity, CodeNamespaceCollection codeNamespaceCollection) { string namespaceName = ""; CodeNamespace webServiceCodeNamespace = null; string fullName = rootActivity.GetType().FullName; CodeTypeDeclaration webserviceCodeTypeDeclaration = null; if (rootActivity.GetType().FullName.IndexOf(".") != -1) { namespaceName = rootActivity.GetType().FullName.Substring(0, rootActivity.GetType().FullName.LastIndexOf('.')); } foreach (CodeNamespace namespace3 in codeNamespaceCollection) { if (namespace3.Name == namespaceName) { webServiceCodeNamespace = namespace3; break; } } if (webServiceCodeNamespace == null) { webServiceCodeNamespace = this.GetWebServiceCodeNamespace(namespaceName); codeNamespaceCollection.Add(webServiceCodeNamespace); } string str3 = fullName.Substring(fullName.LastIndexOf('.') + 1) + "_WebService"; foreach (CodeTypeDeclaration declaration2 in webServiceCodeNamespace.Types) { if (declaration2.Name == str3) { webserviceCodeTypeDeclaration = declaration2; break; } } if (webserviceCodeTypeDeclaration == null) { webserviceCodeTypeDeclaration = this.GetWebserviceCodeTypeDeclaration(fullName.Substring(fullName.LastIndexOf('.') + 1)); webServiceCodeNamespace.Types.Add(webserviceCodeTypeDeclaration); webServiceCodeNamespace.Imports.Add(new CodeNamespaceImport("System")); webServiceCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Web")); webServiceCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Web.Services")); webServiceCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Web.Services.Protocols")); webServiceCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Workflow.Runtime.Hosting")); webServiceCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Workflow.Activities")); } return webserviceCodeTypeDeclaration; }
public CodeNamespaceCollection Build(JavaActivity activity) { var javaNamespace = new CodeNamespace(activity.PackageName); // Generate the Service javaNamespace.Imports.AddRange(this.GenerateImports()); var javaClass = this.GenerateClass(activity); javaClass.Members.Add(this.GenerateInvokeMethod()); javaNamespace.Types.Add(javaClass); var codeNameSpaces = new CodeNamespaceCollection {javaNamespace}; // Generate the corresponding interface if (ConfigurationApp.GetProperty ("IsJavaInterfaceAlreadyGenerated") != "true") { //TODO : Refactor because it's a bit dirty var javaServiceInterfaceNameSpace = InterfaceExtractorFromClass.Extract(javaClass, TargetAppNameSpaceService.javaToolsNameSpace); javaServiceInterfaceNameSpace.Types[0].Name = "IJavaActivtyService"; codeNameSpaces.Add(javaServiceInterfaceNameSpace); ConfigurationApp.SaveProperty("IsJavaInterfaceAlreadyGenerated", "true"); } return codeNameSpaces; }
public void Constructor2 () { CodeNamespace ns1 = new CodeNamespace (); CodeNamespace ns2 = new CodeNamespace (); CodeNamespaceCollection c = new CodeNamespaceCollection (); c.Add (ns1); c.Add (ns2); CodeNamespaceCollection coll = new CodeNamespaceCollection (c); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (ns1), "#2"); Assert.AreEqual (1, coll.IndexOf (ns2), "#3"); }
protected virtual void ThrowOnNoTypes(CodeNamespaceCollection namespaces, string element) { if (namespaces.Count == 0) { throw new InvalidOperationException( string.Format(CultureInfo.CurrentCulture, Properties.Resources.CodeGenerationElementWithoutType, element)); } }
public void AddRange(CodeNamespaceCollection value) { foreach(CodeNamespace e in value) { List.Add(e); } }
public void AddRange(CodeNamespaceCollection value) { throw new NotImplementedException(); }
/// <summary> /// Used when adding a new type to a code namespace. Method looks for a matching namespace /// in the namespaces collection or adds a new one if it does not exist. /// </summary> /// <param name="codeNamespaces">A collection of code namespaces.</param> /// <param name="namespaceName">A string containig the name of the namespace to find or add.</param> /// <returns>A code namespace object containing a new code namespace or an existing namespace.</returns> internal static CodeNamespace GetDotNetNamespace(CodeNamespaceCollection codeNamespaces, string namespaceName) { CodeNamespace dotNetNamespace = null; string dotNetNamespaceName = GenerateDotNetNamespace(namespaceName); // Search for the namespace foreach (CodeNamespace codeNs in codeNamespaces) { if (codeNs.Name == dotNetNamespaceName) return codeNs; } // If namespace was not found create on and add it to the namespaces collection dotNetNamespace = new CodeNamespace(dotNetNamespaceName); codeNamespaces.Add(dotNetNamespace); s_namespaceToDotNetNamespace[dotNetNamespace] = namespaceName; return dotNetNamespace; }
public void Remove_Null () { CodeNamespaceCollection coll = new CodeNamespaceCollection (); coll.Remove ((CodeNamespace) null); }
CodeNamespaceCollection GenerateProcessVariablesNamespaces(TibcoBWProcess tibcoBwProcessToGenerate) { CodeNamespaceCollection processVariableNameNamespaces = new CodeNamespaceCollection(); if (tibcoBwProcessToGenerate.ProcessVariables != null) { foreach (var item in tibcoBwProcessToGenerate.ProcessVariables) { if (!IsBasicType(item.Parameter.Type)) { processVariableNameNamespaces.Add(this.xsdClassGenerator.Build(item.ObjectXNodes, tibcoBwProcessToGenerate.NameSpace)); } } } return processVariableNameNamespaces; }
public void AddRange_Null_Item () { CodeNamespaceCollection coll = new CodeNamespaceCollection (); coll.AddRange (new CodeNamespace[] { null }); }
public CodeNamespaceCollection (CodeNamespaceCollection value) { return default(CodeNamespaceCollection); }
public void AddRange (CodeNamespaceCollection! value) { Contract.Requires(value != null); }
internal static void ReapplyRootNamespace(CodeNamespaceCollection codeNamespaces, string rootNS, SupportedLanguages language) { if (language == SupportedLanguages.VB) { foreach (CodeNamespace codeNamespace in codeNamespaces) { if (codeNamespace.UserData.Contains("TruncatedNamespace")) { if (codeNamespace.Name == null || codeNamespace.Name.Length == 0) codeNamespace.Name = rootNS; else if (codeNamespace.Name.StartsWith(rootNS + ".", StringComparison.Ordinal)) codeNamespace.Name = rootNS + "." + codeNamespace.Name; codeNamespace.UserData.Remove("TruncatedNamespace"); } } } }
internal static CodeNamespaceCollection GenerateCodeFromXomlDocument(Activity rootActivity, string filePath, string rootNamespace, SupportedLanguages language, IServiceProvider serviceProvider) { CodeNamespaceCollection namespaces = new CodeNamespaceCollection(); CodeDomProvider codeDomProvider = CompilerHelpers.GetCodeDomProvider(language); string str = rootActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string; CodeTypeDeclaration declaration = null; if ((codeDomProvider != null) && !string.IsNullOrEmpty(str)) { string str2; string str3; Helpers.GetNamespaceAndClassName(str, out str2, out str3); if (codeDomProvider.IsValidIdentifier(str3)) { DesignerSerializationManager manager = new DesignerSerializationManager(serviceProvider); using (manager.CreateSession()) { ActivityCodeDomSerializationManager manager2 = new ActivityCodeDomSerializationManager(manager); TypeCodeDomSerializer serializer = manager2.GetSerializer(rootActivity.GetType(), typeof(TypeCodeDomSerializer)) as TypeCodeDomSerializer; bool flag = true; ArrayList list = new ArrayList(); list.Add(rootActivity); if (rootActivity is CompositeActivity) { foreach (Activity activity in Helpers.GetNestedActivities((CompositeActivity) rootActivity)) { if (!Helpers.IsActivityLocked(activity)) { if (codeDomProvider.IsValidIdentifier(manager2.GetName(activity))) { list.Insert(0, activity); } else { flag = false; break; } } } } if (flag) { DummySite site = new DummySite(); foreach (Activity activity2 in list) { activity2.Site = site; } rootActivity.Site = site; declaration = serializer.Serialize(manager2, rootActivity, list); declaration.IsPartial = true; if ((filePath != null) && (filePath.Length > 0)) { MD5 md = new MD5CryptoServiceProvider(); byte[] buffer = null; using (StreamReader reader = new StreamReader(filePath)) { buffer = md.ComputeHash(reader.BaseStream); } string str4 = string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}{14}{15}", new object[] { buffer[0].ToString("X2", CultureInfo.InvariantCulture), buffer[1].ToString("X2", CultureInfo.InvariantCulture), buffer[2].ToString("X2", CultureInfo.InvariantCulture), buffer[3].ToString("X2", CultureInfo.InvariantCulture), buffer[4].ToString("X2", CultureInfo.InvariantCulture), buffer[5].ToString("X2", CultureInfo.InvariantCulture), buffer[6].ToString("X2", CultureInfo.InvariantCulture), buffer[7].ToString("X2", CultureInfo.InvariantCulture), buffer[8].ToString("X2", CultureInfo.InvariantCulture), buffer[9].ToString("X2", CultureInfo.InvariantCulture), buffer[10].ToString("X2", CultureInfo.InvariantCulture), buffer[11].ToString("X2", CultureInfo.InvariantCulture), buffer[12].ToString("X2", CultureInfo.InvariantCulture), buffer[13].ToString("X2", CultureInfo.InvariantCulture), buffer[14].ToString("X2", CultureInfo.InvariantCulture), buffer[15].ToString("X2", CultureInfo.InvariantCulture) }); CodeAttributeDeclaration declaration2 = new CodeAttributeDeclaration(typeof(WorkflowMarkupSourceAttribute).FullName); declaration2.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(filePath))); declaration2.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(str4))); declaration.CustomAttributes.Add(declaration2); } CodeNamespace namespace2 = new CodeNamespace(str2); namespace2.Types.Add(declaration); namespaces.Add(namespace2); } } } } if (declaration != null) { Queue queue = new Queue(new object[] { rootActivity }); while (queue.Count > 0) { Activity activity3 = (Activity) queue.Dequeue(); if (!Helpers.IsActivityLocked(activity3)) { Queue queue2 = new Queue(new object[] { activity3 }); while (queue2.Count > 0) { Activity activity4 = (Activity) queue2.Dequeue(); if (activity4 is CompositeActivity) { foreach (Activity activity5 in ((CompositeActivity) activity4).Activities) { queue2.Enqueue(activity5); } } CodeTypeMemberCollection members = activity4.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection; if (members != null) { foreach (CodeSnippetTypeMember member in members) { declaration.Members.Add(member); } } } } } if (language == SupportedLanguages.CSharp) { declaration.LinePragma = new CodeLinePragma((string) rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int) rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1)); } CodeConstructor constructor = null; CodeMemberMethod method = null; foreach (CodeTypeMember member2 in declaration.Members) { if ((constructor == null) && (member2 is CodeConstructor)) { constructor = member2 as CodeConstructor; } if (((method == null) && (member2 is CodeMemberMethod)) && member2.Name.Equals("InitializeComponent", StringComparison.Ordinal)) { method = member2 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)); } } List<string> list2 = rootActivity.GetValue(WorkflowMarkupSerializer.ClrNamespacesProperty) as List<string>; if (list2 != null) { foreach (CodeNamespace namespace3 in namespaces) { foreach (string str5 in list2) { if (!string.IsNullOrEmpty(str5)) { CodeNamespaceImport import = new CodeNamespaceImport(str5) { LinePragma = new CodeLinePragma((string) rootActivity.GetValue(ActivityCodeDomSerializer.MarkupFileNameProperty), Math.Max((int) rootActivity.GetValue(ActivityMarkupSerializer.StartLineProperty), 1)) }; namespace3.Imports.Add(import); } } } } return namespaces; }
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; }
public void Constructor1_Null () { CodeNamespaceCollection coll = new CodeNamespaceCollection ( (CodeNamespace[]) null); }
public void AddRange(CodeNamespaceCollection !value) { Contract.Requires(value != null); }
/// <devdoc> /// <para> /// Initializes a new instance of <see cref='System.CodeDom.CodeNamespaceCollection'/> based on another <see cref='System.CodeDom.CodeNamespaceCollection'/>. /// </para> /// </devdoc> public CodeNamespaceCollection(CodeNamespaceCollection value) { this.AddRange(value); }
public CodeNamespaceCollection(CodeNamespaceCollection value) { return(default(CodeNamespaceCollection)); }
/// <summary> /// Gets the DotNetNamespace for a given typename /// </summary> /// <param name="codeNamespaces">The CodeNamespace collection to search in.</param> /// <param name="typeName">The name of a type (data contract) to search for.</param> /// <returns>The DotNetNamespace for the given type if found, otherwise an empty string.</returns> internal static string GetNamespaceFromType(CodeNamespaceCollection codeNamespaces, string typeName) { // strip off the namespace int idx = typeName.LastIndexOf("."); string ns = ""; if(idx >= 0) { ns = typeName.Substring(0, idx); typeName = typeName.Remove(0, idx+1); } // Search for the namespace foreach (CodeNamespace codeNs in codeNamespaces) { if(codeNs.Name == ns || ns == "") { foreach(CodeTypeDeclaration ctd in codeNs.Types) { if(ctd.Name == typeName) { if(s_namespaceToDotNetNamespace.ContainsKey(codeNs)) { return s_namespaceToDotNetNamespace[codeNs]; } else { return ""; } } } } } return ""; }
public Type[] Generate(IEnumerable<XPathModuleInfo> modules) { bool debuggerIsAttached = Debugger.IsAttached; var generatedTypeNames = new List<string>(); var compilerParams = new CompilerParameters { GenerateInMemory = !debuggerIsAttached, ReferencedAssemblies = { // current assembly typeof(IntegratedExtensionFunctionGenerator).Assembly.Location, // Saxon.Api typeof(ExtensionFunctionDefinition).Assembly.Location, // System typeof(Uri).Assembly.Location, // System.Core typeof(Enumerable).Assembly.Location, } }; var namespaces = new CodeNamespaceCollection(); foreach (XPathModuleInfo module in modules) { string[] functionDefTypeNames; namespaces.Add(GenerateModuleTypes(module, out functionDefTypeNames)); generatedTypeNames.AddRange(functionDefTypeNames); AddAssemblyReference(compilerParams, module.Type.Assembly); foreach (XPathFunctionInfo function in module.Functions) { AddAssemblyReference(compilerParams, function.ReturnType.ClrType.Assembly); foreach (XPathVariableInfo param in function.Parameters) { AddAssemblyReference(compilerParams, param.Type.ClrType.Assembly); } } } var compileUnit = new CodeCompileUnit(); compileUnit.Namespaces.AddRange(namespaces); CompilerResults result = this.provider.CompileAssemblyFromDom(compilerParams, compileUnit); CompilerError firstError = result.Errors.Cast<CompilerError>().FirstOrDefault(e => !e.IsWarning); if (firstError != null) { using (var stringWriter = new StringWriter(CultureInfo.InvariantCulture)) { provider.GenerateCodeFromCompileUnit(compileUnit, stringWriter, null); if (debuggerIsAttached) { Debugger.Log(0, Debugger.DefaultCategory, "Integrated extension function generation error:" + Environment.NewLine); Debugger.Log(0, Debugger.DefaultCategory, stringWriter.ToString()); } } throw new ArgumentException(firstError.ErrorText, "modules"); } if (debuggerIsAttached) { Debugger.Log(0, Debugger.DefaultCategory, "Integrated extension function(s) generated " + result.PathToAssembly + Environment.NewLine); } return generatedTypeNames .Select(n => result.CompiledAssembly.GetType(n, throwOnError: true)) .ToArray(); }
public CodeNamespaceCollection(CodeNamespaceCollection value) { throw new NotImplementedException(); }
internal static void FixStandardNamespacesAndRootNamespace(CodeNamespaceCollection codeNamespaces, string rootNS, SupportedLanguages language) { // add the standard imports to all the namespaces. if (language == SupportedLanguages.VB) { foreach (CodeNamespace codeNamespace in codeNamespaces) { if (codeNamespace.Name == rootNS) { codeNamespace.Name = string.Empty; codeNamespace.UserData.Add("TruncatedNamespace", null); } else if (codeNamespace.Name.StartsWith(rootNS + ".", StringComparison.Ordinal)) { codeNamespace.Name = codeNamespace.Name.Substring(rootNS.Length + 1); codeNamespace.UserData.Add("TruncatedNamespace", null); } } } foreach (CodeNamespace codeNamespace in codeNamespaces) { Hashtable definedNamespaces = new Hashtable(); foreach (CodeNamespaceImport codeNamespaceImport in codeNamespace.Imports) definedNamespaces.Add(codeNamespaceImport.Namespace, codeNamespaceImport); foreach (string standardNS in standardNamespaces) if (!definedNamespaces.Contains(standardNS))//add only new imports codeNamespace.Imports.Add(new CodeNamespaceImport(standardNS)); } }
protected void Rewrite(CodeNamespaceCollection target, CodeNamespaceCollection source, ref bool didRewrite) { foreach (CodeNamespace item in source) { target.Add(this.Rewrite(item, ref didRewrite)); } }