欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-04-08 19:09:42
在ASP.NET开发网站的过程中,有时候会涉及到文件夹相关操作,如判断文件夹目录是否存在、删除文件夹目录、创建文件、删除文件、复制文件夹等等。这一批有关文件目录的操作可以通过Directory类、File类的方法进行,因此为了我们自己操作的方便,可以封装出一个工具类,专门用于操作文件目录以及文件目录 ......

在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
    }