/// <summary>
/// 文件有关的操作类
/// </summary>
public class FileOperate
{
    /// <summary>
    /// 删除文件
    /// </summary>
    /// <param name="FileFullPath">文件的全路径.</param>
    /// <returns>bool</returns>
    public bool DeleteFile(string FileFullPath)
    {
        if (File.Exists(FileFullPath) == true) //用静态类判断文件是否存在
        {
            File.SetAttributes(FileFullPath, FileAttributes.Normal); //设置文件的属性为正常（如果文件为只读的话直接删除会报错）
            File.Delete(FileFullPath); //删除文件
            return true;
        }
        else  //文件不存在
        {
            return false;
        }
    }

    /// <summary>
    /// 获取文件名（包含扩展名）
    /// </summary>
    /// <param name="FileFullPath">文件全路径</param>
    /// <returns>string</returns>
    public string GetFileName(string FileFullPath)
    {
        if (File.Exists(FileFullPath) == true)
        {
            FileInfo F = new FileInfo(FileFullPath);  //FileInfo类为提供创建、复制、删除等方法
            return F.Name;  //获取文件名（包含扩展名）
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 获取文件文件扩展名
    /// </summary>
    /// <param name="FileFullPath">文件全路径</param>
    /// <returns>string</returns>
    public string GetFileExtension(string FileFullPath)
    {
        if (File.Exists(FileFullPath) == true)
        {
            FileInfo F = new FileInfo(FileFullPath);
            return F.Extension;  //获取文件扩展名（包含".",如：".mp3"）
           
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 获取文件名（可包含扩展名）
    /// </summary>
    /// <param name="FileFullPath">文件全路径</param>
    /// <param name="IncludeExtension">是否包含扩展名</param>
    /// <returns>string</returns>
    public string GetFileName(string FileFullPath, bool IncludeExtension)
    {
        if (File.Exists(FileFullPath) == true)
        {
            FileInfo F = new FileInfo(FileFullPath);
            if (IncludeExtension == true)
            {
                return F.Name;   //返回文件名（包含扩展名）
            }
            else
            {
                return F.Name.Replace(F.Extension, "");  //把扩展名替换为空字符
            }
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 根据传来的文件全路径，外部打开文件，默认用系统注册类型关联软件打开
    /// </summary>
    /// <param name="FileFullPath">文件的全路径</param>
    /// <returns>bool</returns>
    public bool OpenFile(string FileFullPath)
    {
        if (File.Exists(FileFullPath) == true)
        {
            System.Diagnostics.Process.Start(FileFullPath);  //打开文件，默认用系统注册类型关联软件打开
            return true;
        }
        else
        {
            return false;
        }
    }

    /// <summary>
    /// 获取文件大小
    /// </summary>
    /// <param name="FileFullPath">文件全路径</param>
    /// <returns>string</returns>
    public string GetFileSize(string FileFullPath)
    {
        if (File.Exists(FileFullPath) == true)
        {
            FileInfo F = new FileInfo(FileFullPath);
            long FL = F.Length;
            if (FL > (1024 * 1024 * 1024))  //由大向小来判断文件的大小
            {
                return Math.Round((FL + 0.00) / (1024 * 1024 * 1024), 2).ToString() + " GB";  //将双精度浮点数舍入到指定的小数（long类型与double类型运算，结果会是一个double类型）
            }
            else if (FL > (1024 * 1024))
            {
                return Math.Round((FL + 0.00) / (1024 * 1024), 2).ToString() + " MB";
            }
            else if (FL > 1024)
            {
                return Math.Round((FL + 0.00) / 1024, 2).ToString() + " KB";
            }
            else
            {
                return FL.ToString();
            }
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 文件转换成二进制，返回二进制数组Byte[]
    /// </summary>
    /// <param name="FileFullPath">文件全路径</param>
    /// <returns>byte[] 包含文件流的二进制数组</returns>
    public byte[] FileToStreamByte(string FileFullPath)
    {
        if (File.Exists(FileFullPath) == true)
        {
            FileStream FS = new FileStream(FileFullPath, FileMode.Open); //创建一个文件流
            byte[] fileData = new byte[FS.Length];                       //创建一个字节数组，用于保存流
            FS.Read(fileData, 0, fileData.Length);                       //从流中读取字节块，保存到缓存中
            FS.Close();                                                  //关闭流（一定得关闭，否则流一直存在）
            return fileData;                                             //返回字节数组
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 二进制数组Byte[]生成文件
    /// </summary>
    /// <param name="FileFullPath">要生成的文件全路径</param>
    /// <param name="StreamByte">要生成文件的二进制 Byte 数组</param>
    /// <returns>bool 是否生成成功</returns>
    public bool ByteStreamToFile(string FileFullPath, byte[] StreamByte)
    {
        try
        {
            if (File.Exists(FileFullPath) == true)  //判断要创建的文件是否存在，若存在则先删除
            {
                File.Delete(FileFullPath);
            }
            FileStream FS = new FileStream(FileFullPath, FileMode.OpenOrCreate);  //创建文件流(打开或创建的方式)
            FS.Write(StreamByte, 0, StreamByte.Length);  //把文件流写到文件中
            FS.Close();
            return true;
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// 将Xml文件序列化(可起到加密和压缩XML文件的目的)
    /// </summary>
    /// <param name="FileFullPath">要序列化的XML文件全路径</param>
    /// <returns>bool 是否序列化成功</returns>
    public bool SerializeXml(string FileFullPath)   //序列化：
    {
        try
        {
            System.Data.DataSet DS = new System.Data.DataSet();  //创建数据集，用来临时存储XML文件
            DS.ReadXml(FileFullPath);  //将XML文件读入到数据集中
            FileStream FS = new FileStream(FileFullPath + ".tmp", FileMode.OpenOrCreate);  //创建一个.tmp的临时文件
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter FT = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();  //使用二进制格式化程序进行序列化
            FT.Serialize(FS, DS);  //把数据集序列化后存入文件中
            FS.Close();  //一定要关闭文件流，否则文件改名会报错（文件正在使用错误）
            DeleteFile(FileFullPath);  //删除原XML文件
            File.Move(FileFullPath + ".tmp", FileFullPath);  //改名(把临时文件名改成原来的xml文件名)
            return true;
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// 反序列化XML文件
    /// </summary>
    /// <param name="FileFullPath">要反序列化XML文件的全路径</param>
    /// <returns>bool 是否反序列化XML文件</returns>
    public bool DeSerializeXml(string FileFullPath)
    {
        FileStream FS = new FileStream(FileFullPath, FileMode.Open);  //打开XML文件流
        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter FT = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();  //使用二进制格式化程序进行序列化
        ((System.Data.DataSet)FT.Deserialize(FS)).WriteXml(FileFullPath + ".tmp");  //把文件反序列化后存入.tmp临时文件中
        FS.Close();  //关闭并释放流
        DeleteFile(FileFullPath);  //删除原文件
        File.Move(FileFullPath + ".tmp", FileFullPath);  //改名(把临时文件改成原来的xml文件)
        return true;
    }

}

/// <summary>
/// 与文件夹有关的操作类
/// </summary>
public class DirOperate
{
    public enum OperateOption
    {
        /// <summary>
        /// 当被创建的文件夹存在时，先删除该文件夹
        /// </summary>
        ExistDelete,

        /// <summary>
        /// 当文件夹存在时，直接返回，不进行其它操作
        /// </summary>
        ExistReturn
    }

    /// <summary>
    /// 创建文件夹
    /// </summary>
    /// <param name="DirFullPath">要创建的文件夹全路径</param>
    /// <param name="Option">创建文件夹时的操作选项</param>
    /// <returns>bool 是否创建成功</returns>
    public bool CreateDir(string DirFullPath, OperateOption Option)
    {
        try
        {
            if (Directory.Exists(DirFullPath) == false)  //判断文件夹是否存在
            {
                Directory.CreateDirectory(DirFullPath);
            }
            else if (Option == OperateOption.ExistDelete)  //如果存在且选项为“存在删除”
            {
                Directory.Delete(DirFullPath);  //删除目录，并删除此目录下的所以子目录
                Directory.CreateDirectory(DirFullPath);  //创建目录
            }
            return true;
        }
        catch
        {
            return false;
        }
    }

    public bool DeleteDir(string DirFullPath)
    {
        if (Directory.Exists(DirFullPath) == true)
        {
            Directory.Delete(DirFullPath, true);
            return true;
        }
        else
        {
            return false;
        }       
    }

    /// <summary>
    /// 得到当前文件夹中所有文件列表
    /// </summary>
    /// <param name="DirFullPath">文件夹全路径</param>
    /// <returns>string[] 文件列表</returns>
    public string[] GetDirFiles(string DirFullPath)
    {
        if (Directory.Exists(DirFullPath) == true)
        {
            string[] s = Directory.GetFiles(DirFullPath, "*.*", SearchOption.TopDirectoryOnly);  //获取当前目录下的所有文件
            return s;
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 得到当前文件夹及下级文件夹中所有文件列表
    /// </summary>
    /// <param name="DirFullPath">文件夹全路径</param>
    /// <param name="SO">搜索选项</param>
    /// <returns>string[] 文件列表</returns>
    public string[] GetDirFiles(string DirFullPath, SearchOption SO)
    {
        if (Directory.Exists(DirFullPath) == true)
        {
            string[] s = Directory.GetFiles(DirFullPath, "*.*", SearchOption.AllDirectories);  //获取当前目录下的所有文件(包含子文件夹中的文件)
            return s;
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 得到当前文件夹中指定文件类型［扩展名］文件列表
    /// </summary>
    /// <param name="DirFullPath">文件夹的全路径</param>
    /// <param name="SearchPattern">查找哪种类型的文件</param>
    /// <returns>string[] 文件列表</returns>
    public string[] GetDirFiles(string DirFullPath, string SearchPattern)
    {
        if (Directory.Exists(DirFullPath) == true)
        {
            string[] s = Directory.GetFiles(DirFullPath, SearchPattern);  //获取当前目录下指定文件类型的文件列表
            return s;
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 得到当前文件夹及下级文件夹中指定文件类型［扩展名］文件列表
    /// </summary>
    /// <param name="DirFullPath">目录全路径</param>
    /// <param name="SearchPattern">查找哪种类型的文件</param>
    /// <param name="SO">搜索选项</param>
    /// <returns>string[] 文件列表</returns>
    public string[] GetDirFiles(string DirFullPath, string SearchPattern, SearchOption SO)
    {
        if (Directory.Exists(DirFullPath) == true)
        {
            string[] s = Directory.GetFiles(DirFullPath, SearchPattern, SO);  //获取当前目录下的文件
            return s;
        }
        else
        {
            return null;
        }
    }
}