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(, 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 = )
        {
            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(, 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;
        }

    }

+ 去掉.

　　:string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);

+文件名称是否包含标识字符串：

        public bool isFileNameContainsFlags(string fileName,List<string> contentFlags)
        {
            bool isContain = false;
            if (contentFlags == null || contentFlags.Count == )
            {
                isContain = true;
            }
            else
            {
                foreach (string flag in contentFlags)
                {
                    if (fileName.Contains(flag.Trim()))
                    {
                        isContain = true;
                        break;
                    }
                }
            }
            return isContain;
        }

+过滤特殊字符

/// <summary>
        /// 过滤掉非法字符和点字符
        /// </summary>
        /// <param name="directoryName"></param>
        /// <returns></returns>
        public String DirectoryNameFilter(String directoryName)
        {
            string invalidChars = "\\/:*?\"<>|.";    //自定义非法字符（比系统的多了个.）
            foreach (char c in invalidChars)
            {
                directoryName = directoryName.Replace(c.ToString(), string.Empty);
            }
            return directoryName;
        }

        /// <summary>
        /// 过滤掉非法字符
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public String NameFilter(String name)
        {
            string invalidChars = "\\/:*?\"<>|";    //自定义非法字符（比系统的多了个.）
            foreach (char c in invalidChars)
            {
                name = name.Replace(c.ToString(), string.Empty);
            }
            return name;
        }

+打开文件夹浏览器

        /// <summary>
        /// 打开文件夹浏览器
        /// </summary>
        /// <param name="dirPath"></param>
        private string ShowFolderDialog(string dirPath)
        {
            string forderPath = dirPath.Trim();
            if (!string.IsNullOrEmpty(forderPath))
            {
                this.fld_dlg.SelectedPath = forderPath;
            }

            DialogResult dlgResult = fld_dlg.ShowDialog();
            if (dlgResult == DialogResult.OK)
            {
                forderPath = fld_dlg.SelectedPath;
            }
            return forderPath;
        }

+批量修改文件名

        /// <summary>
        /// 修改文件名
        /// </summary>
        /// <param name="baseDirPath">基路径</param>
        /// <param name="partName">修改文件名</param>
        /// <param name="changeType">类型(0：替换,1:+前面，2：+后面)</param>
        /// <param name="isRecursion">是递归</param>
        /// <returns></returns>
        public bool ChangeFilesName(string baseDirPath, string partName, int changeType, bool isRecursion)
        {
            bool isSuccess = true;
            try
            {
                this.ConfirmPathExist(baseDirPath);
                List<string> fileNames = this.getChildFiles(baseDirPath);
                switch(changeType)
                {
                    case :
                        int i = ;
                        foreach(string fName in fileNames)
                        {
                            string srcFullName = Path.Combine(baseDirPath,fName);
                            FileInfo fInfo = new FileInfo(srcFullName);
                            string dstFileName = partName + i + Path.GetExtension(fName);
                            string dstFullName = Path.Combine(baseDirPath, dstFileName);
                            fInfo.MoveTo(dstFullName);
                            i++;
                        }
                        break;
                    case :
                        foreach(string fName in fileNames)
                        {
                            string srcFullName = Path.Combine(baseDirPath,fName);
                            FileInfo fInfo = new FileInfo(srcFullName);
                            string dstFileName = partName + fName;
                            string dstFullName = Path.Combine(baseDirPath, dstFileName);
                            fInfo.MoveTo(dstFullName);
                        }
                        break;
                    case :
                        foreach (string fName in fileNames)
                        {
                            string srcFullName = Path.Combine(baseDirPath, fName);
                            FileInfo fInfo = new FileInfo(srcFullName);
                            string dstFileName = Path.GetFileNameWithoutExtension(fName) + partName + Path.GetExtension(fName);
                            string dstFullName = Path.Combine(baseDirPath, dstFileName);
                            fInfo.MoveTo(dstFullName);
                        }
                        break;
                    default:
                        break;
                }
                if (isRecursion)
                {
                    List<string> dirFullNames = getChildDirectories(baseDirPath, true);
                    foreach(string dirFullName in dirFullNames)
                    {
                        ChangeFilesName(dirFullName, partName, changeType, isRecursion);
                    }
                }
            }
            catch (Exception ex)
            {
                isSuccess = false;
            }
            return isSuccess;
        }

+删除、清空目录

        private void DeleteDirector(string path)
        {
            if (!Directory.Exists(path))
                return;

            string[] subdir = Directory.GetDirectories(path);
            foreach (string dir in subdir)
                DeleteDirector(dir);

            string[] files = Directory.GetFiles(path);

            foreach (string file in files)
            {
                File.Delete(file);
            }
            Directory.Delete(path);
        }

        /// <summary>
        /// 清空目录
        /// </summary>
        /// <param name="path">目录全路径</param>
        private void ClearDirectory(string path)
        {
            if (!Directory.Exists(path))
                return;

            string[] files = Directory.GetFiles(path);
            foreach (string file in files)
            {
                try
                {
                    File.Delete(file);
                }
                catch (Exception e)
                {
                    _logger.Info("删除文件失败: ", e);
                }
            }

            string[] dirs = Directory.GetDirectories(path);
            foreach (string dir in dirs)
            {
                try
                {
                    ClearDirectory(dir);
                    Directory.Delete(dir);
                }
                catch (Exception e)
                {
                    _logger.Info("删除目录失败: ", e);
                }
            }
        }

更多：http://www.cnblogs.com/shenchao/p/5431163.html