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

C#实现最完整的文件和目录操作类实例

程序员文章站 2022-03-22 14:33:58
本文实例讲述了c#实现最完整的文件和目录操作类。分享给大家供大家参考。具体如下: using system; using system.text; using...

本文实例讲述了c#实现最完整的文件和目录操作类。分享给大家供大家参考。具体如下:

using system;
using system.text;
using system.io;
namespace hellocsharp.utilities
{
 /// <summary>
 /// 文件操作类
 /// </summary>
 public static class dirfile
 {
  #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);
    }

    //删除目录中所有的子目录
    string[] directorynames = getdirectories(directorypath);
    for (int i = 0; i < directorynames.length; i++)
    {
     deletedirectory(directorynames);
    }
   }
  }
  #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
 }
}

希望本文所述对大家的c#程序设计有所帮助。