C# ICompilationUnit.Any方法代码示例

			public ParseInformation ParseFile(IProjectContent parentProjectContent, ITextBuffer fileContent)
			{
				if (parser == null)
					return null;
				
				if (fileContent == null) {
					// GetParseableFileContent must not be called inside any lock
					// (otherwise we'd risk deadlocks because GetParseableFileContent must invoke on the main thread)
					fileContent = GetParseableFileContent(fileName);
				}
				
				ITextBufferVersion fileContentVersion = fileContent.Version;
				List<IProjectContent> projectContents;
				lock (this) {
					if (this.disposed)
						return null;
					
					if (fileContentVersion != null && this.bufferVersion != null && this.bufferVersion.BelongsToSameDocumentAs(fileContentVersion)) {
						if (this.bufferVersion.CompareAge(fileContentVersion) >= 0) {
							// Special case: (necessary due to parentProjectContent optimization)
							// Detect when a file belongs to multiple projects but the ParserService hasn't realized
							// that, yet. In this case, do another parse run to detect all parent projects.
							if (!(parentProjectContent != null && this.oldUnits.Length == 1 && this.oldUnits[0].ProjectContent != parentProjectContent)) {
								return this.parseInfo;
							}
						}
					}
					
					if (parentProjectContent != null && (oldUnits.Length == 0 || (oldUnits.Length == 1 && oldUnits[0].ProjectContent == parentProjectContent))) {
						// Optimization: if parentProjectContent is specified and doesn't conflict with what we already know,
						// we will use it instead of doing an expensive GetProjectContents call.
						projectContents = new List<IProjectContent>();
						projectContents.Add(parentProjectContent);
					} else {
						projectContents = GetProjectContents(fileName);
					}
				}
				// We now leave the lock to do the actual parsing.
				// This is done to allow IParser implementations to invoke methods on the main thread without
				// risking deadlocks.
				
				// parse once for each project content that contains the file
				ICompilationUnit[] newUnits = new ICompilationUnit[projectContents.Count];
				ICompilationUnit resultUnit = null;
				for (int i = 0; i < newUnits.Length; i++) {
					IProjectContent pc = projectContents[i];
					try {
						newUnits[i] = parser.Parse(pc, fileName, fileContent);
					} catch (Exception ex) {
						throw new ApplicationException("Error parsing " + fileName, ex);
					}
					if (i == 0 || pc == parentProjectContent)
						resultUnit = newUnits[i];
				}
				lock (this) {
					if (this.disposed)
						return null;
					
					// ensure we never go backwards in time (we need to repeat this check after we've reacquired the lock)
					if (fileContentVersion != null && this.bufferVersion != null && this.bufferVersion.BelongsToSameDocumentAs(fileContentVersion)) {
						if (this.bufferVersion.CompareAge(fileContentVersion) >= 0) {
							if (parentProjectContent != null && parentProjectContent != parseInfo.CompilationUnit.ProjectContent) {
								ICompilationUnit oldUnit = oldUnits.FirstOrDefault(o => o.ProjectContent == parentProjectContent);
								if (oldUnit != null)
									return new ParseInformation(oldUnit);
							}
							return this.parseInfo;
						}
					}
					
					ParseInformation newParseInfo = new ParseInformation(resultUnit);
					
					for (int i = 0; i < newUnits.Length; i++) {
						IProjectContent pc = projectContents[i];
						// update the compilation unit
						ICompilationUnit oldUnit = oldUnits.FirstOrDefault(o => o.ProjectContent == pc);
						pc.UpdateCompilationUnit(oldUnit, newUnits[i], fileName);
						ParseInformation newUnitParseInfo = (newUnits[i] == resultUnit) ? newParseInfo : new ParseInformation(newUnits[i]);
						RaiseParseInformationUpdated(new ParseInformationEventArgs(fileName, pc, oldUnit, newUnitParseInfo));
					}
					
					// remove all old units that don't exist anymore
					foreach (ICompilationUnit oldUnit in oldUnits) {
						if (!newUnits.Any(n => n.ProjectContent == oldUnit.ProjectContent)) {
							oldUnit.ProjectContent.RemoveCompilationUnit(oldUnit);
							RaiseParseInformationUpdated(new ParseInformationEventArgs(fileName, oldUnit.ProjectContent, oldUnit, null));
						}
					}
					
					this.bufferVersion = fileContentVersion;
					this.oldUnits = newUnits;
					this.parseInfo = newParseInfo;
					return newParseInfo;
				}
			}