C# Solution.FindProjectItem方法代码示例

        /// <summary>
        /// Adds a class file to the relevant visual studio solution
        /// </summary>
        /// <param name="sln">The solution to add the file to</param>
        /// <param name="featureFile">The feature file path that the class file is for.</param>
        /// <param name="classFile">The class file to be added</param>
        /// <returns>true if the class was added succesfully</returns>
        public bool AddToSolution(Solution sln, string featureFile, string classFile)
        {
            //Locate feature file in solution
            ProjectItem prjItem = sln.FindProjectItem(featureFile);
            if (prjItem == null)
                return false;

            //Add the class file into the same project that conatins the feature file.
            prjItem.ContainingProject.ProjectItems.AddFromFile(classFile);
            return true;
        }

		/////////////////////////////////////////////////////////////////////////////

		protected void Initialize( string inputFilePath )
		{
			// ******
			if( null == errListProvider ) {
				//
				// custom tool FAILS if we try to do this in the ctor
				//
				errListProvider = new ErrorListProvider( GlobalServiceProvider );
			}
	
			// ******
			solution = Dte.Solution;
			if( null == solution ) {
				return;
			}

			// ******
			templateItem = solution.FindProjectItem( inputFilePath );
			templateConfigMgr = templateItem.ConfigurationManager;
			templateProject = templateItem.ContainingProject;

			//IEnumerable<Project> projects = GetAllProjects( solution );

			// ******
			//
			// is always null - this is references elsewhere (null is ok)
			//
			projConfig = templateProject.ConfigurationManager.ActiveConfiguration;
		}

        static bool TryGetProjectItem(Solution solution, string path, out ProjectItem item)
        {
            item = null;

            if (solution != null)
                item = solution.FindProjectItem(path);

            // if we found project item, but don't have project items, attempt to find
            // item recursively
            if (item != null && item.ProjectItems == null)
                item = FindProjectItemRecursive(solution, path);

            return item != null;
        }

        /// <summary>
        /// Saves content accumulated by this transformation to the output files.
        /// </summary>
        /// <param name="outputFiles">
        /// <see cref="OutputFile"/>s that need to be added to the <paramref name="solution"/>.
        /// </param>
        /// <param name="solution">
        /// Current Visual Studio <see cref="Solution"/>.
        /// </param>
        /// <param name="projects">
        /// All <see cref="Project"/>s in the current <paramref name="solution"/>.
        /// </param>
        /// <param name="template">
        /// A <see cref="ProjectItem"/> that represents T4 template being transformed.
        /// </param>
        /// <remarks>
        /// Note that this method currently cannot distinguish between files that are
        /// already in a Database project and files that are simply displayed with 
        /// "Show All Files" option. Database project model makes these items appear 
        /// as if they were included in the project.
        /// </remarks>
        private static void UpdateOutputFiles(IEnumerable<OutputFile> outputFiles, Solution solution, IEnumerable<Project> projects, ProjectItem template)
        {
            foreach (OutputFile output in outputFiles)
            {
                UpdateOutputFile(output); // Save the output file before we can add it to the solution

                ProjectItem outputItem = solution.FindProjectItem(output.File);
                ProjectItems collection = FindProjectItemCollection(output, projects, template);

                if (outputItem == null)
                {
                    // If output file has not been added to the solution
                    outputItem = collection.AddFromFile(output.File);
                }
                else if (!Same(outputItem.Collection, collection))
                {
                    // If the output file moved from one collection to another
                    string backupFile = output.File + ".bak";
                    File.Move(output.File, backupFile); // Prevent unnecessary source control operations
                    outputItem.Delete(); // Remove doesn't work on "DependentUpon" items
                    File.Move(backupFile, output.File);

                    outputItem = collection.AddFromFile(output.File);
                }

                SetProjectItemProperties(outputItem, output);
                SetProjectItemBuildProperties(outputItem, output);
                AddProjectItemReferences(outputItem, output);
            }
        }

        /// <summary>
        /// Deletes output files that were not generated by the current session.
        /// </summary>
        /// <param name="outputFiles">
        /// A read-only collection of <see cref="OutputFile"/> objects.
        /// </param>
        /// <param name="solution">
        /// Current Visual Studio <see cref="Solution"/>.
        /// </param>
        /// <param name="template">
        /// A <see cref="ProjectItem"/> that represents T4 template being transformed.
        /// </param>
        private static void DeleteOldOutputs(IEnumerable<OutputFile> outputFiles, Solution solution, ProjectItem template)
        {
            // If previous transformation produced a log of generated ouptut files
            string logFile = GetLogFileName();
            if (File.Exists(logFile))
            {
                // Delete all files recorded in the log that were not regenerated
                foreach (string line in File.ReadAllLines(logFile))
                {
                    string relativePath = line.Trim();

                    // Skip blank lines
                    if (relativePath.Length == 0)
                    {
                        continue;
                    }

                    // Skip comments
                    if (relativePath.StartsWith("//", StringComparison.OrdinalIgnoreCase))
                    {
                        continue;
                    }

                    string absolutePath = Path.GetFullPath(relativePath);

                    // Skip the file if it was regenerated during current transformation
                    if (outputFiles.Any(output => OutputInfo.SamePath(output.File, absolutePath)))
                    {
                        continue;
                    }

                    // The file wasn't regenerated, delete it from the solution, source control and file storage
                    ProjectItem projectItem = solution.FindProjectItem(absolutePath);
                    if (projectItem != null)
                    {
                        DeleteProjectItem(projectItem);
                    }
                }
            }

            // Also delete all project items nested under template if they weren't regenerated
            string templateFileName = Path.GetFileNameWithoutExtension(Host.TemplateFile);
            foreach (ProjectItem childProjectItem in template.ProjectItems)
            {
                // Skip the file if it has the same name as the template file. This will prevent constant
                // deletion and adding of the main output file to the project, which is slow and may require
                // the user to check the file out unnecessarily.
                if (templateFileName == Path.GetFileNameWithoutExtension(childProjectItem.Name))
                {
                    continue;
                }

                // If the file wan't regenerated, delete it from the the solution, source control and file storage
                if (!outputFiles.Any(o => OutputInfo.SamePath(o.File, childProjectItem.get_FileNames(1))))
                {
                    childProjectItem.Delete();
                }
            }
        }