C# ProjectItem.get_FileNames方法代码示例

        // <summary>
        //     Adds the DbContext templates for the given EDMX project item if the templates are
        //     installed and can be used, otherwise does nothing.
        // </summary>
        // <param name="edmxItem">The project item representing the EDMX model.</param>
        // <param name="useLegacyTemplate">A value indicating whether to use the legacy version of the template.</param>
        public void AddDbContextTemplates(ProjectItem edmxItem, bool useLegacyTemplate = true)
        {
            Debug.Assert(edmxItem != null, "edmxItem is null.");

            var templatePath = FindDbContextTemplate(edmxItem.ContainingProject, useLegacyTemplate);

            if (templatePath != null)
            {
                try
                {
                    var edmxFilePath = edmxItem.get_FileNames(1);
                    var edmxFileName = Path.GetFileNameWithoutExtension(edmxFilePath);
                    AddArtifactGeneratorWizard.EdmxUri = Utils.FileName2Uri(edmxFilePath);

                    if (!(edmxItem.ProjectItems ?? edmxItem.Collection).OfType<ProjectItem>().Any(
                        i => string.Equals(i.Name, edmxFileName + ".tt", StringComparison.OrdinalIgnoreCase)))
                    {
                        AddAndNestCodeGenTemplates(
                            edmxItem,
                            () => edmxItem.Collection.AddFromTemplate(templatePath, edmxFileName));
                    }
                }
                finally
                {
                    AddArtifactGeneratorWizard.EdmxUri = null;
                }
            }
        }

        internal VSProjectItemManager(DTE2 dte, ProjectItem projectItem, string fileNamePrefix)
        {
            this.dte = dte;
            this.projectItem = projectItem;

            this.filesAdded = new Dictionary<string, object>();
            this.filesCreated = new List<string>();

            if (this.projectItem != null)
            {
                if (string.IsNullOrEmpty(fileNamePrefix))
                {
                    fileNamePrefix = this.GetFileNamePrefix(projectItem.Name);
                }

                if (projectItem.FileCount > 0)
                {
                    try
                    {
                        this.fullFileNamePrefix = Path.GetDirectoryName(projectItem.get_FileNames(0)) + @"\" + fileNamePrefix;
                    }
                    catch (System.ArgumentException)
                    {
                        //vs.Php raise exception
                    }

                }
            }
        }

			public void OnItemRemoved(ProjectItem item)
			{
				P4Operations.EditFile(m_plugin.OutputPane, item.ContainingProject.FullName);

				for (int i = 0; i < item.FileCount; i++)
				{
					string name = item.get_FileNames((short)i);
					P4Operations.DeleteFile(m_plugin.OutputPane, name);
				}
			}

        private void RenameItem(ProjectItem item, string newFileName)
        {
            var templateFile = item.get_FileNames(1);

            var newFile = Path.Combine(Path.GetDirectoryName(templateFile), newFileName);
            File.Copy(templateFile, newFile);
            item.Collection.AddFromFile(newFile);

            item.Remove();
            File.Delete(templateFile);
        }

        /// <summary>
        /// Creates the file code merger.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <returns></returns>
        public IFileCodeMerger CreateFileCodeMerger(ProjectItem item)
        {
            if (item == null)
                throw new ArgumentNullException("item");

            IFileCodeMerger fileCodeMerger;
            string activeFileName = DTE.ActiveDocument.ProjectItem.get_FileNames(1);
            bool useDocumentMerger = GetTextDocument() != null;

            if (useDocumentMerger || item.get_FileNames(1) == activeFileName)
                fileCodeMerger = new LuaFileCodeMerger(item);
            else
                fileCodeMerger = new LuaExternalFileCodeMerger(item);

            return fileCodeMerger;
        }

		protected FileComponent VisitFile( ProjectItem item )
		{
			FileComponent file = null;

			if( Filter( item ) )
			{
				m_app.StatusBar.Text = "building stats for " + item.Name;

				file = new FileComponent( item.get_FileNames(0), item.Name );

				Walker walker = new Walker();
				walker.WalkFile( file, item );
			}

			return file;
		}

        public override void ProjectItemFinishedGenerating(ProjectItem projectItem)
        {
            if (!projectItem.Name.Contains(".g.cs"))
            {
                _entityRepoFile = projectItem;
            }
            else
            {
                //把生成文件变为实体文件的子文件。
                if (_entityRepoFile != null)
                {
                    projectItem.Remove();
                    _entityRepoFile.ProjectItems.AddFromFile(projectItem.get_FileNames(1));
                }
            }

            base.ProjectItemFinishedGenerating(projectItem);
        }

            public void OnItemAdded(ProjectItem item)
            {
                P4Operations.EditFile(m_plugin.OutputPane, item.ContainingProject.FullName);

                if (item.ProjectItems != null)
                {
                    for (int i = 0; i < item.FileCount; i++)
                    {
                        string name = item.get_FileNames((short)i);
                        P4Operations.AddFile(m_plugin.OutputPane, name);
                    }
                }
                else
                {
                    if(System.IO.File.Exists(item.Name))
                        P4Operations.AddFile(m_plugin.OutputPane, item.Name);
                }
            }

        private static void DoLaunchUpdateModelFromDatabaseWizard(ProjectItem projectItem)
        {
            var uri = Utils.FileName2Uri(projectItem.get_FileNames(1));
            ModelManager modelManager = PackageManager.Package.ModelManager;
            var efArtifactSet = modelManager.GetArtifactSet(uri);

            Debug.Assert(efArtifactSet != null, "Could not find artifact for the following file:" + uri.AbsolutePath);

            if (efArtifactSet != null)
            {
                var entityDesignArtifact = efArtifactSet.GetEntityDesignArtifact();

                Debug.Assert(
                    entityDesignArtifact != null,
                    "In LaunchUpdateModelWizardPage: DoLaunchUpdateModelFromDatabaseWizard, entityDesignArtifact is null");

                if (entityDesignArtifact != null)
                {
                    UpdateFromDatabaseEngine.UpdateModelFromDatabase(entityDesignArtifact);
                }
            }
        }

        public override void ProjectItemFinishedGenerating(ProjectItem projectItem)
        {
            if (!projectItem.Name.Contains(".g.cs"))
            {
                _entityFile = projectItem;

                //给父实体添加列表属性。
                if (_isChild)
                {
                    WriteChildrenProperty(projectItem);
                }
            }
            else
            {
                //把生成文件变为实体文件的子文件。
                if (_entityFile != null)
                {
                    projectItem.Remove();
                    _entityFile.ProjectItems.AddFromFile(projectItem.get_FileNames(1));
                }
            }

            base.ProjectItemFinishedGenerating(projectItem);
        }

 /// <summary>
 /// Invokes replace method on the provided objects
 /// </summary>
 /// <param name="codeFile">Code file to test</param>
 /// <param name="resFile">Resource file to use</param>
 /// <param name="hcs">Hardcoded string to use</param>
 /// <param name="expected">Expected test string</param>
 internal static void TestReplaceMethod(ProjectItem codeFile, string resourceFileName, BaseHardCodedString hcs, string expected, string resourceName)
 {
     string fileName = codeFile.get_FileNames(1);
     bool readOnly = false;
     try
     {
         readOnly = CommonMethods.ToggleReadOnly(fileName, false);
         ExtractToResourceActionSite refactorSite = new ExtractToResourceActionSite(hcs);
         ResourceFileCollection resources = new ResourceFileCollection(codeFile.ContainingProject,
             new FilterMethod(refactorSite.ActionObject.IsValidResourceFile));
         ResourceFile resFile = resources[resourceFileName];
         refactorSite.ExtractStringToResource(resFile, resourceName);
         TextDocument doc = ((EnvDTE.TextDocument)codeFile.Document.Object(null));
         EditPoint ep = doc.StartPoint.CreateEditPoint();
         string line = ep.GetLines(hcs.StartingLine + 1, hcs.StartingLine + 2);
         Assert.AreEqual(expected, line, "New line does not match the expected output");
     }
     finally
     {
         if (readOnly) CommonMethods.ToggleReadOnly(fileName, true);
     }
 }

 public static bool IsModelFile(ProjectItem projectItem)
 {
     var fullName = projectItem.get_FileNames(1);
     return IsModelFile(fullName);
 }

		/// <summary>
		/// Returns the item file name relative to the containing solution.
		/// </summary>
		public static string GetFilePathRelative(ProjectItem item)
		{
			Guard.ArgumentNotNull(item, "item");
			return GetFilePathRelative(item.DTE, item.get_FileNames(1));
		}

        private void BuildCacheSub(ProjectItem projectItem)
        {
            try
            {
                var k = projectItem.get_FileNames(1);
                if (!_projectItemCache.ContainsKey(k))
                    _projectItemCache.Add(k, projectItem);
                else
                    System.Diagnostics.Debug.Write(string.Empty);

                foreach (ProjectItem pItem in projectItem.ProjectItems)
                {
                    BuildCacheSub(pItem);
                }

            }
            catch (Exception ex)
            {
                throw;
            }
        }

 private ArrayList GetFileListFromProjectTree(ProjectItem item)
 {
     ArrayList filesList = new ArrayList();
     if (item == null) return filesList;
     if (item.Kind == EnvDTE.Constants.vsProjectItemKindPhysicalFile)
     {
         for (short i = 1; i <= item.FileCount; i++)
         {
             string filename = item.get_FileNames(i);
             filesList.Add(filename);
         }
     }
     else if (item.Kind == EnvDTE.Constants.vsProjectItemKindPhysicalFolder)
     {
         foreach (ProjectItem childItem in item.ProjectItems)
         {
             filesList.AddRange(GetFileListFromProjectTree(childItem));
         }
     }
     return filesList;
 }