C# INamespace类代码示例

        public static void AddNamespace(INamespace ns)
        {
            if (ns == null)
                throw new ArgumentNullException("ns");

            namespaces[ns.Identifier] = ns;
        }

		public static IEntity ResolveQualifiedNameToSingle(INamespace root, string qualifiedName)
		{
			IEntity current = root;
			foreach (string part in qualifiedName.Split('.'))
				current = ResolveSingle((INamespace) current, part);
			return current;
		}

		public void AddNamespace (INamespace ns)
		{
			if (usedNamespaces.Contains (ns.Name))
				return;
			usedNamespaces.Add (ns.Name);
			result.Add (Factory.CreateNamespaceCompletionData (ns));
		}

 public CodeNamespace(CodeModelContext context, INamespace ns)
     : base(context)
 {
     this.ns = ns;
     this.InfoLocation = global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationExternal;
     this.Language = context.CurrentProject.GetCodeModelLanguage();
 }

		public static bool ResolveCoalescingNamespaces(INamespace parent, INamespace namespaceToResolveAgainst, string name, EntityType typesToConsider, ICollection<IEntity> resultingSet)
		{
			var resolved = new Set<IEntity>();
			if (!namespaceToResolveAgainst.Resolve(resolved, name, typesToConsider))
				return false;
			return CoalesceResolved(resolved, parent, name, resultingSet);
		}

		public static IEntity ResolveSingle(INamespace root, string name)
		{
			var resolved = new List<IEntity>();
			Assert.IsTrue(root.Resolve(resolved, name, EntityType.Any), "Failed to resolve '{0}' against '{1}'", name, root);
			Assert.AreEqual(1, resolved.Count);
			return resolved[0];
		}

		AstNode[] FindReferences(INamespace ns)
		{
			var result = new List<AstNode>();
			var searchScopes = findReferences.GetSearchScopes(ns);
			findReferences.FindReferencesInFile(searchScopes, unresolvedFile, syntaxTree, compilation,
			                                    (node, rr) => result.Add(node), CancellationToken.None);
			return result.OrderBy(n => n.StartLocation).ToArray();
		}

 public void SetChild(string name, INamespace entity)
 {
     _children[name] = entity;
     if (name == "")
     {
         _empty = entity;
     }
 }

 public NamespaceDelegator(INamespace parent, params INamespace[] namespaces)
 {
     if (null == namespaces)
     {
         throw new ArgumentNullException("namespaces");
     }
     _parent = parent;
     _namespaces = namespaces;
 }

        public NamespaceEntity(INamespace parent, TypeSystemServices tagManager, string name)
        {
            _parent = parent;
            _typeSystemServices = tagManager;
            _name = name;
			_assemblies = new Dictionary<Assembly, Dictionary<string, List<Type>>>(AssemblyEqualityComparer.Default);
            _childrenNamespaces = new Dictionary<string, NamespaceEntity>();
            _internalModules = new List<ModuleEntity>();
            _externalModules = new List<ExternalType>();

 public GlobalNamespace(IDictionary children)
     : base(null, children)
 {
     _empty = (INamespace)children[""];
     if (null == _empty)
     {
         _empty = NullNamespace.Default;
     }
 }

 public SimpleNamespace(INamespace parent, IDictionary children)
 {
     if (null == children)
     {
         throw new ArgumentNullException("children");
     }
     _parent = parent;
     _children = children;
 }

		bool IsAccessible(MemberLookup lookup, INamespace ns)
		{
			if (ns.Types.Any (t => lookup.IsAccessible (t, false)))
				return true;
			foreach (var child in ns.ChildNamespaces)
				if (IsAccessible (lookup, child))
					return true;
			return false;
		}

		/// <summary>
		/// Creates a new merged root namespace.
		/// </summary>
		/// <param name="compilation">The main compilation.</param>
		/// <param name="namespaces">The individual namespaces being merged.</param>
		/// <param name="externAlias">The extern alias for this namespace.</param>
		public MergedNamespace(ICompilation compilation, INamespace[] namespaces, string externAlias = null)
		{
			if (compilation == null)
				throw new ArgumentNullException("compilation");
			if (namespaces == null)
				throw new ArgumentNullException("namespaces");
			this.compilation = compilation;
			this.namespaces = namespaces;
			this.externAlias = externAlias;
		}

		public static Set<IEntity> ResolveQualifiedName(INamespace root, string qualifiedName)
		{
			INamespace current = root;
			string[] parts = qualifiedName.Split('.');
			for (int i=0; i < parts.Length - 1; ++i)
				current = (INamespace) ResolveSingle(current, parts[i]);
			var result = new Set<IEntity>();
			current.Resolve(result, parts[parts.Length - 1], EntityType.Any);
			return result;
		}