C# IProjectContent.ThreadSafeGetReferencedContents方法代码示例

		Assembly FindAssemblyInProjectReferences(IProjectContent pc, string name)
		{
			foreach (IProjectContent referencedProjectContent in pc.ThreadSafeGetReferencedContents()) {
				if (name == referencedProjectContent.AssemblyName) {
					return this.typeResolutionService.LoadAssembly(referencedProjectContent);
				}
			}
			return null;
		}

		public static IReturnType FindType(IProjectContent pc, string xmlNamespace, string className)
		{
			if (pc == null)
				throw new ArgumentNullException("pc");
			if (xmlNamespace == null || className == null)
				return null;
			if (xmlNamespace.StartsWith("clr-namespace:", StringComparison.OrdinalIgnoreCase)) {
				return CreateClrNamespaceType(pc, xmlNamespace, className);
			}
			else {
				IReturnType type = FindTypeInAssembly(pc, xmlNamespace, className);
				if (type != null)
					return type;
				foreach (IProjectContent p in pc.ThreadSafeGetReferencedContents()) {
					type = FindTypeInAssembly(p, xmlNamespace, className);
					if (type != null)
						return type;
				}
				return null;
			}
		}

		public static IEnumerable<IClass> GetNamespaceMembers(IProjectContent pc, string xmlNamespace)
		{
			if (pc == null)
				throw new ArgumentNullException("pc");
			
			if (!string.IsNullOrEmpty(xmlNamespace)) {
				if (xmlNamespace.StartsWith("clr-namespace:", StringComparison.OrdinalIgnoreCase))
					return pc.GetNamespaceContents(GetNamespaceNameFromClrNamespace(xmlNamespace)).OfType<IClass>();
				else {
					var list = new List<ICompletionEntry>();
					AddNamespaceMembersInAssembly(pc, xmlNamespace, list);
					foreach (IProjectContent p in pc.ThreadSafeGetReferencedContents()) {
						AddNamespaceMembersInAssembly(p, xmlNamespace, list);
					}
					return list.OfType<IClass>();
				}
			}
			
			return Enumerable.Empty<IClass>();
		}

		/// <summary>
		/// Loads the assembly represented by the project content. Returns null on failure.
		/// </summary>
		public Assembly LoadAssembly(IProjectContent pc)
		{
			WorkbenchSingleton.AssertMainThread();
			// prevent StackOverflow when project contents have cyclic dependencies
			// Very popular example of cyclic dependency: System <-> System.Xml
			if (!projectContentsCurrentlyLoadingAssembly.Add(pc))
				return null;
			
			Assembly sdAssembly;
			if (IsSharpDevelopAssembly(pc, out sdAssembly))
				return sdAssembly;
			
			try {
				// load dependencies of current assembly
				foreach (IProjectContent rpc in pc.ThreadSafeGetReferencedContents()) {
					if (rpc is ParseProjectContent) {
						LoadAssembly(rpc);
					} else if (rpc is ReflectionProjectContent) {
						ReflectionProjectContent rrpc = (ReflectionProjectContent)rpc;
						if (!rrpc.IsGacAssembly) {
							LoadAssembly(rpc);
						}
					}
				}
			} finally {
				projectContentsCurrentlyLoadingAssembly.Remove(pc);
			}
			
			if (pc.Project != null) {
				return LoadAssembly(((IProject)pc.Project).OutputAssemblyFullPath);
			} else if (pc is ReflectionProjectContent) {
				ReflectionProjectContent rpc = (ReflectionProjectContent)pc;
				if (rpc.IsGacAssembly)
					return LoadAssembly(new AssemblyName(rpc.AssemblyFullName), false);
				else
					return LoadAssembly(rpc.AssemblyLocation);
			} else {
				return null;
			}
		}

		public static IEnumerable<ICompletionItem> CreateListForXmlnsCompletion(IProjectContent projectContent)
		{
			List<XmlnsCompletionItem> list = new List<XmlnsCompletionItem>();
			
			foreach (IProjectContent content in projectContent.ThreadSafeGetReferencedContents()) {
				foreach (IAttribute att in content.GetAssemblyAttributes()) {
					if (att.PositionalArguments.Count == 2
					    && att.AttributeType.FullyQualifiedName == "System.Windows.Markup.XmlnsDefinitionAttribute") {
						list.Add(new XmlnsCompletionItem(att.PositionalArguments[0] as string, true));
					}
				}
				
				foreach (string @namespace in content.NamespaceNames) {
					if (!string.IsNullOrEmpty(@namespace))
						list.Add(new XmlnsCompletionItem(@namespace, content.AssemblyName));
				}
			}
			
			foreach (string @namespace in projectContent.NamespaceNames) {
				if (!string.IsNullOrEmpty(@namespace))
					list.Add(new XmlnsCompletionItem(@namespace, false));
			}
			
			list.Add(new XmlnsCompletionItem(MarkupCompatibilityNamespace, true));
			
			return list
				.Distinct(new XmlnsEqualityComparer())
				.OrderBy(item => item, new XmlnsComparer());
		}

		public string Search(UnknownIdentifierResolveResult rr, IProjectContent pc, List<IClass> results)
		{
			SearchAttributesWithName(results, pc, rr.Identifier);
			foreach (IProjectContent content in pc.ThreadSafeGetReferencedContents())
				SearchAttributesWithName(results, content, rr.Identifier);
			return rr.Identifier;
		}