【转载】ASP.NET工具类：文件夹目录Directory操作工具类

在asp.net开发网站的过程中，有时候会涉及到文件夹相关操作，如判断文件夹目录是否存在、删除文件夹目录、创建文件、删除文件、复制文件夹等等。这一批有关文件目录的操作可以通过directory类、file类的方法进行，因此为了我们自己操作的方便，可以封装出一个工具类，专门用于操作文件目录以及文件目录里面的文件。

directory类：msdn上的定义为目录类，开用于创建，移动和枚举目录和子目录的静态方法。这个类不能被继承。

file类：提供用于创建、复制、删除、移动和打开单一文件的静态方法，并协助创建filestream文件流对象。

备注：原文转载自asp.net工具类：文件夹目录directory操作工具类_it技术小趣屋。

封装一个目录操作工具类dirfilehelper类，该类除了包含常规的操作外，还包含文件复制、文件移动、计算文本文件行数等公用方法，具体的工具类实现如下：

  /// <summary>
    /// 文件操作夹
    /// </summary>
    public static class dirfilehelper
    {
        #region 检测指定目录是否存在
        /// <summary>
        /// 检测指定目录是否存在
        /// </summary>
        /// <param name="directorypath">目录的绝对路径</param>
        /// <returns></returns>
        public static bool isexistdirectory(string directorypath)
        {
            return directory.exists(directorypath);
        }
        #endregion
        #region 检测指定文件是否存在,如果存在返回true
        /// <summary>
        /// 检测指定文件是否存在,如果存在则返回true。
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>        
        public static bool isexistfile(string filepath)
        {
            return file.exists(filepath);
        }
        #endregion
        #region 获取指定目录中的文件列表
        /// <summary>
        /// 获取指定目录中所有文件列表
        /// </summary>
        /// <param name="directorypath">指定目录的绝对路径</param>        
        public static string[] getfilenames(string directorypath)
        {
            //如果目录不存在，则抛出异常
            if (!isexistdirectory(directorypath))
            {
                throw new filenotfoundexception();
            }
            //获取文件列表
            return directory.getfiles(directorypath);
        }
        #endregion
        #region 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.
        /// <summary>
        /// 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.
        /// </summary>
        /// <param name="directorypath">指定目录的绝对路径</param>        
        public static string[] getdirectories(string directorypath)
        {
            try
            {
                return directory.getdirectories(directorypath);
            }
            catch (ioexception ex)
            {
                throw ex;
            }
        }
        #endregion
        #region 获取指定目录及子目录中所有文件列表
        /// <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
            {
                if (issearchchild)
                {
                    return directory.getfiles(directorypath, searchpattern, searchoption.alldirectories);
                }
                else
                {
                    return directory.getfiles(directorypath, searchpattern, searchoption.topdirectoryonly);
                }
            }
            catch (ioexception ex)
            {
                throw ex;
            }
        }
        #endregion
        #region 检测指定目录是否为空
        /// <summary>
        /// 检测指定目录是否为空
        /// </summary>
        /// <param name="directorypath">指定目录的绝对路径</param>        
        public static bool isemptydirectory(string directorypath)
        {
            try
            {
                //判断是否存在文件
                string[] filenames = getfilenames(directorypath);
                if (filenames.length > 0)
                {
                    return false;
                }
                //判断是否存在文件夹
                string[] directorynames = getdirectories(directorypath);
                if (directorynames.length > 0)
                {
                    return false;
                }
                return true;
            }
            catch
            {
                //这里记录日志
                //loghelper.writetracelog(traceloglevel.error, ex.message);
                return true;
            }
        }
        #endregion
        #region 检测指定目录中是否存在指定的文件
        /// <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
            {
                //获取指定的文件列表
                string[] filenames = getfilenames(directorypath, searchpattern, false);
                //判断指定文件是否存在
                if (filenames.length == 0)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
            catch (exception ex)
            {
                throw new exception(ex.message);
                //loghelper.writetracelog(traceloglevel.error, ex.message);
            }
        }
        /// <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
            {
                //获取指定的文件列表
                string[] filenames = getfilenames(directorypath, searchpattern, true);
                //判断指定文件是否存在
                if (filenames.length == 0)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
            catch (exception ex)
            {
                throw new exception(ex.message);
                //loghelper.writetracelog(traceloglevel.error, ex.message);
            }
        }
        #endregion
        #region 创建目录
        /// <summary>
        /// 创建目录
        /// </summary>
        /// <param name="dir">要创建的目录路径包括目录名</param>
        public static void createdir(string dir)
        {
            if (dir.length == 0) return;
            if (!directory.exists(system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir))
                directory.createdirectory(system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir);
        }
        #endregion
        #region 删除目录
        /// <summary>
        /// 删除目录
        /// </summary>
        /// <param name="dir">要删除的目录路径和名称</param>
        public static void deletedir(string dir)
        {
            if (dir.length == 0) return;
            if (directory.exists(system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir))
                directory.delete(system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir);
        }
        #endregion
        #region 删除文件
        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="file">要删除的文件路径和名称</param>
        public static void deletefile(string file)
        {
            if (file.exists(system.web.httpcontext.current.request.physicalapplicationpath + file))
                file.delete(system.web.httpcontext.current.request.physicalapplicationpath + file);
        }
        #endregion
        #region 创建文件
        /// <summary>
        /// 创建文件
        /// </summary>
        /// <param name="dir">带后缀的文件名</param>
        /// <param name="pagestr">文件内容</param>
        public static void createfile(string dir, string pagestr)
        {
            dir = dir.replace("/", "\\");
            if (dir.indexof("\\") > -1)
                createdir(dir.substring(0, dir.lastindexof("\\")));
            system.io.streamwriter sw = new system.io.streamwriter(system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir, false, system.text.encoding.getencoding("gb2312"));
            sw.write(pagestr);
            sw.close();
        }
        #endregion
        #region 移动文件(剪贴--粘贴)
        /// <summary>
        /// 移动文件(剪贴--粘贴)
        /// </summary>
        /// <param name="dir1">要移动的文件的路径及全名(包括后缀)</param>
        /// <param name="dir2">文件移动到新的位置,并指定新的文件名</param>
        public static void movefile(string dir1, string dir2)
        {
            dir1 = dir1.replace("/", "\\");
            dir2 = dir2.replace("/", "\\");
            if (file.exists(system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir1))
                file.move(system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir1, system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir2);
        }
        #endregion
        #region 复制文件
        /// <summary>
        /// 复制文件
        /// </summary>
        /// <param name="dir1">要复制的文件的路径已经全名(包括后缀)</param>
        /// <param name="dir2">目标位置,并指定新的文件名</param>
        public static void copyfile(string dir1, string dir2)
        {
            dir1 = dir1.replace("/", "\\");
            dir2 = dir2.replace("/", "\\");
            if (file.exists(system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir1))
            {
                file.copy(system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir1, system.web.httpcontext.current.request.physicalapplicationpath + "\\" + dir2, true);
            }
        }
        #endregion
        #region 根据时间得到目录名 / 格式:yyyymmdd 或者 hhmmssff
        /// <summary>
        /// 根据时间得到目录名yyyymmdd
        /// </summary>
        /// <returns></returns>
        public static string getdatedir()
        {
            return datetime.now.tostring("yyyymmdd");
        }
        /// <summary>
        /// 根据时间得到文件名hhmmssff
        /// </summary>
        /// <returns></returns>
        public static string getdatefile()
        {
            return datetime.now.tostring("hhmmssff");
        }
        #endregion
        #region 复制文件夹
        /// <summary>
        /// 复制文件夹(递归)
        /// </summary>
        /// <param name="varfromdirectory">源文件夹路径</param>
        /// <param name="vartodirectory">目标文件夹路径</param>
        public static void copyfolder(string varfromdirectory, string vartodirectory)
        {
            directory.createdirectory(vartodirectory);
            if (!directory.exists(varfromdirectory)) return;
            string[] directories = directory.getdirectories(varfromdirectory);
            if (directories.length > 0)
            {
                foreach (string d in directories)
                {
                    copyfolder(d, vartodirectory + d.substring(d.lastindexof("\\")));
                }
            }
            string[] files = directory.getfiles(varfromdirectory);
            if (files.length > 0)
            {
                foreach (string s in files)
                {
                    file.copy(s, vartodirectory + s.substring(s.lastindexof("\\")), true);
                }
            }
        }
        #endregion
        #region 检查文件,如果文件不存在则创建
        /// <summary>
        /// 检查文件,如果文件不存在则创建  
        /// </summary>
        /// <param name="filepath">路径,包括文件名</param>
        public static void existsfile(string filepath)
        {
            //if(!file.exists(filepath))    
            //file.create(filepath);    
            //以上写法会报错,详细解释请看下文.........   
            if (!file.exists(filepath))
            {
                filestream fs = file.create(filepath);
                fs.close();
            }
        }
        #endregion
        #region 删除指定文件夹对应其他文件夹里的文件
        /// <summary>
        /// 删除指定文件夹对应其他文件夹里的文件
        /// </summary>
        /// <param name="varfromdirectory">指定文件夹路径</param>
        /// <param name="vartodirectory">对应其他文件夹路径</param>
        public static void deletefolderfiles(string varfromdirectory, string vartodirectory)
        {
            directory.createdirectory(vartodirectory);
            if (!directory.exists(varfromdirectory)) return;
            string[] directories = directory.getdirectories(varfromdirectory);
            if (directories.length > 0)
            {
                foreach (string d in directories)
                {
                    deletefolderfiles(d, vartodirectory + d.substring(d.lastindexof("\\")));
                }
            }

            string[] files = directory.getfiles(varfromdirectory);
            if (files.length > 0)
            {
                foreach (string s in files)
                {
                    file.delete(vartodirectory + s.substring(s.lastindexof("\\")));
                }
            }
        }
        #endregion
        #region 从文件的绝对路径中获取文件名( 包含扩展名 )
        /// <summary>
        /// 从文件的绝对路径中获取文件名( 包含扩展名 )
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>        
        public static string getfilename(string filepath)
        {
            //获取文件的名称
            fileinfo fi = new fileinfo(filepath);
            return fi.name;
        }
        #endregion
        /// <summary>
        /// 复制文件参考方法,页面中引用
        /// </summary>
        /// <param name="cdir">新路径</param>
        /// <param name="tempid">模板引擎替换编号</param>
        public static void copyfiles(string cdir, string tempid)
        {
            //if (directory.exists(request.physicalapplicationpath + "\\controls"))
            //{
            //    string tempstr = string.empty;
            //    streamwriter sw;
            //    if (file.exists(request.physicalapplicationpath + "\\controls\\default.aspx"))
            //    {
            //        tempstr = file.readalltext(request.physicalapplicationpath + "\\controls\\default.aspx");
            //        tempstr = tempstr.replace("{$channelid$}", tempid);
            //        sw = new streamwriter(request.physicalapplicationpath + "\\" + cdir + "\\default.aspx", false, system.text.encoding.getencoding("gb2312"));
            //        sw.write(tempstr);
            //        sw.close();
            //    }
            //    if (file.exists(request.physicalapplicationpath + "\\controls\\column.aspx"))
            //    {
            //        tempstr = file.readalltext(request.physicalapplicationpath + "\\controls\\column.aspx");
            //        tempstr = tempstr.replace("{$channelid$}", tempid);
            //        sw = new streamwriter(request.physicalapplicationpath + "\\" + cdir + "\\list.aspx", false, system.text.encoding.getencoding("gb2312"));
            //        sw.write(tempstr);
            //        sw.close();
            //    }
            //    if (file.exists(request.physicalapplicationpath + "\\controls\\content.aspx"))
            //    {
            //        tempstr = file.readalltext(request.physicalapplicationpath + "\\controls\\content.aspx");
            //        tempstr = tempstr.replace("{$channelid$}", tempid);
            //        sw = new streamwriter(request.physicalapplicationpath + "\\" + cdir + "\\view.aspx", false, system.text.encoding.getencoding("gb2312"));
            //        sw.write(tempstr);
            //        sw.close();
            //    }
            //    if (file.exists(request.physicalapplicationpath + "\\controls\\morediss.aspx"))
            //    {
            //        tempstr = file.readalltext(request.physicalapplicationpath + "\\controls\\morediss.aspx");
            //        tempstr = tempstr.replace("{$channelid$}", tempid);
            //        sw = new streamwriter(request.physicalapplicationpath + "\\" + cdir + "\\disslist.aspx", false, system.text.encoding.getencoding("gb2312"));
            //        sw.write(tempstr);
            //        sw.close();
            //    }
            //    if (file.exists(request.physicalapplicationpath + "\\controls\\showdiss.aspx"))
            //    {
            //        tempstr = file.readalltext(request.physicalapplicationpath + "\\controls\\showdiss.aspx");
            //        tempstr = tempstr.replace("{$channelid$}", tempid);
            //        sw = new streamwriter(request.physicalapplicationpath + "\\" + cdir + "\\diss.aspx", false, system.text.encoding.getencoding("gb2312"));
            //        sw.write(tempstr);
            //        sw.close();
            //    }
            //    if (file.exists(request.physicalapplicationpath + "\\controls\\review.aspx"))
            //    {
            //        tempstr = file.readalltext(request.physicalapplicationpath + "\\controls\\review.aspx");
            //        tempstr = tempstr.replace("{$channelid$}", tempid);
            //        sw = new streamwriter(request.physicalapplicationpath + "\\" + cdir + "\\review.aspx", false, system.text.encoding.getencoding("gb2312"));
            //        sw.write(tempstr);
            //        sw.close();
            //    }
            //    if (file.exists(request.physicalapplicationpath + "\\controls\\search.aspx"))
            //    {
            //        tempstr = file.readalltext(request.physicalapplicationpath + "\\controls\\search.aspx");
            //        tempstr = tempstr.replace("{$channelid$}", tempid);
            //        sw = new streamwriter(request.physicalapplicationpath + "\\" + cdir + "\\search.aspx", false, system.text.encoding.getencoding("gb2312"));
            //        sw.write(tempstr);
            //        sw.close();
            //    }
            //}
        }

        #region 创建一个目录
        /// <summary>
        /// 创建一个目录
        /// </summary>
        /// <param name="directorypath">目录的绝对路径</param>
        public static void createdirectory(string directorypath)
        {
            //如果目录不存在则创建该目录
            if (!isexistdirectory(directorypath))
            {
                directory.createdirectory(directorypath);
            }
        }
        #endregion
        #region 创建一个文件
        /// <summary>
        /// 创建一个文件。
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>
        public static void createfile(string filepath)
        {
            try
            {
                //如果文件不存在则创建该文件
                if (!isexistfile(filepath))
                {
                    //创建一个fileinfo对象
                    fileinfo file = new fileinfo(filepath);
                    //创建文件
                    filestream fs = file.create();
                    //关闭文件流
                    fs.close();
                }
            }
            catch (exception ex)
            {
                //loghelper.writetracelog(traceloglevel.error, ex.message);
                throw ex;
            }
        }
        /// <summary>
        /// 创建一个文件,并将字节流写入文件。
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>
        /// <param name="buffer">二进制流数据</param>
        public static void createfile(string filepath, byte[] buffer)
        {
            try
            {
                //如果文件不存在则创建该文件
                if (!isexistfile(filepath))
                {
                    //创建一个fileinfo对象
                    fileinfo file = new fileinfo(filepath);
                    //创建文件
                    filestream fs = file.create();
                    //写入二进制流
                    fs.write(buffer, 0, buffer.length);
                    //关闭文件流
                    fs.close();
                }
            }
            catch (exception ex)
            {
                //loghelper.writetracelog(traceloglevel.error, ex.message);
                throw ex;
            }
        }
        #endregion
        #region 获取文本文件的行数
        /// <summary>
        /// 获取文本文件的行数
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>        
        public static int getlinecount(string filepath)
        {
            //将文本文件的各行读到一个字符串数组中
            string[] rows = file.readalllines(filepath);
            //返回行数
            return rows.length;
        }
        #endregion
        #region 获取一个文件的长度
        /// <summary>
        /// 获取一个文件的长度,单位为byte
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>        
        public static int getfilesize(string filepath)
        {
            //创建一个文件对象
            fileinfo fi = new fileinfo(filepath);
            //获取文件的大小
            return (int)fi.length;
        }
        #endregion
        #region 获取指定目录中的子目录列表
        /// <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
            {
                if (issearchchild)
                {
                    return directory.getdirectories(directorypath, searchpattern, searchoption.alldirectories);
                }
                else
                {
                    return directory.getdirectories(directorypath, searchpattern, searchoption.topdirectoryonly);
                }
            }
            catch (ioexception ex)
            {
                throw ex;
            }
        }
        #endregion
        #region 向文本文件写入内容
        /// <summary>
        /// 向文本文件中写入内容
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>
        /// <param name="text">写入的内容</param>
        /// <param name="encoding">编码</param>
        public static void writetext(string filepath, string text, encoding encoding)
        {
            //向文件写入内容
            file.writealltext(filepath, text, encoding);
        }
        #endregion
        #region 向文本文件的尾部追加内容
        /// <summary>
        /// 向文本文件的尾部追加内容
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>
        /// <param name="content">写入的内容</param>
        public static void appendtext(string filepath, string content)
        {
            file.appendalltext(filepath, content);
        }
        #endregion
        #region 将现有文件的内容复制到新文件中
        /// <summary>
        /// 将源文件的内容复制到目标文件中
        /// </summary>
        /// <param name="sourcefilepath">源文件的绝对路径</param>
        /// <param name="destfilepath">目标文件的绝对路径</param>
        public static void copy(string sourcefilepath, string destfilepath)
        {
            file.copy(sourcefilepath, destfilepath, true);
        }
        #endregion
        #region 将文件移动到指定目录
        /// <summary>
        /// 将文件移动到指定目录
        /// </summary>
        /// <param name="sourcefilepath">需要移动的源文件的绝对路径</param>
        /// <param name="descdirectorypath">移动到的目录的绝对路径</param>
        public static void move(string sourcefilepath, string descdirectorypath)
        {
            //获取源文件的名称
            string sourcefilename = getfilename(sourcefilepath);
            if (isexistdirectory(descdirectorypath))
            {
                //如果目标中存在同名文件,则删除
                if (isexistfile(descdirectorypath + "\\" + sourcefilename))
                {
                    deletefile(descdirectorypath + "\\" + sourcefilename);
                }
                //将文件移动到指定目录
                file.move(sourcefilepath, descdirectorypath + "\\" + sourcefilename);
            }
        }
        #endregion

        #region 从文件的绝对路径中获取文件名( 不包含扩展名 )
        /// <summary>
        /// 从文件的绝对路径中获取文件名( 不包含扩展名 )
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>        
        public static string getfilenamenoextension(string filepath)
        {
            //获取文件的名称
            fileinfo fi = new fileinfo(filepath);
            return fi.name.split('.')[0];
        }
        #endregion
        #region 从文件的绝对路径中获取扩展名
        /// <summary>
        /// 从文件的绝对路径中获取扩展名
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>        
        public static string getextension(string filepath)
        {
            //获取文件的名称
            fileinfo fi = new fileinfo(filepath);
            return fi.extension;
        }
        #endregion
        #region 清空指定目录
        /// <summary>
        /// 清空指定目录下所有文件及子目录,但该目录依然保存.
        /// </summary>
        /// <param name="directorypath">指定目录的绝对路径</param>
        public static void cleardirectory(string directorypath)
        {
            if (isexistdirectory(directorypath))
            {
                //删除目录中所有的文件
                string[] filenames = getfilenames(directorypath);
                for (int i = 0; i < filenames.length; i++)
                {
                    deletefile(filenames[i]);
                }
                //删除目录中所有的子目录
                string[] directorynames = getdirectories(directorypath);
                for (int i = 0; i < directorynames.length; i++)
                {
                    deletedirectory(directorynames[i]);
                }
            }
        }
        #endregion
        #region 清空文件内容
        /// <summary>
        /// 清空文件内容
        /// </summary>
        /// <param name="filepath">文件的绝对路径</param>
        public static void clearfile(string filepath)
        {
            //删除文件
            file.delete(filepath);
            //重新创建该文件
            createfile(filepath);
        }
        #endregion
        #region 删除指定目录
        /// <summary>
        /// 删除指定目录及其所有子目录
        /// </summary>
        /// <param name="directorypath">指定目录的绝对路径</param>
        public static void deletedirectory(string directorypath)
        {
            if (isexistdirectory(directorypath))
            {
                directory.delete(directorypath, true);
            }
        }
        #endregion
    }