C#:文件、路径（Path_File）

    public class Path_File
    {
        public string AppPath
        {
            get
            {
                return AppDomain.CurrentDomain.BaseDirectory;
            }
        }

        public Path_File()
        {
           
        }

        /// <summary>
        /// 查找指定路径下的文件夹
        /// </summary>
        /// <param name="parentDirPath">指定路径</param>
        /// <param name="findDir">文件夹</param>
        /// <param name="findDirPath">文件夹路径</param>
        /// <returns>是否找到</returns>
        public bool FindDirectory(string parentDirPath, string findDir, ref string findDirPath, bool isRecursion = true)
        {
            bool isFind = false;
            try
            {
                DirectoryInfo folder = new DirectoryInfo(parentDirPath.Trim());  //指定搜索文件夹
                if (folder.Exists && !parentDirPath.Contains(findDir))//存在 文件夹
                {
                    DirectoryInfo[] listDirInfos = folder.GetDirectories();//取得给定文件夹下的文件夹组
                    if (listDirInfos != null)
                    {
                        foreach (DirectoryInfo dirInfo in listDirInfos)//遍历
                        {
                            if (dirInfo.Name.ToLower() == findDir.Trim().ToLower())
                            {
                                findDirPath = dirInfo.FullName;
                                isFind = true;
                                break;
                            }
                        }
                        if (!isFind && isRecursion)  //目录内未找到切递归子目录查找
                        {
                            foreach (DirectoryInfo dirInfo in listDirInfos)//遍历
                            {
                                string newParentDirPath = Path.Combine(parentDirPath, dirInfo.Name);
                                isFind = FindDirectory(newParentDirPath, findDir, ref findDirPath, isRecursion);
                                if (isFind)
                                {
                                    break;
                                }
                            }
                        }
                    }
                }
                else
                {
                    int count = parentDirPath.LastIndexOf(findDir) + findDir.Length;
                    findDirPath = parentDirPath.Substring(0, count);
                    isFind = true;
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return isFind;
        }

        /// <summary>
        /// 获取指定目录下的子目录名集
        /// </summary>
        /// <param name="parentDirPath">指定目录</param>
        /// <returns>子目录名集</returns>
        public List<string> getChildDirectories(string parentDirPath,bool isFullName = false)
        {
            List<string> listDirs = new List<string>();
            DirectoryInfo folder = new DirectoryInfo(parentDirPath.Trim());  //指定搜索文件夹
            if (folder.Exists)//存在 文件夹
            {
                DirectoryInfo[] listDirInfos = folder.GetDirectories();//取得给定文件夹下的文件夹组
                if (listDirs != null)
                {
                    foreach (DirectoryInfo dirInfo in listDirInfos)//遍历
                    {
                        if (isFullName)
                        {
                            listDirs.Add(dirInfo.FullName);
                        }
                        else
                        {
                            listDirs.Add(dirInfo.Name);
                        }
                    }
                }
            }
            return listDirs;
        }

        /// <summary>
        /// 获取指定目录下的子文件名集
        /// </summary>
        /// <param name="parentDirPath">指定目录</param>
        /// <returns>子目录名集</returns>
        public List<string> getChildFiles(string parentDirPath, bool isFullName = false)
        {
            List<string> listFiles = new List<string>();
            DirectoryInfo folder = new DirectoryInfo(parentDirPath.Trim());  //指定搜索文件夹
            if (folder.Exists)//存在 文件夹
            {
                FileInfo[] listFileInfos = folder.GetFiles();//取得给定文件夹下的文件夹组
                if (listFiles != null)
                {
                    foreach (FileInfo fileInfo in listFileInfos)//遍历
                    {
                        if (isFullName)
                        {
                            listFiles.Add(fileInfo.FullName);
                        }
                        else
                        {
                            listFiles.Add(fileInfo.Name);
                        }
                    }
                }
            }
            return listFiles;
        }

        /// <summary>
        /// 复制文件夹
        /// </summary>
        /// <param name="sourcePath">源目录</param>
        /// <param name="targetPath">目的目录</param>
        public bool CopyFolder(string sourcePath, string targetPath)
        {
            bool isSuccess = true;
            try
            {
                DirectoryInfo sourceInfo = new DirectoryInfo(sourcePath);
                if (sourceInfo.Exists)      //源目录存在
                {
                    DirectoryInfo targetInfo = new DirectoryInfo(targetPath);
                    if (!targetInfo.Exists)
                    {
                        targetInfo.Create();
                    }

                    FileInfo[] files = sourceInfo.GetFiles();   //拷贝文件
                    foreach (FileInfo file in files)
                    {
                        file.CopyTo(Path.Combine(targetPath, file.Name), true);
                    }

                    DirectoryInfo[] childDirInfos = sourceInfo.GetDirectories(); //拷贝目录
                    foreach (DirectoryInfo dirInfo in childDirInfos)
                    {
                        CopyFolder(Path.Combine(sourcePath, dirInfo.Name), Path.Combine(targetPath, dirInfo.Name));
                    }
                }
            }
            catch (Exception)
            {
                isSuccess = false;
            }
            return isSuccess;
        }

        /// <summary>
        /// 确认路径存在（不存在则创建路径）
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public bool ConfirmPathExist(string path)
        {
            bool isExist = true;
            try
            {
                DirectoryInfo folder = new DirectoryInfo(path.Trim());
                if (!folder.Exists)//不存在 文件夹
                {
                    folder.Create();
                }
            }
            catch(Exception ex)
            {
                isExist = false;
            }
            return isExist;
        }

        /// <summary>
        /// 删除指定文件
        /// </summary>
        /// <param name="fFullName"></param>
        /// <returns></returns>
        public bool DeleteFile(string fFullName)
        {
            bool isSuccess = true;
            try
            {
                FileInfo fInfo = new FileInfo(fFullName);
                if (fInfo.Exists)//存在 文件
                {
                    fInfo.Delete();
                }
            }
            catch (Exception ex)
            {
                isSuccess = false;
            }
            return isSuccess;
        }

        /// <summary>
        /// 删除指定文件夹
        /// </summary>
        /// <param name="folderPath"></param>
        /// <returns></returns>
        public bool DeleteFolder(string folderPath)
        {
            bool isSuccess = true;
            try
            {
                DirectoryInfo dirInfo = new DirectoryInfo(folderPath);
                if (dirInfo.Exists)//存在 文件夹
                {
                    dirInfo.Delete(true);
                }
            }
            catch (Exception ex)
            {
                isSuccess = false;
            }
            return isSuccess;
        }

        /// <summary>
        /// 替换路径下文件名中的标识
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="oldTag"></param>
        /// <param name="newTag"></param>
        /// <returns></returns>
        public bool ReplaceTagFromName(string filePath, string oldTag, string newTag,bool isIgnorCase = false)
        {
            bool isSuccess = true;
            try
            {
                DirectoryInfo dirInfo = new DirectoryInfo(filePath);
                if (!dirInfo.Exists)
                {
                    dirInfo.Create();
                }
                FileInfo[] fileInfos = dirInfo.GetFiles();
                foreach (FileInfo fileInfo in fileInfos)
                {
                    string name = Path.GetFileNameWithoutExtension(fileInfo.Name);
                    if (isIgnorCase)
                    {
                        name = name.ToLower();
                        oldTag = oldTag.ToLower();
                    }
                    string newName = name.Replace(oldTag, newTag);
                    string newFileName = newName + fileInfo.Extension;
                    string fullName = Path.Combine(filePath,newFileName);
                    fileInfo.MoveTo(fullName);
                }
            }
            catch (Exception ex)
            {
                isSuccess = false;
            }
            return isSuccess;
        }

        /// <summary>
        /// 更级名称
        /// </summary>
        /// <param name="fileFullName"></param>
        /// <param name="i"></param>
        /// <returns></returns>
        public string getUniqueName(string fileFullName, int i = 0)
        {
            string fileName = fileFullName;
            try
            {
                FileInfo fInfo = new FileInfo(fileFullName);
                if (fInfo.Exists)
                {
                    string ext = fInfo.Extension;
                    int length = fileFullName.LastIndexOf(ext);
                    fileName = fInfo.FullName.Substring(0, length) + i + ext;
                    //string fileNamePath = Path.GetDirectoryName(fileFullName);
                    //string fileNameWithoutExt = Path.GetFileNameWithoutExtension(fileFullName); //仅获取文件名，不包含路径
                    //fileName = fileNameWithoutExt + i + ext;
                    //fileName = Path.Combine(fileNamePath,fileName);
                    fInfo = new FileInfo(fileName);
                    if (fInfo.Exists)
                    {
                        i++;
                        fileName = getUniqueName(fileFullName, i);
                    }
                }
            }
            catch
            {
            }
            return fileName;
        }

        /// <summary>
        /// 更级名称
        /// </summary>
        /// <param name="fileFullName"></param>
        /// <param name="i"></param>
        /// <returns></returns>
        public bool UpdateName(string fileFullName)
        {
            bool isSuccess = true; 
            try
            {
                string newName = getUniqueName(fileFullName);
                FileInfo fInfo = new FileInfo(fileFullName);
                if (fInfo.Exists)
                {
                    fInfo.MoveTo(newName);
                }
            }
            catch
            {
                isSuccess = false; 
            }
            return isSuccess;
        }


        public bool SaveInfos(string fileFullName, Dictionary<string, string> booksInfo, string tag = "|")
        {
            bool isSuccess = true;
            try
            {
                FileInfo fInfo = new FileInfo(fileFullName);
                FileStream fStream = null;
                if (!fInfo.Exists)
                {
                    fStream = fInfo.Create();
                }
                else
                {
                    fStream = fInfo.Open(FileMode.CreateNew,FileAccess.ReadWrite);
                }
                StreamWriter sWrite = new StreamWriter(fStream);//(fileFullName, true);
                foreach (string bookId in booksInfo.Keys)
                {
                    string lineInfo = bookId + tag + booksInfo[bookId];
                    sWrite.WriteLine(lineInfo);
                    sWrite.Flush();
                }
                sWrite.Close();
            }
            catch
            {
                isSuccess = false;
            }
            return isSuccess;
        }

        public bool AppendInfo(string fileFullName,string Info)
        {
            bool isSuccess = true;
            try
            {
                FileInfo fInfo = new FileInfo(fileFullName);
                FileStream fStream = null;
                if (!fInfo.Exists)
                {
                    fStream = fInfo.Create();
                }
                else
                {
                    fStream = fInfo.Open(FileMode.Append, FileAccess.ReadWrite);
                }
                StreamWriter sWrite = new StreamWriter(fStream);
                sWrite.WriteLine(Info);
                sWrite.Flush();
                sWrite.Close();
            }
            catch
            {
                isSuccess = false;
            }
            return isSuccess;
        }

    }