private CodeNamespace(SerializationInfo info, StreamingContext context) { this.imports = new CodeNamespaceImportCollection(); this.comments = new CodeCommentStatementCollection(); this.classes = new CodeTypeDeclarationCollection(); this.namespaces = new CodeNamespaceCollection(); }
public CodeNamespace() { this.imports = new CodeNamespaceImportCollection(); this.comments = new CodeCommentStatementCollection(); this.classes = new CodeTypeDeclarationCollection(); this.namespaces = new CodeNamespaceCollection(); }
public void Constructor0 () { CodeNamespaceImportCollection coll = new CodeNamespaceImportCollection (); 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.IsNull (((ICollection) coll).SyncRoot, "#5"); }
public void Constructor0_Deny_Unrestricted () { CodeNamespaceImportCollection coll = new CodeNamespaceImportCollection (); coll.Add (cni); Assert.AreSame (cni, coll[0], "this[int]"); coll[0] = cni; coll.Clear (); coll.AddRange (array); Assert.IsNotNull (coll.GetEnumerator (), "GetEnumerator"); }
public void Add () { CodeNamespaceImport ni1 = new CodeNamespaceImport ("A"); CodeNamespaceImport ni2 = new CodeNamespaceImport ("B"); CodeNamespaceImport ni3 = new CodeNamespaceImport ("b"); CodeNamespaceImport ni4 = new CodeNamespaceImport ("B"); CodeNamespaceImportCollection coll = new CodeNamespaceImportCollection (); coll.Add (ni1); Assert.AreEqual (1, coll.Count, "#1"); Assert.AreEqual (0, ((IList) coll).IndexOf (ni1), "#2"); coll.Add (ni2); Assert.AreEqual (2, coll.Count, "#3"); Assert.AreEqual (1, ((IList) coll).IndexOf (ni2), "#4"); coll.Add (ni3); Assert.AreEqual (2, coll.Count, "#5"); Assert.AreEqual (-1, ((IList) coll).IndexOf (ni3), "#6"); coll.Add (ni4); Assert.AreEqual (2, coll.Count, "#7"); Assert.AreEqual (-1, ((IList) coll).IndexOf (ni4), "#8"); }
private void AddImportsForCodeTypeReferenceCollection(CodeNamespaceImportCollection curImports, CodeTypeReferenceCollection ctrc) { foreach (CodeTypeReference ctr in ctrc) { MaybeAddImport(curImports, ctr); } }
public void AddRange_Null_Item() { CodeNamespaceImportCollection coll = new CodeNamespaceImportCollection(); coll.AddRange(new CodeNamespaceImport[] { null }); }
static CodeCompileUnit ParseInternal (TextReader codeStream) { var tree = SyntaxTree.Parse (codeStream); if (tree.Errors.Count > 0) throw new ArgumentException ("Stream contained errors."); var convertVisitor = new CodeDomConvertVisitor (); CodeCompileUnit ccu = convertVisitor.Convert (Compilation.Value, tree, tree.ToTypeSystem ()); //C# parser seems to insist on putting imports in the "Global" namespace; fix it up for (int i = 0; i < ccu.Namespaces.Count; i++) { CodeNamespace global = ccu.Namespaces [i]; if ((global.Name == "Global") && (global.Types.Count == 0)) { global.Name = ""; ccu.Namespaces.RemoveAt (i); ccu.Namespaces.Insert (0, global); //clear out repeat imports... for (int j = 1; j < ccu.Namespaces.Count; j++) { CodeNamespace cn = ccu.Namespaces [j]; //why can't we remove imports? will have to collect ones to keep //then clear and refill CodeNamespaceImportCollection imps = new CodeNamespaceImportCollection (); for (int m = 0; m < cn.Imports.Count; m++) { bool found = false; for (int n = 0; n < global.Imports.Count; n++) if (global.Imports [n] == cn.Imports [m]) found = true; if (!found) imps.Add (cn.Imports [m]); } cn.Imports.Clear (); foreach (CodeNamespaceImport imp in imps) cn.Imports.Add (imp); } break; } } return ccu; }
static CodeCompileUnit ParseInternal (TextReader codeStream) { IParser parser = ParserFactory.CreateParser ( SupportedLanguage.CSharp, codeStream); parser.ParseMethodBodies = true; parser.Parse (); if (parser.Errors.Count > 0) throw new ArgumentException (parser.Errors.ErrorOutput); CodeDomVisitor cdv = new CodeDomVisitor (); // new CodeDomVisitor (parser.Lexer.SpecialTracker.CurrentSpecials); parser.CompilationUnit.AcceptVisitor (cdv, null); parser.Dispose (); CodeCompileUnit ccu = cdv.codeCompileUnit; //C# parser seems to insist on putting imports in the "Global" namespace; fix it up for (int i = 0; i < ccu.Namespaces.Count; i++) { CodeNamespace global = ccu.Namespaces [i]; if ((global.Name == "Global") && (global.Types.Count == 0)) { global.Name = ""; ccu.Namespaces.RemoveAt (i); ccu.Namespaces.Insert (0, global); //clear out repeat imports... for (int j = 1; j < ccu.Namespaces.Count; j++) { CodeNamespace cn = ccu.Namespaces [j]; //why can't we remove imports? will have to collect ones to keep //then clear and refill CodeNamespaceImportCollection imps = new CodeNamespaceImportCollection (); for (int m = 0; m < cn.Imports.Count; m++) { bool found = false; for (int n = 0; n < global.Imports.Count; n++) if (global.Imports [n] == cn.Imports [m]) found = true; if (!found) imps.Add (cn.Imports [m]); } cn.Imports.Clear (); foreach (CodeNamespaceImport imp in imps) cn.Imports.Add (imp); } break; } } return ccu; }
public void AddRange_Null_Array () { CodeNamespaceImportCollection coll = new CodeNamespaceImportCollection (); coll.AddRange ((CodeNamespaceImport[]) null); }
private void AddImportsForTypeDeclaration(CodeNamespaceImportCollection curImports, CodeTypeDeclaration ctd) { AddImportsForCodeTypeReferenceCollection(curImports, ctd.BaseTypes); foreach (CodeTypeMember member in ctd.Members) { CodeMemberProperty prop; CodeMemberMethod meth; CodeMemberField field; CodeMemberEvent evnt; CodeTypeDeclaration innerType; if ((prop = member as CodeMemberProperty) != null) { AddImportsForProperty(curImports, prop); } else if ((evnt = member as CodeMemberEvent) != null) { AddImportsForEvent(curImports, evnt); } else if ((field = member as CodeMemberField) != null) { AddImportsForField(curImports, field); } else if ((meth = member as CodeMemberMethod) != null) { AddImportsForMethod(curImports, meth); } else if ((innerType = member as CodeTypeDeclaration) != null) { AddImportsForTypeDeclaration(curImports, innerType); } } }
private void MaybeAddImport(CodeNamespaceImportCollection curImports, CodeTypeReference reference) { string typeName = reference.BaseType; if (reference.BaseType == "System.Object" || reference.BaseType == "System.String" || reference.BaseType == "System.Int32" || reference.BaseType == "System.Double" || reference.BaseType == "System.Void") return; int firstDot; if((firstDot = typeName.IndexOf('.')) == -1){ return; } string typeNs = typeName.Substring(0, firstDot); foreach (CodeNamespaceImport cni in curImports) { if (cni.Namespace.StartsWith(typeNs)) return; } Console.WriteLine(reference.BaseType); curImports.Add(new CodeNamespaceImport(typeName.Substring(0, typeName.LastIndexOf('.')))); }
private void AddImportsForMethod(CodeNamespaceImportCollection imports, CodeMemberMethod method) { MaybeAddImport(imports, method.ReturnType); }
private void AddImportsForProperty(CodeNamespaceImportCollection imports, CodeMemberProperty prop) { MaybeAddImport(imports, prop.Type); }
public static CodeTypeReference CreateShortCodeTypeReference(Type type, CodeNamespaceImportCollection imports) { var result = new CodeTypeReference(type); Shortify(result, type, imports); return result; }
/// <summary> /// Visits a <see cref="CodeNamespaceImportCollection"/>. /// </summary> /// <param name="codeNamespaceImportCollection">The <see cref="CodeNamespaceImportCollection"/> to visit.</param> protected virtual void VisitCodeNamespaceImportCollection(CodeNamespaceImportCollection codeNamespaceImportCollection) { // Visit all of the CodeNamespaceImport items in the collection. foreach (CodeNamespaceImport item in codeNamespaceImportCollection.Cast<CodeNamespaceImport>()) { this.VisitCodeNamespaceImport(item); } }
public void Add_Null () { CodeNamespaceImportCollection coll = new CodeNamespaceImportCollection (); coll.Add ((CodeNamespaceImport) null); }
void AddConditionalImports(CodeNamespaceImportCollection imports, string firstImport, string conditional, string[] importsIfTrue, string[] importsIfFalse, string lastImport) { if (Provider is CSharpCodeProvider) { // HACK HACK HACK // Would be better if CodeDom actually supported conditional compilation constructs... // This is predecated upon CSharpCodeGenerator.GenerateNamespaceImport() being implemented as: // output.Write ("using "); // output.Write (GetSafeName (import.Namespace)); // output.WriteLine (';'); // Thus, with "crafty" execution of the namespace, we can stuff arbitrary text in there... var block = new StringBuilder(); // No 'using', as GenerateNamespaceImport() writes it. block.Append(firstImport).Append(";").Append(Environment.NewLine); block.Append("#if ").Append(conditional).Append(Environment.NewLine); foreach (var ns in importsIfTrue) block.Append("\tusing ").Append(ns).Append(";").Append(Environment.NewLine); block.Append("#else // ").Append(conditional).Append(Environment.NewLine); foreach (var ns in importsIfFalse) block.Append("\tusing ").Append(ns).Append(";").Append(Environment.NewLine); block.Append("#endif // ").Append(conditional).Append(Environment.NewLine); block.Append("\tusing ").Append(lastImport); // No ';', as GenerateNamespaceImport() writes it. imports.Add(new CodeNamespaceImport(block.ToString())); } else if (Provider is VBCodeProvider) { // HACK HACK HACK // Would be better if CodeDom actually supported conditional compilation constructs... // This is predecated upon VBCodeGenerator.GenerateNamespaceImport() being implemented as: // output.Write ("Imports "); // output.Write (import.Namespace); // output.WriteLine (); // Thus, with "crafty" execution of the namespace, we can stuff arbitrary text in there... var block = new StringBuilder(); // No 'Imports', as GenerateNamespaceImport() writes it. block.Append(firstImport).Append(Environment.NewLine); block.Append("#If ").Append(conditional).Append(" Then").Append(Environment.NewLine); foreach (var ns in importsIfTrue) block.Append("Imports ").Append(ns).Append(Environment.NewLine); block.Append("#Else ' ").Append(conditional).Append(Environment.NewLine); foreach (var ns in importsIfFalse) block.Append("Imports ").Append(ns).Append(Environment.NewLine); block.Append("#End If ' ").Append(conditional).Append(Environment.NewLine); block.Append("Imports ").Append(lastImport); // No newline, as GenerateNamespaceImport() writes it. imports.Add(new CodeNamespaceImport(block.ToString())); } else { // Default to using the DbLinq imports imports.Add(new CodeNamespaceImport(firstImport)); foreach (var ns in importsIfTrue) imports.Add(new CodeNamespaceImport(ns)); imports.Add(new CodeNamespaceImport(lastImport)); } }
private UsedNamespaceList Translate(CodeNamespaceImportCollection imports){ int n = imports == null ? 0 : imports.Count; UsedNamespaceList usedNspaces = new UsedNamespaceList(n); for (int i = 0; i < n; i++) usedNspaces.Add(this.Translate(imports[i])); return usedNspaces; }
protected virtual void AddDefaultImports(CodeNamespaceImportCollection imports) { imports.Add(new CodeNamespaceImport("System")); }
protected void Rewrite(CodeNamespaceImportCollection target, CodeNamespaceImportCollection source, ref bool didRewrite) { foreach (CodeNamespaceImport item in source) { target.Add(this.Rewrite(item, ref didRewrite)); } }
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"); }
private void AddImportsForEvent(CodeNamespaceImportCollection imports, CodeMemberEvent evnt) { MaybeAddImport(imports, evnt.Type); }
public static void Shortify(CodeTypeReference typeReference, Type type, CodeNamespaceImportCollection imports) { if (typeReference.ArrayRank > 0) { Shortify(typeReference.ArrayElementType, type, imports); return; } if (type.Namespace != null && imports.Cast<CodeNamespaceImport>() .Any(cni => cni.Namespace == type.Namespace)) { var prefix = type.Namespace + '.'; if (prefix != null) { var pos = typeReference.BaseType.IndexOf(prefix); if (pos == 0) { typeReference.BaseType = typeReference.BaseType.Substring(prefix.Length); } } } }
private void AddImportsForField(CodeNamespaceImportCollection imports, CodeMemberField field) { MaybeAddImport(imports, field.Type); }