C# ProjectItem.FileName方法代码示例

		public void RemoveDependencies(ProjectItem projectItem)
		{
			var filename = projectItem.FileName();

			if (Dependencies.ContainsKey(filename))
				Dependencies.Remove(filename);

			RemoveDependenciesForFile(projectItem);
		}

		public bool CheckDependencies(ProjectItem projectItem)
		{
			var filename = projectItem.FileName();

			var engine = EngineResolver.GetEngineByFilename(filename);

			if (engine == null)
				return false;

			var contents = FileHandler.GetContents(filename);

			SaveDependencies(projectItem, filename, contents, engine);

			return true;
		}

		public IEnumerable<FileAssociation> Run(ProjectItem projectItem)
		{
			var filename = projectItem.FileName();
			var engine = EngineResolver.GetEngineByFilename(filename);
			var result = new List<FileAssociation>();

			TaskList.Remove(filename);

			if (engine != null)
				result.AddRange(ProcessEngine(projectItem, filename, engine));

			var associations = RunDependencies(filename);

			if (associations != null)
				result.AddRange(associations);

			return result;
		}

        public void CheckForConfigRefresh(ProjectItem projectItem)
        {
            string fullFileName = projectItem.FileName();

            if (this.dependentFiles.ContainsKey(fullFileName)) {
                foreach (string configFile in this.dependentFiles[fullFileName]
                    .Distinct(StringComparer.InvariantCultureIgnoreCase) // prevent the same config file from being fired multiple times
                    .ToArray()) {
                    // ToArray to prevent "Collection Modified" exceptions
                    this.Refresh(configFile);
                }
            }

            if (projectItem.ProjectItems != null) {
                foreach (ProjectItem projectItemInner in projectItem.ProjectItems.Cast<ProjectItem>().ToArray()) {
                    // ToArray to prevent "Collection Modified" exceptions
                    this.CheckForConfigRefresh(projectItemInner);
                }
            }
        }

 private void ProjectItemsEvents_ItemRenamed(ProjectItem projectItem, string oldFileName)
 {
     if (EngineManager.IsTransformed(projectItem.FileName()))
     {
         // Now a chirp file
         this.ProjectItemsEvents_ItemAdded(projectItem);
     } else if (EngineManager.IsTransformed(oldFileName)) {
         try {
             VSProjectItemManager.DeleteAllItems(projectItem.ProjectItems);
             this.tasks.Remove(oldFileName);
         } catch (Exception e) {
             this.OutputWindowWriteText("Exception was thrown when trying to rename file.\n" + e.ToString());
         }
     }
 }

        private void ProjectItemsEvents_ItemRemoved(ProjectItem projectItem)
        {
            string fileName = projectItem.FileName();
            this.tasks.Remove(fileName);

            if (T4Engine.Handles(fileName) > 0) {
                this.T4Engine.Run(fileName, projectItem);
            }
        }

		public void ItemClosed(ProjectItem projectItem)
		{
			Chirp.TaskList.Remove(projectItem.FileName());
		}

        /// <summary>
        /// build a dictionary that has the files that could change as the key.
        /// for the value it is a LIST of config files that need updated if it does change.
        /// so, when a .less.css file changes, we look in the list and rebuild any of the configs associated with it.
        /// if a config file changes...this rebuild all of this....
        /// </summary>
        /// <param name="projectItem">project Item</param>
        internal void ReloadFileDependencies(ProjectItem projectItem)
        {
            string configFileName = projectItem.FileName();

            // remove all current dependencies for this config file...
            foreach (string key in this.dependentFiles.Keys.ToArray()) {
                List<string> files = this.dependentFiles[key];
                if (files.Remove(configFileName) && files.Count == 0) {
                    this.dependentFiles.Remove(key);
                }
            }

            IEnumerable<string> dependents;
            if (IsLessFile(configFileName))
            {
                var root = System.IO.Path.GetDirectoryName(projectItem.ContainingProject.FullName);
                var text = System.IO.File.ReadAllText(configFileName);
                var imports = LessEngine.FindDependencies(configFileName, text, root);
                dependents = imports.Where(x => x.IsFile).Select(x => x.LocalPath);

            } else {
                var fileGroups = this.LoadConfigFileGroups(configFileName);
                dependents = fileGroups.SelectMany(x => x.Files).Select(x => x.Path);

            }

            foreach (var file in dependents) {
                if (!this.dependentFiles.ContainsKey(file)) {
                    this.dependentFiles.Add(file, new List<string> { configFileName });
                } else {
                    this.dependentFiles[file].Add(configFileName);
                }
            }
        }