C# CodeDom.CodeNamespaceImport类代码示例

        private CodeGenUtil()
        {
            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" };
        }

        static CodeNamespace BuildProgram()
        {
            // namespaceの作成
            var ns = new CodeNamespace("MetaWorld");
            // import編成
            var systemImport = new CodeNamespaceImport("System");
            // class作成
            var programClass = new CodeTypeDeclaration("Program");

            // mainメソッドの定義
            var methodMain = new CodeMemberMethod()
            {
                Attributes = MemberAttributes.Static,
                Name = "Main"
            };
            methodMain.Statements.Add(
                new CodeMethodInvokeExpression(
                    new CodeSnippetExpression("Console"),
                    "WriteLine",
                    new CodePrimitiveExpression("Hello World")
                    )
                );

            // コード構造の編成
            programClass.Members.Add(methodMain);
            ns.Imports.Add(systemImport);
            ns.Types.Add(programClass);
            return ns;
        }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            // Try to find the namespace in the existing imports
            string ns = Namespace;
            if (!String.IsNullOrEmpty(ns) && Char.IsWhiteSpace(ns[0]))
            {
                ns = ns.Substring(1);
            }

            CodeNamespaceImport import = context.Namespace
                .Imports
                .OfType<CodeNamespaceImport>()
                .Where(i => String.Equals(i.Namespace, ns.Trim(), StringComparison.Ordinal))
                .FirstOrDefault();

            if (import == null)
            {
                // It doesn't exist, create it
                import = new CodeNamespaceImport(ns);
                context.Namespace.Imports.Add(import);
            }

            // Attach our info to the existing/new import.
            import.LinePragma = context.GenerateLinePragma(target);
        }

 public void Add(CodeNamespaceImport value)
 {
     if (!_keys.ContainsKey(value.Namespace))
     {
         _keys[value.Namespace] = value;
         _data.Add(value);
     }
 }

 public void Add(CodeNamespaceImport value)
 {
     if (!this.keys.ContainsKey(value.Namespace))
     {
         this.keys[value.Namespace] = value;
         this.data.Add(value);
     }
 }

 public SqlTypesSchemaImporterExtensionHelper(string name,
                                               string targetNamespace,
                                               string[] references,
                                               CodeNamespaceImport[] namespaceImports,
                                               string destinationType,
                                               bool direct) {
      Init(name, targetNamespace, references, namespaceImports, destinationType, direct);
  }

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeNamespaceImport cni = new CodeNamespaceImport ("mono");
			Assert.IsNull (cni.LinePragma, "LinePragma");
			cni.LinePragma = new CodeLinePragma (String.Empty, Int32.MinValue);
			Assert.AreEqual ("mono", cni.Namespace, "Namespace");
			cni.Namespace = String.Empty;
		}

 void IXamlFileGenerationData.addImports(CodeNamespace ns)
 {
     CodeNamespaceImport anImport;
     if (this.isRegularWindow)
         anImport = new CodeNamespaceImport("System.Windows");
     else
         anImport = new CodeNamespaceImport("System.Windows.Navigation");
     ns.Imports.Add(anImport);
 }

        private static CodeNamespace AddNamespace(CodeCompileUnit compileUnit)
        {
            var codeNamespace = new CodeNamespace("Scripts");

            var systemImport = new CodeNamespaceImport("System");
            codeNamespace.Imports.Add(systemImport);

            compileUnit.Namespaces.Add(codeNamespace);
            return codeNamespace;
        }

 public void AddRange(CodeNamespaceImport[] value)
 {
     if (value == null)
     {
         throw new ArgumentNullException("value");
     }
     foreach (CodeNamespaceImport import in value)
     {
         this.Add(import);
     }
 }

        public void AddRange(CodeNamespaceImport[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }

            foreach (CodeNamespaceImport c in value)
            {
                Add(c);
            }
        }

		public void Constructor1 ()
		{
			string ns = "mono";

			CodeNamespaceImport cni = new CodeNamespaceImport (ns);
			Assert.IsNull (cni.LinePragma, "#1");
			Assert.IsNotNull (cni.Namespace, "#2");
			Assert.AreSame (ns, cni.Namespace, "#3");

			cni = new CodeNamespaceImport ((string) null);
			Assert.IsNotNull (cni.Namespace, "#4");
			Assert.AreEqual (string.Empty, cni.Namespace, "#5");
		}

        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;
        }

		protected virtual void BuildNamespace (CodeNamespace codeNamespace)
		{

			CodeTypeDeclaration codeType = new CodeTypeDeclaration {
            Name = GeneratedTypeName,
            IsClass = true
         };

			foreach (ParsedValue<string> item in this.parser.Namespaces) {
            
				CodeNamespaceImport 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 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");
		}