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

本文实例讲述了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#程序设计有所帮助。