建立两个类用于完成文件和文件夹的相关操作

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace FileDirOpreate
{
    /// <summary>
    /// 与文件有关的操作类
    /// </summary>
    public class FileDirOpreate
    {
        /// <summary>
        /// Deletes the file.
        /// </summary>
        /// <param name="FileFullPath">要删除的文件全路径</param>
        /// <returns></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>
        /// Gets the name of the file.包括文件的扩展名
        /// </summary>
        /// <param name="FileFullPath">文件的全路径</param>
        /// <returns></returns>
        public string GetFileName(string FileFullPath)
        {
            if (File.Exists(FileFullPath) == true)
            {
                FileInfo F = new FileInfo(FileFullPath);
                return F.Name;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Gets the name of the file.
        /// </summary>
        /// <param name="FileFullPath">文件的全路径</param>
        /// <param name="IncludeExtension">是否包含文件的扩展名</param>
        /// <returns></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>
        /// Gets the file extension.
        /// </summary>
        /// <param name="FileFullPath">The file full path.</param>
        /// <returns></returns>
        public string GetFileExtension(string FileFullPath)
        {
            if (File.Exists(FileFullPath) == true)
            {
                FileInfo F = new FileInfo(FileFullPath);
                return F.Extension;
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// Opens the file.
        /// </summary>
        /// <param name="FileFullPath">The file full path.</param>
        /// <returns></returns>
        public bool OpenFile(string FileFullPath)
        {
            if (File.Exists(FileFullPath) == true)
            {
                System.Diagnostics.Process.Start(FileFullPath);
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Gets the size of the file.
        /// </summary>
        /// <param name="FileFullPath">The file full path.</param>
        /// <returns></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)
                {
                    //   KB      MB    GB   TB
                    return System.Convert.ToString(Math.Round((FL + 0.00) / (1024 * 1024 * 1024), 2)) + " GB";
                }
                else if (FL > 1024 * 1024)
                {
                    return System.Convert.ToString(Math.Round((FL + 0.00) / (1024 * 1024), 2)) + " MB";
                }
                else
                {
                    return System.Convert.ToString(Math.Round((FL + 0.00) / 1024, 2)) + " KB";
                }
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Files to stream byte.
        /// </summary>
        /// <param name="FileFullPath">The file full path.</param>
        /// <returns></returns>
        public byte[] FileToStreamByte(string FileFullPath)
        {
            byte[] fileData = null;
            if (File.Exists(FileFullPath) == true)
            {
                FileStream FS = new FileStream(FileFullPath, System.IO.FileMode.Open);
                fileData = new byte[FS.Length];
                FS.Read(fileData, 0, fileData.Length);
                FS.Close();
                return fileData;
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// Bytes the stream to file.
        /// </summary>
        /// <param name="CreateFileFullPath">The create file full path.</param>
        /// <param name="StreamByte">The stream byte.</param>
        /// <returns></returns>
        public bool ByteStreamToFile(string CreateFileFullPath, byte[] StreamByte)
        {
            try
            {
                if (File.Exists(CreateFileFullPath) == true)
                {
                    DeleteFile(CreateFileFullPath);
                }
                FileStream FS;
                FS = File.Create(CreateFileFullPath);
                FS.Write(StreamByte, 0, StreamByte.Length);
                FS.Close();
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 序列化XML文件
        /// </summary>
        /// <param name="FileFullPath">The file full path.</param>
        /// <returns></returns>
        public bool SerializeXmlFile(string FileFullPath)
        {
            try
            {
                System.Data.DataSet DS = new System.Data.DataSet();
                DS.ReadXml(FileFullPath);
                FileStream FS = new FileStream(FileFullPath + ".tmp", FileMode.OpenOrCreate);
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter FT = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                FT.Serialize(FS, DS);
                FS.Close();
                DeleteFile(FileFullPath);
                File.Move(FileFullPath + ".tmp", FileFullPath);
                return true;
            }
            catch
            {
                return false;
            }

        }

        /// <summary>
        /// 反序列化XML文件
        /// </summary>
        /// <param name="FileFullPath">The file full path.</param>
        /// <returns></returns>
        public bool DeserializeXmlFile(string FileFullPath)
        {
            try
            {
                System.Data.DataSet DS = new System.Data.DataSet();
                FileStream FS = new FileStream(FileFullPath, FileMode.Open);
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter FT = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                ((System.Data.DataSet)FT.Deserialize(FS)).WriteXml(FileFullPath + ".tmp");
                FS.Close();
                DeleteFile(FileFullPath);
                File.Move(FileFullPath + ".tmp", FileFullPath);
                return true;
            }
            catch
            {
                return false;
            }
        }
    }

   /// <summary>
   /// 新类：完成文件夹的相关操作
   /// </summary>
    public class DirOperate
    {
        public enum OperateOption
        {
            /// <summary>
            /// 存在删除再创建
            /// </summary>
            ExistDelete,
            /// <summary>
            /// 存在直接返回
            /// </summary>
            ExistReturn
        }

        /// <summary>
        /// 创建文件夹
        /// </summary>
        /// <param name="DirFullPath">The dir full path.</param>
        /// <param name="DirOperateOption">The dir operate option.</param>
        /// <returns></returns>
        public bool CreateDir(string DirFullPath, OperateOption DirOperateOption)
        {
            try
            {
                if (Directory.Exists(DirFullPath) == false)
                {
                    Directory.CreateDirectory(DirFullPath);
                }
                else if (DirOperateOption == OperateOption.ExistDelete)
                {
                    Directory.Delete(DirFullPath, true);
                }
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 删除文件夹
        /// </summary>
        /// <param name="DirFullPath">全称路径.</param>
        /// <returns></returns>
        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></returns>
        public string[] GetDirFiles(string DirFullPath)
        {
            string[] FileList = null;
            if (Directory.Exists(DirFullPath) == true)
            {
                FileList = Directory.GetFiles(DirFullPath, "*.*", SearchOption.TopDirectoryOnly);

            }
            return FileList;
        }

        /// <summary>
        /// 得到目录内的文件名，
        /// </summary>
        /// <param name="DirFullPath">T指定的目录名</param>
        /// <param name="SO">The SO.</param>
        /// <returns></returns>
        public string[] GetDirFiles(string DirFullPath, SearchOption SO)
        {
            string[] FileList = null;
            if (Directory.Exists(DirFullPath) == true)
            {
                FileList = Directory.GetFiles(DirFullPath, "*.*", SO);
            }
            return FileList;
        }
        /// <summary>
        ///  得到目录内的文件名，
        /// </summary>
        /// <param name="DirFullPath">The dir full path.</param>
        /// <param name="SearchPattern">The search pattern.</param>
        /// <returns></returns>
        public string[] GetDirFiles(string DirFullPath, string SearchPattern)
        {
            string[] FileList = null;
            if (Directory.Exists(DirFullPath) == true)
            {
                FileList = Directory.GetFiles(DirFullPath, SearchPattern);
            }
            return FileList;
        }

        /// <summary>
        ///  得到目录内的文件名，
        /// </summary>
        /// <param name="DirFullPath">The dir full path.</param>
        /// <param name="SearchPattern">The search pattern.</param>
        /// <param name="SO">The SO.</param>
        /// <returns></returns>
        public string[] GetDirFiles(string DirFullPath, string SearchPattern, SearchOption SO)
        {
            string[] FileList = null;
            if (Directory.Exists(DirFullPath) == true)
            {
                FileList = Directory.GetFiles(DirFullPath, SearchPattern, SO);
            }
            return FileList;
        }
    }
}