[No0000DC]C# FileHelper 本地文件、文件夹操作类封装FileHelper

using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using Shared;

namespace PublishPart.Helpers
{
    public static class FileHelper
    {
        #region  Methods

        /// <summary>
        ///     向文本文件的尾部追加内容
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="content">写入的内容</param>
        public static void AppendText(string filePath, string content)
        {
            File.AppendAllText(filePath, content);
        }


        /// <summary>
        ///     清空指定目录下所有文件及子目录,但该目录依然保存.
        /// </summary>
        /// <param name="directoryPath">指定目录的绝对路径</param>
        public static void ClearDirectory(string directoryPath)
        {
            if (IsExistDirectory(directoryPath))
            {
                //删除目录中所有的文件
                var filePaths = GetFileNames(directoryPath);
                foreach (var filePath in filePaths)
                    DeleteFile(filePath);

                //删除目录中所有的子目录
                var directoryPaths = GetDirectories(directoryPath);
                foreach (var oneDirectoryPath in directoryPaths)
                    DeleteDirectory(oneDirectoryPath);
            }
        }


        /// <summary>
        ///     清空文件内容
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static void ClearFile(string filePath)
        {
            //删除文件
            File.Delete(filePath);

            //重新创建该文件
            CreateFile(filePath);
        }


        /// <summary>
        ///     检测指定目录中是否存在指定的文件,若要搜索子目录请使用重载方法.
        /// </summary>
        /// <param name="directoryPath">指定目录的绝对路径</param>
        /// <param name="searchPattern">
        ///     模式字符串，"*"代表0或N个字符，"?"代表1个字符。
        ///     范例："Log*.xml"表示搜索所有以Log开头的Xml文件。
        /// </param>
        public static bool Contains(string directoryPath, string searchPattern)
        {
            try
            {
                //获取指定的文件列表
                var fileNames = GetFileNames(directoryPath, searchPattern, false);

                //判断指定文件是否存在
                return fileNames.Length != 0;
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return false;
            }
        }

        /// <summary>
        ///     检测指定目录中是否存在指定的文件
        /// </summary>
        /// <param name="directoryPath">指定目录的绝对路径</param>
        /// <param name="searchPattern">
        ///     模式字符串，"*"代表0或N个字符，"?"代表1个字符。
        ///     范例："Log*.xml"表示搜索所有以Log开头的Xml文件。
        /// </param>
        /// <param name="isSearchChild">是否搜索子目录</param>
        public static bool Contains(string directoryPath, string searchPattern, bool isSearchChild)
        {
            try
            {
                //获取指定的文件列表
                var fileNames = GetFileNames(directoryPath, searchPattern, true);

                //判断指定文件是否存在
                return fileNames.Length != 0;
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return false;
            }
        }


        /// <summary>
        ///     将源文件的内容复制到目标文件中
        /// </summary>
        /// <param name="sourceFilePath">源文件的绝对路径</param>
        /// <param name="destFilePath">目标文件的绝对路径</param>
        public static void Copy(string sourceFilePath, string destFilePath)
        {
            File.Copy(sourceFilePath, destFilePath, true);
        }


        /// <summary>
        ///     将一个目录的文件拷贝到另外一个目录去
        /// </summary>
        /// <param name="srcPath">源目录</param>
        /// <param name="aimPath">目标目录</param>
        /// <param name="flag">是否允许覆盖同名文件</param>
        /// <param name="version">当出现多次调用此方法的时候，能够重命名多次，比如xxx.1.old,xxx.2.old</param>
        public static void CopyDir(string srcPath, string aimPath, bool flag, int version)
        {
            // 检查目标目录是否以目录分割字符结束如果不是则添加之
            if (aimPath[aimPath.Length - 1] != Path.DirectorySeparatorChar)
                aimPath += Path.DirectorySeparatorChar;

            // 判断目标目录是否存在如果不存在则新建之
            CreateDirectory(aimPath);

            // 得到源目录的文件列表，该里面是包含文件以及目录路径的一个数组
            // 如果你指向copy目标文件下面的文件而不包含目录请使用下面的方法
            var fileList = Directory.GetFileSystemEntries(srcPath);

            // 遍历所有的文件和目录
            foreach (var file in fileList)
                try
                {
                    // 如果这是一个目录，并且不是update目录，递归
                    if (Directory.Exists(file))
                    {
                        var path = Path.GetDirectoryName(file);
                        if (path != null)
                        {
                            var dirName = path.Split('\');
                            if (dirName[dirName.Length - 1].ToLower() != "update")
                                CopyDir(file, aimPath + Path.GetFileName(file), flag, version);
                        }
                    }

                    // 否则直接Copy文件(不拷贝update.xml文件)
                    else if (!file.ToLower().Contains("update.xml"))
                    {
                        //如果是pdb文件，直接忽略
                        if (file.Contains(".pdb") || file.Contains(".vshost.exe"))
                            continue;
                        //如果文件是dll或者exe文件，则可能是正在使用的文件，不能直接替换
                        if (file.ToLower().Contains(".exe") || file.ToLower().Contains(".dll") ||
                            file.ToLower().Contains(".pdb"))
                        {
                            var exist = false;

                            //正在使用的文件将不能拷贝
                            var onUsedFiles = AppDomain.CurrentDomain.GetAssemblies();


                            foreach (var onUsedFile in onUsedFiles)
                            {
                                var filename = onUsedFile.ManifestModule.Name;

                                //正在使用的文件
                                if (file.Contains(filename))
                                {
                                    //先判断这个文件存在
                                    if (Contains(aimPath, Path.GetFileName(file)))
                                        File.Move(aimPath + Path.GetFileName(file),
                                            aimPath + Path.GetFileName(file) + "." + version + ".old");
                                    File.Copy(file, aimPath + Path.GetFileName(file), true);
                                    exist = true;
                                    break;
                                }
                            }

                            //不是依赖项并且本身不是更新程序本身
                            if (!exist)
                                File.Copy(file, aimPath + Path.GetFileName(file), true);
                            //更新程序自身的更新(单独调试此工程的时候需要用到这一段)
                            /*if (Path.GetFileName(file) == "EastMoney.BPF.DataPlatformUpgrade.exe")
                            {
                                try
                                {
                                    File.Move(aimPath + Path.GetFileName(file),
                                        aimPath + Path.GetFileName(file) + "." + version + ".old");

                                    File.Copy(file, aimPath + Path.GetFileName(file), true);
                                }
                                catch (Exception exception)
                                {
                                                    LogHelper.LogError("Error! ", exception);
                                }
                            }*/
                        }
                        else
                        {
                            File.Copy(file, aimPath + Path.GetFileName(file), true);
                        }
                    }
                }
                catch (Exception exception)
                {
                    LogHelper.LogError("拷贝文件失败，失败原因为:" + exception.Message + " 文件名为:" + file, exception);
                }
        }


        /// <summary>
        ///     创建一个目录
        /// </summary>
        /// <param name="directoryPath">目录的绝对路径</param>
        public static void CreateDirectory(string directoryPath)
        {
            //如果目录不存在则创建该目录
            if (!IsExistDirectory(directoryPath))
                Directory.CreateDirectory(directoryPath);
        }


        /// <summary>
        ///     创建一个文件。
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static bool CreateFile(string filePath)
        {
            try
            {
                //如果文件不存在则创建该文件
                if (!IsExistFile(filePath))
                {
                    var fileInfo = new FileInfo(filePath); //创建一个FileInfo对象
                    var fileStream = fileInfo.Create(); //创建文件
                    fileStream.Close(); //关闭文件流
                }
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return false;
            }

            return true;
        }

        /// <summary>
        ///     创建一个文件,并将字节流写入文件。
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        /// <param name="buffer">二进制流数据</param>
        public static bool CreateFile(string filePath, byte[] buffer)
        {
            try
            {
                //如果文件不存在则创建该文件
                if (!IsExistFile(filePath))
                {
                    //创建一个FileInfo对象
                    var file = new FileInfo(filePath);

                    //创建文件
                    var fs = file.Create();

                    //写入二进制流
                    fs.Write(buffer, 0, buffer.Length);

                    //关闭文件流
                    fs.Close();
                }
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return false;
            }
            return true;
        }


        /// <summary>
        ///     删除指定目录及其所有子目录(打开状态下降不能删除)
        /// </summary>
        /// <param name="directoryPath">指定目录的绝对路径</param>
        public static void DeleteDirectory(string directoryPath)
        {
            if (IsExistDirectory(directoryPath))
                try
                {
                    Directory.Delete(directoryPath, true);
                }
                catch (Exception exception)
                {
                    LogHelper.LogError("删除出错，可能是因为文件夹被打开了!请关闭后再试!路径为" + directoryPath + exception.Message, exception);
                }
        }

        /// <summary>
        /// 调用bat删除目录，以防止系统底层的异步删除机制
        /// </summary>
        /// <param name="dirPath"></param>
        /// <returns></returns>
        public static bool DeleteDirectoryWithCmd(string dirPath)
        {
            var process = new Process(); //string path = ...;//bat路径  
            var processStartInfo = new ProcessStartInfo("CMD.EXE", "/C rd /S /Q "" + dirPath + """)
            {
                UseShellExecute = false,
                RedirectStandardOutput = true
            }; //第二个参数为传入的参数，string类型以空格分隔各个参数  
            process.StartInfo = processStartInfo;
            process.Start();
            process.WaitForExit();
            var output = process.StandardOutput.ReadToEnd();
            if (string.IsNullOrWhiteSpace(output))
                return true;
            return false;
        }

        /// <summary>
        /// 调用bat删除文件，以防止系统底层的异步删除机制
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static bool DelFileWithCmd(string filePath)
        {
            var process = new Process(); //string path = ...;//bat路径  
            var processStartInfo = new ProcessStartInfo("CMD.EXE", "/C del /F /S /Q "" + filePath + """)
            {
                UseShellExecute = false,
                RedirectStandardOutput = true
            }; //第二个参数为传入的参数，string类型以空格分隔各个参数  
            process.StartInfo = processStartInfo;
            process.Start();
            process.WaitForExit();
            var output = process.StandardOutput.ReadToEnd();
            if (output.Contains(filePath))
                return true;
            return false;
        }


        /// <summary>
        ///     删除指定文件
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static void DeleteFile(string filePath)
        {
            if (IsExistFile(filePath))
                File.Delete(filePath);
        }


        /// <summary>
        ///     通过后缀名在目录中查找文件
        /// </summary>
        /// <param name="directory">目录</param>
        /// <param name="pattern">后缀名</param>
        public static void DeleteFiles(DirectoryInfo directory, string pattern)
        {
            if (directory.Exists && pattern.Trim() != string.Empty)
            {
                try
                {
                    foreach (var fileInfo in directory.GetFiles(pattern))
                        fileInfo.Delete();
                }
                catch (Exception exception)
                {
                    LogHelper.LogError("Error! ", exception);
                }
                foreach (var info in directory.GetDirectories())
                    DeleteFiles(info, pattern);
            }
        }


        /// <summary>
        ///     将文件读取到缓冲区中
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static byte[] FileToBytes(string filePath)
        {
            //获取文件的大小 
            var fileSize = GetFileSize(filePath);

            //创建一个临时缓冲区
            var buffer = new byte[fileSize];

            //创建一个文件流
            var fileInfo = new FileInfo(filePath);
            var fileStream = fileInfo.Open(FileMode.Open);

            try
            {
                //将文件流读入缓冲区
                fileStream.Read(buffer, 0, fileSize);

                return buffer;
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return null;
            }
            finally
            {
                fileStream.Close(); //关闭文件流
            }
        }


        /// <summary>
        ///     将文件读取到字符串中
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static string FileToString(string filePath)
        {
            return FileToString(filePath, Encoding.Default);
        }

        /// <summary>
        ///     将文件读取到字符串中
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        /// <param name="encoding">字符编码</param>
        public static string FileToString(string filePath, Encoding encoding)
        {
            //创建流读取器
            var reader = new StreamReader(filePath, encoding);
            try
            {
                return reader.ReadToEnd(); //读取流
            }
            catch
            {
                return string.Empty;
            }
            finally
            {
                reader.Close(); //关闭流读取器
            }
        }


        /// <summary>
        ///     获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.
        /// </summary>
        /// <param name="directoryPath">指定目录的绝对路径</param>
        public static string[] GetDirectories(string directoryPath)
        {
            try
            {
                return Directory.GetDirectories(directoryPath);
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return null;
            }
        }

        /// <summary>
        ///     获取指定目录及子目录中所有子目录列表
        /// </summary>
        /// <param name="directoryPath">指定目录的绝对路径</param>
        /// <param name="searchPattern">
        ///     模式字符串，"*"代表0或N个字符，"?"代表1个字符。
        ///     范例："Log*.xml"表示搜索所有以Log开头的Xml文件。
        /// </param>
        /// <param name="isSearchChild">是否搜索子目录</param>
        public static string[] GetDirectories(string directoryPath, string searchPattern, bool isSearchChild)
        {
            try
            {
                return Directory.GetDirectories(directoryPath, searchPattern,
                    isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return null;
            }
        }


        /// <summary>
        ///     从文件的绝对路径中获取扩展名
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static string GetExtension(string filePath)
        {
            var fileInfo = new FileInfo(filePath); //获取文件的名称
            return fileInfo.Extension;
        }


        /// <summary>
        ///     从文件的绝对路径中获取文件名( 包含扩展名 )
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static string GetFileName(string filePath)
        {
            //获取文件的名称
            var fileInfo = new FileInfo(filePath);
            return fileInfo.Name;
        }


        /// <summary>
        ///     从文件的绝对路径中获取文件名( 不包含扩展名 )
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static string GetFileNameNoExtension(string filePath)
        {
            //获取文件的名称
            var fileInfo = new FileInfo(filePath);
            return fileInfo.Name.Split('.')[0];
        }


        /// <summary>
        ///     获取指定目录中所有文件列表
        /// </summary>
        /// <param name="directoryPath">指定目录的绝对路径</param>
        public static string[] GetFileNames(string directoryPath)
        {
            if (!IsExistDirectory(directoryPath)) //如果目录不存在，则抛出异常
                throw new FileNotFoundException();
            return Directory.GetFiles(directoryPath); //获取文件列表
        }

        /// <summary>
        ///     获取指定目录及子目录中所有文件列表
        /// </summary>
        /// <param name="directoryPath">指定目录的绝对路径</param>
        /// <param name="searchPattern">
        ///     模式字符串，"*"代表0或N个字符，"?"代表1个字符。
        ///     范例："Log*.xml"表示搜索所有以Log开头的Xml文件。
        /// </param>
        /// <param name="isSearchChild">是否搜索子目录</param>
        public static string[] GetFileNames(string directoryPath, string searchPattern, bool isSearchChild)
        {
            if (!IsExistDirectory(directoryPath)) //如果目录不存在，则抛出异常
                throw new FileNotFoundException();
            try
            {
                return Directory.GetFiles(directoryPath, searchPattern,
                    isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return null;
            }
        }


        /// <summary>
        ///     获取一个文件的长度,单位为Byte
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static int GetFileSize(string filePath)
        {
            //创建一个文件对象
            var fileInfo = new FileInfo(filePath);

            //获取文件的大小
            return (int) fileInfo.Length;
        }

        /// <summary>
        ///     获取一个文件的长度,单位为KB
        /// </summary>
        /// <param name="filePath">文件的路径</param>
        public static double GetFileSizeByKB(string filePath)
        {
            var fileInfo = new FileInfo(filePath); //创建一个文件对象
            var size = fileInfo.Length / 1024;
            return double.Parse(size.ToString()); //获取文件的大小
        }

        /// <summary>
        ///     获取一个文件的长度,单位为MB
        /// </summary>
        /// <param name="filePath">文件的路径</param>
        public static double GetFileSizeByMB(string filePath)
        {
            var fileInfo = new FileInfo(filePath); //创建一个文件对象
            var size = fileInfo.Length / 1024 / 1024;
            return double.Parse(size.ToString()); //获取文件的大小
        }

        /// <summary>
        ///     得到文件大小
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static long GetFileSizeFromPath(string filePath = null)
        {
            if (string.IsNullOrEmpty(filePath)) return -1;
            if (!File.Exists(filePath)) return -1;
            var objFile = new FileInfo(filePath);
            return objFile.Length;
        }


        /// <summary>
        ///     获取文本文件的行数
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static int GetLineCount(string filePath)
        {
            //将文本文件的各行读到一个字符串数组中
            var rows = File.ReadAllLines(filePath);

            //返回行数
            return rows.Length;
        }


        /// <summary>
        ///     检测指定目录是否为空
        /// </summary>
        /// <param name="directoryPath">指定目录的绝对路径</param>
        public static bool IsEmptyDirectory(string directoryPath)
        {
            try
            {
                //判断是否存在文件
                var fileNames = GetFileNames(directoryPath);
                if (fileNames.Length > 0)
                    return false;

                //判断是否存在文件夹
                var directoryNames = GetDirectories(directoryPath);
                return directoryNames.Length <= 0;
            }
            catch
            {
                return false;
            }
        }


        /// <summary>
        ///     检测指定目录是否存在
        /// </summary>
        /// <param name="directoryPath">目录的绝对路径</param>
        public static bool IsExistDirectory(string directoryPath)
        {
            return Directory.Exists(directoryPath);
        }


        /// <summary>
        ///     检测指定文件是否存在,如果存在则返回true。
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        public static bool IsExistFile(string filePath)
        {
            return File.Exists(filePath);
        }


        /// <summary>
        ///     将文件移动到指定目录
        /// </summary>
        /// <param name="sourceFilePath">需要移动的源文件的绝对路径</param>
        /// <param name="descDirectoryPath">移动到的目录的绝对路径</param>
        public static void Move(string sourceFilePath, string descDirectoryPath)
        {
            //获取源文件的名称
            var sourceFileName = GetFileName(sourceFilePath);

            if (IsExistDirectory(descDirectoryPath))
            {
                //如果目标中存在同名文件,则删除
                if (IsExistFile(descDirectoryPath + "\" + sourceFileName))
                    DeleteFile(descDirectoryPath + "\" + sourceFileName);
                //将文件移动到指定目录
                File.Move(sourceFilePath, descDirectoryPath + "\" + sourceFileName);
            }
        }


        /// <summary>
        ///     将流读取到缓冲区中
        /// </summary>
        /// <param name="stream">原始流</param>
        public static byte[] StreamToBytes(Stream stream)
        {
            try
            {
                //创建缓冲区
                var buffer = new byte[stream.Length];

                //读取流
                stream.Read(buffer, 0, int.Parse(stream.Length.ToString()));

                //返回流
                return buffer;
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return null;
            }
            finally
            {
                stream.Close(); //关闭流
            }
        }


        /// <summary>
        ///     向文本文件中写入内容,默认UTF8编码
        /// </summary>
        /// <param name="filePath">文件的绝对路径</param>
        /// <param name="content">写入的内容</param>
        /// <param name="encoding"></param>
        public static void WriteText(string filePath, string content, Encoding encoding = null)
        {
            if (encoding == null)
            {
                encoding = Encoding.UTF8;
            }
            File.WriteAllText(filePath, content, encoding); //向文件写入内容
        }

        #endregion

        /// <summary>   
        /// 重命名文件夹内的所有子文件夹   ============================
        /// </summary>   
        /// <param name="directoryName">文件夹名称</param>   
        /// <param name="newDirectoryName">新子文件夹名称格式字符串</param>   
        public static bool RenameDirectories(string directoryName, string newDirectoryName)
        {
            DirectoryInfo directoryInfo = new DirectoryInfo(directoryName);
            if (!directoryInfo.Exists)
            {
                return false;
            }
            try
            {
                int i = 1;

                //string[] sDirectories = Directory.GetDirectories(directoryName);
                foreach (var sDirectory in directoryInfo.GetDirectories())
                {
                    string sNewDirectoryName = string.Format(newDirectoryName, i++);
                    string sNewDirectory = Path.Combine(directoryName, sNewDirectoryName);
                    sDirectory.MoveTo(sNewDirectory);
                    // Directory.Move(sDirectory, sNewDirectory);
                }
                return true;
            }
            catch (Exception exception)
            {
                LogHelper.LogError("Error! ", exception);
                return false;
            }
        }

        /// <summary>
        /// 文件重命名
        /// </summary>
        /// <param name="oldFileName"></param>
        /// <param name="newFileName"></param>
        public static bool FileRename(string filePath, string newFileName)
        {
            FileInfo fileInfo = new FileInfo(filePath); // 列表中的原始文件全路径名
            if (!fileInfo.Exists)
            {
                return false;
            }
           // fileInfo.DirectoryName 


           // fileInfo.MoveTo(Path.Combine(newStr));// 改名方法

            return true;// 新文件名
        }
    }
}