C#学习笔记001 – 获取文件夹下的所有文件的文件名

2018年4月23日22:37:05 2

因项目需要用到这一块,查了一些资料,找到了两种方法;做个记录。

1.路径用Directory,文件名用file。

  1. String path = @"X:xxxxxx";
  2. //第一种方法
  3. var files = Directory.GetFiles(path, "*.txt");
  4. foreach (var file in files)
  5.     Console.WriteLine(file);

2. 我也推荐用第二种方法,可以拿到文件的所有信息,比如扩展名什么的。

  1. DirectoryInfo folder = new DirectoryInfo(path);
  2. foreach (FileInfo file in folder.GetFiles("*.txt"))
  3. {
  4.     Console.WriteLine(file.FullName);
  5. }

附文件管理类

展开

  1. using System;
  2. using System.Text;
  3. using System.IO;
  4. namespace DotNet.Utilities
  5. {
  6.     /// <summary>  
  7.     /// 文件操作夹  
  8.     /// </summary>  
  9.     public static class DirFileHelper
  10.     {
  11.         #region 检测指定目录是否存在  
  12.         /// <summary>  
  13.         /// 检测指定目录是否存在  
  14.         /// </summary>  
  15.         /// <param name="directoryPath">目录的绝对路径</param>  
  16.         /// <returns></returns>  
  17.         public static bool IsExistDirectory(string directoryPath)
  18.         {
  19.             return Directory.Exists(directoryPath);
  20.         }
  21.         #endregion  
  22.  
  23.         #region 检测指定文件是否存在,如果存在返回true  
  24.         /// <summary>  
  25.         /// 检测指定文件是否存在,如果存在则返回true。  
  26.         /// </summary>  
  27.         /// <param name="filePath">文件的绝对路径</param>          
  28.         public static bool IsExistFile(string filePath)
  29.         {
  30.             return File.Exists(filePath);
  31.         }
  32.         #endregion  
  33.  
  34.         #region 获取指定目录中的文件列表  
  35.         /// <summary>  
  36.         /// 获取指定目录中所有文件列表  
  37.         /// </summary>  
  38.         /// <param name="directoryPath">指定目录的绝对路径</param>          
  39.         public static string[] GetFileNames(string directoryPath)
  40.         {
  41.             //如果目录不存在,则抛出异常  
  42.             if (!IsExistDirectory(directoryPath))
  43.             {
  44.                 throw new FileNotFoundException();
  45.             }
  46.             //获取文件列表  
  47.             return Directory.GetFiles(directoryPath);
  48.         }
  49.         #endregion  
  50.  
  51.         #region 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.  
  52.         /// <summary>  
  53.         /// 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.  
  54.         /// </summary>  
  55.         /// <param name="directoryPath">指定目录的绝对路径</param>          
  56.         public static string[] GetDirectories(string directoryPath)
  57.         {
  58.             try
  59.             {
  60.                 return Directory.GetDirectories(directoryPath);
  61.             }
  62.             catch (IOException ex)
  63.             {
  64.                 throw ex;
  65.             }
  66.         }
  67.         #endregion  
  68.  
  69.         #region 获取指定目录及子目录中所有文件列表  
  70.         /// <summary>  
  71.         /// 获取指定目录及子目录中所有文件列表  
  72.         /// </summary>  
  73.         /// <param name="directoryPath">指定目录的绝对路径</param>  
  74.         /// <param name="searchPattern">模式字符串,"*"代表0或N个字符,"?"代表1个字符。  
  75.         /// 范例:"Log*.xml"表示搜索所有以Log开头的Xml文件。</param>  
  76.         /// <param name="isSearchChild">是否搜索子目录</param>  
  77.         public static string[] GetFileNames(string directoryPath, string searchPattern, bool isSearchChild)
  78.         {
  79.             //如果目录不存在,则抛出异常  
  80.             if (!IsExistDirectory(directoryPath))
  81.             {
  82.                 throw new FileNotFoundException();
  83.             }
  84.             try
  85.             {
  86.                 if (isSearchChild)
  87.                 {
  88.                     return Directory.GetFiles(directoryPath, searchPattern, SearchOption.AllDirectories);
  89.                 }
  90.                 else
  91.                 {
  92.                     return Directory.GetFiles(directoryPath, searchPattern, SearchOption.TopDirectoryOnly);
  93.                 }
  94.             }
  95.             catch (IOException ex)
  96.             {
  97.                 throw ex;
  98.             }
  99.         }
  100.         #endregion  
  101.  
  102.         #region 检测指定目录是否为空  
  103.         /// <summary>  
  104.         /// 检测指定目录是否为空  
  105.         /// </summary>  
  106.         /// <param name="directoryPath">指定目录的绝对路径</param>          
  107.         public static bool IsEmptyDirectory(string directoryPath)
  108.         {
  109.             try
  110.             {
  111.                 //判断是否存在文件  
  112.                 string[] fileNames = GetFileNames(directoryPath);
  113.                 if (fileNames.Length > 0)
  114.                 {
  115.                     return false;
  116.                 }
  117.                 //判断是否存在文件夹  
  118.                 string[] directoryNames = GetDirectories(directoryPath);
  119.                 if (directoryNames.Length > 0)
  120.                 {
  121.                     return false;
  122.                 }
  123.                 return true;
  124.             }
  125.             catch
  126.             {
  127.                 //这里记录日志  
  128.                 //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);  
  129.                 return true;
  130.             }
  131.         }
  132.         #endregion  
  133.  
  134.         #region 检测指定目录中是否存在指定的文件  
  135.         /// <summary>  
  136.         /// 检测指定目录中是否存在指定的文件,若要搜索子目录请使用重载方法.  
  137.         /// </summary>  
  138.         /// <param name="directoryPath">指定目录的绝对路径</param>  
  139.         /// <param name="searchPattern">模式字符串,"*"代表0或N个字符,"?"代表1个字符。  
  140.         /// 范例:"Log*.xml"表示搜索所有以Log开头的Xml文件。</param>          
  141.         public static bool Contains(string directoryPath, string searchPattern)
  142.         {
  143.             try
  144.             {
  145.                 //获取指定的文件列表  
  146.                 string[] fileNames = GetFileNames(directoryPath, searchPattern, false);
  147.                 //判断指定文件是否存在  
  148.                 if (fileNames.Length == 0)
  149.                 {
  150.                     return false;
  151.                 }
  152.                 else
  153.                 {
  154.                     return true;
  155.                 }
  156.             }
  157.             catch (Exception ex)
  158.             {
  159.                 throw new Exception(ex.Message);
  160.                 //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);  
  161.             }
  162.         }
  163.         /// <summary>  
  164.         /// 检测指定目录中是否存在指定的文件  
  165.         /// </summary>  
  166.         /// <param name="directoryPath">指定目录的绝对路径</param>  
  167.         /// <param name="searchPattern">模式字符串,"*"代表0或N个字符,"?"代表1个字符。  
  168.         /// 范例:"Log*.xml"表示搜索所有以Log开头的Xml文件。</param>   
  169.         /// <param name="isSearchChild">是否搜索子目录</param>  
  170.         public static bool Contains(string directoryPath, string searchPattern, bool isSearchChild)
  171.         {
  172.             try
  173.             {
  174.                 //获取指定的文件列表  
  175.                 string[] fileNames = GetFileNames(directoryPath, searchPattern, true);
  176.                 //判断指定文件是否存在  
  177.                 if (fileNames.Length == 0)
  178.                 {
  179.                     return false;
  180.                 }
  181.                 else
  182.                 {
  183.                     return true;
  184.                 }
  185.             }
  186.             catch (Exception ex)
  187.             {
  188.                 throw new Exception(ex.Message);
  189.                 //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);  
  190.             }
  191.         }
  192.         #endregion  
  193.  
  194.         #region 创建目录  
  195.         /// <summary>  
  196.         /// 创建目录  
  197.         /// </summary>  
  198.         /// <param name="dir">要创建的目录路径包括目录名</param>  
  199.         public static void CreateDir(string dir)
  200.         {
  201.             if (dir.Length == 0) return;
  202.             if (!Directory.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir))  
  203.                 Directory.CreateDirectory(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir);  
  204.         }  
  205.         #endregion  
  206.  
  207.         #region 删除目录  
  208.         /// <summary>  
  209.         /// 删除目录  
  210.         /// </summary>  
  211.         /// <param name="dir">要删除的目录路径和名称</param>  
  212.         public static void DeleteDir(string dir)  
  213.         {  
  214.             if (dir.Length == 0) return;  
  215.             if (Directory.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir))  
  216.                 Directory.Delete(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir);  
  217.         }  
  218.         #endregion  
  219.  
  220.         #region 删除文件  
  221.         /// <summary>  
  222.         /// 删除文件  
  223.         /// </summary>  
  224.         /// <param name="file">要删除的文件路径和名称</param>  
  225.         public static void DeleteFile(string file)  
  226.         {  
  227.             if (File.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + file))  
  228.                 File.Delete(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + file);  
  229.         }  
  230.         #endregion  
  231.  
  232.         #region 创建文件  
  233.         /// <summary>  
  234.         /// 创建文件  
  235.         /// </summary>  
  236.         /// <param name="dir">带后缀的文件名</param>  
  237.         /// <param name="pagestr">文件内容</param>  
  238.         public static void CreateFile(string dir, string pagestr)  
  239.         {  
  240.             dir = dir.Replace("/", "\");  
  241.             if (dir.IndexOf("\") > -1)  
  242.                 CreateDir(dir.Substring(0, dir.LastIndexOf("\")));  
  243.             System.IO.StreamWriter sw = new System.IO.StreamWriter(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir, false, System.Text.Encoding.GetEncoding("GB2312"));  
  244.             sw.Write(pagestr);  
  245.             sw.Close();  
  246.         }  
  247.         #endregion  
  248.  
  249.         #region 移动文件(剪贴--粘贴)  
  250.         /// <summary>  
  251.         /// 移动文件(剪贴--粘贴)  
  252.         /// </summary>  
  253.         /// <param name="dir1">要移动的文件的路径及全名(包括后缀)</param>  
  254.         /// <param name="dir2">文件移动到新的位置,并指定新的文件名</param>  
  255.         public static void MoveFile(string dir1, string dir2)  
  256.         {  
  257.             dir1 = dir1.Replace("/", "\");  
  258.             dir2 = dir2.Replace("/", "\");  
  259.             if (File.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir1))  
  260.                 File.Move(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir1, System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir2);  
  261.         }  
  262.         #endregion  
  263.  
  264.         #region 复制文件  
  265.         /// <summary>  
  266.         /// 复制文件  
  267.         /// </summary>  
  268.         /// <param name="dir1">要复制的文件的路径已经全名(包括后缀)</param>  
  269.         /// <param name="dir2">目标位置,并指定新的文件名</param>  
  270.         public static void CopyFile(string dir1, string dir2)  
  271.         {  
  272.             dir1 = dir1.Replace("/", "\");  
  273.             dir2 = dir2.Replace("/", "\");  
  274.             if (File.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir1))  
  275.             {  
  276.                 File.Copy(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir1, System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\" + dir2, true);  
  277.             }  
  278.         }  
  279.         #endregion  
  280.  
  281.         #region 根据时间得到目录名 / 格式:yyyyMMdd 或者 HHmmssff  
  282.         /// <summary>  
  283.         /// 根据时间得到目录名yyyyMMdd  
  284.         /// </summary>  
  285.         /// <returns></returns>  
  286.         public static string GetDateDir()  
  287.         {  
  288.             return DateTime.Now.ToString("yyyyMMdd");  
  289.         }  
  290.         /// <summary>  
  291.         /// 根据时间得到文件名HHmmssff  
  292.         /// </summary>  
  293.         /// <returns></returns>  
  294.         public static string GetDateFile()  
  295.         {  
  296.             return DateTime.Now.ToString("HHmmssff");  
  297.         }  
  298.         #endregion  
  299.  
  300.         #region 复制文件夹  
  301.         /// <summary>  
  302.         /// 复制文件夹(递归)  
  303.         /// </summary>  
  304.         /// <param name="varFromDirectory">源文件夹路径</param>  
  305.         /// <param name="varToDirectory">目标文件夹路径</param>  
  306.         public static void CopyFolder(string varFromDirectory, string varToDirectory)  
  307.         {  
  308.             Directory.CreateDirectory(varToDirectory);  
  309.   
  310.             if (!Directory.Exists(varFromDirectory)) return;  
  311.   
  312.             string[] directories = Directory.GetDirectories(varFromDirectory);  
  313.   
  314.             if (directories.Length > 0)  
  315.             {  
  316.                 foreach (string d in directories)  
  317.                 {  
  318.                     CopyFolder(d, varToDirectory + d.Substring(d.LastIndexOf("\")));  
  319.                 }  
  320.             }  
  321.             string[] files = Directory.GetFiles(varFromDirectory);  
  322.             if (files.Length > 0)  
  323.             {  
  324.                 foreach (string s in files)  
  325.                 {  
  326.                     File.Copy(s, varToDirectory + s.Substring(s.LastIndexOf("\")), true);  
  327.                 }  
  328.             }  
  329.         }  
  330.         #endregion  
  331.  
  332.         #region 检查文件,如果文件不存在则创建  
  333.         /// <summary>  
  334.         /// 检查文件,如果文件不存在则创建    
  335.         /// </summary>  
  336.         /// <param name="FilePath">路径,包括文件名</param>  
  337.         public static void ExistsFile(string FilePath)  
  338.         {  
  339.             //if(!File.Exists(FilePath))      
  340.             //File.Create(FilePath);      
  341.             //以上写法会报错,详细解释请看下文.........     
  342.             if (!File.Exists(FilePath))  
  343.             {  
  344.                 FileStream fs = File.Create(FilePath);  
  345.                 fs.Close();  
  346.             }  
  347.         }  
  348.         #endregion  
  349.  
  350.         #region 删除指定文件夹对应其他文件夹里的文件  
  351.         /// <summary>  
  352.         /// 删除指定文件夹对应其他文件夹里的文件  
  353.         /// </summary>  
  354.         /// <param name="varFromDirectory">指定文件夹路径</param>  
  355.         /// <param name="varToDirectory">对应其他文件夹路径</param>  
  356.         public static void DeleteFolderFiles(string varFromDirectory, string varToDirectory)  
  357.         {  
  358.             Directory.CreateDirectory(varToDirectory);  
  359.   
  360.             if (!Directory.Exists(varFromDirectory)) return;  
  361.   
  362.             string[] directories = Directory.GetDirectories(varFromDirectory);  
  363.   
  364.             if (directories.Length > 0)  
  365.             {  
  366.                 foreach (string d in directories)  
  367.                 {  
  368.                     DeleteFolderFiles(d, varToDirectory + d.Substring(d.LastIndexOf("\")));  
  369.                 }  
  370.             }  
  371.   
  372.   
  373.             string[] files = Directory.GetFiles(varFromDirectory);  
  374.   
  375.             if (files.Length > 0)  
  376.             {  
  377.                 foreach (string s in files)  
  378.                 {  
  379.                     File.Delete(varToDirectory + s.Substring(s.LastIndexOf("\")));  
  380.                 }  
  381.             }  
  382.         }  
  383.         #endregion  
  384.  
  385.         #region 从文件的绝对路径中获取文件名( 包含扩展名 )  
  386.         /// <summary>  
  387.         /// 从文件的绝对路径中获取文件名( 包含扩展名 )  
  388.         /// </summary>  
  389.         /// <param name="filePath">文件的绝对路径</param>          
  390.         public static string GetFileName(string filePath)  
  391.         {  
  392.             //获取文件的名称  
  393.             FileInfo fi = new FileInfo(filePath);  
  394.             return fi.Name;  
  395.         }  
  396.         #endregion  
  397.   
  398.         /// <summary>  
  399.         /// 复制文件参考方法,页面中引用  
  400.         /// </summary>  
  401.         /// <param name="cDir">新路径</param>  
  402.         /// <param name="TempId">模板引擎替换编号</param>  
  403.         public static void CopyFiles(string cDir, string TempId)  
  404.         {  
  405.             //if (Directory.Exists(Request.PhysicalApplicationPath + "\Controls"))  
  406.             //{  
  407.             //    string TempStr = string.Empty;  
  408.             //    StreamWriter sw;  
  409.             //    if (File.Exists(Request.PhysicalApplicationPath + "\Controls\Default.aspx"))  
  410.             //    {  
  411.             //        TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\Controls\Default.aspx");  
  412.             //        TempStr = TempStr.Replace("{$ChannelId$}", TempId);  
  413.   
  414.             //        sw = new StreamWriter(Request.PhysicalApplicationPath + "\" + cDir + "\Default.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));  
  415.             //        sw.Write(TempStr);  
  416.             //        sw.Close();  
  417.             //    }  
  418.             //    if (File.Exists(Request.PhysicalApplicationPath + "\Controls\Column.aspx"))  
  419.             //    {  
  420.             //        TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\Controls\Column.aspx");  
  421.             //        TempStr = TempStr.Replace("{$ChannelId$}", TempId);  
  422.   
  423.             //        sw = new StreamWriter(Request.PhysicalApplicationPath + "\" + cDir + "\List.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));  
  424.             //        sw.Write(TempStr);  
  425.             //        sw.Close();  
  426.             //    }  
  427.             //    if (File.Exists(Request.PhysicalApplicationPath + "\Controls\Content.aspx"))  
  428.             //    {  
  429.             //        TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\Controls\Content.aspx");  
  430.             //        TempStr = TempStr.Replace("{$ChannelId$}", TempId);  
  431.   
  432.             //        sw = new StreamWriter(Request.PhysicalApplicationPath + "\" + cDir + "\View.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));  
  433.             //        sw.Write(TempStr);  
  434.             //        sw.Close();  
  435.             //    }  
  436.             //    if (File.Exists(Request.PhysicalApplicationPath + "\Controls\MoreDiss.aspx"))  
  437.             //    {  
  438.             //        TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\Controls\MoreDiss.aspx");  
  439.             //        TempStr = TempStr.Replace("{$ChannelId$}", TempId);  
  440.   
  441.             //        sw = new StreamWriter(Request.PhysicalApplicationPath + "\" + cDir + "\DissList.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));  
  442.             //        sw.Write(TempStr);  
  443.             //        sw.Close();  
  444.             //    }  
  445.             //    if (File.Exists(Request.PhysicalApplicationPath + "\Controls\ShowDiss.aspx"))  
  446.             //    {  
  447.             //        TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\Controls\ShowDiss.aspx");  
  448.             //        TempStr = TempStr.Replace("{$ChannelId$}", TempId);  
  449.   
  450.             //        sw = new StreamWriter(Request.PhysicalApplicationPath + "\" + cDir + "\Diss.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));  
  451.             //        sw.Write(TempStr);  
  452.             //        sw.Close();  
  453.             //    }  
  454.             //    if (File.Exists(Request.PhysicalApplicationPath + "\Controls\Review.aspx"))  
  455.             //    {  
  456.             //        TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\Controls\Review.aspx");  
  457.             //        TempStr = TempStr.Replace("{$ChannelId$}", TempId);  
  458.   
  459.             //        sw = new StreamWriter(Request.PhysicalApplicationPath + "\" + cDir + "\Review.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));  
  460.             //        sw.Write(TempStr);  
  461.             //        sw.Close();  
  462.             //    }  
  463.             //    if (File.Exists(Request.PhysicalApplicationPath + "\Controls\Search.aspx"))  
  464.             //    {  
  465.             //        TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\Controls\Search.aspx");  
  466.             //        TempStr = TempStr.Replace("{$ChannelId$}", TempId);  
  467.   
  468.             //        sw = new StreamWriter(Request.PhysicalApplicationPath + "\" + cDir + "\Search.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));  
  469.             //        sw.Write(TempStr);  
  470.             //        sw.Close();  
  471.             //    }  
  472.             //}  
  473.         }  
  474.  
  475.         #region 创建一个目录  
  476.         /// <summary>  
  477.         /// 创建一个目录  
  478.         /// </summary>  
  479.         /// <param name="directoryPath">目录的绝对路径</param>  
  480.         public static void CreateDirectory(string directoryPath)  
  481.         {  
  482.             //如果目录不存在则创建该目录  
  483.             if (!IsExistDirectory(directoryPath))  
  484.             {  
  485.                 Directory.CreateDirectory(directoryPath);  
  486.             }  
  487.         }  
  488.         #endregion  
  489.  
  490.         #region 创建一个文件  
  491.         /// <summary>  
  492.         /// 创建一个文件。  
  493.         /// </summary>  
  494.         /// <param name="filePath">文件的绝对路径</param>  
  495.         public static void CreateFile(string filePath)  
  496.         {  
  497.             try  
  498.             {  
  499.                 //如果文件不存在则创建该文件  
  500.                 if (!IsExistFile(filePath))  
  501.                 {  
  502.                     //创建一个FileInfo对象  
  503.                     FileInfo file = new FileInfo(filePath);  
  504.   
  505.                     //创建文件  
  506.                     FileStream fs = file.Create();  
  507.   
  508.                     //关闭文件流  
  509.                     fs.Close();  
  510.                 }  
  511.             }  
  512.             catch (Exception ex)  
  513.             {  
  514.                 //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);  
  515.                 throw ex;  
  516.             }  
  517.         }  
  518.   
  519.         /// <summary>  
  520.         /// 创建一个文件,并将字节流写入文件。  
  521.         /// </summary>  
  522.         /// <param name="filePath">文件的绝对路径</param>  
  523.         /// <param name="buffer">二进制流数据</param>  
  524.         public static void CreateFile(string filePath, byte[] buffer)  
  525.         {  
  526.             try  
  527.             {  
  528.                 //如果文件不存在则创建该文件  
  529.                 if (!IsExistFile(filePath))  
  530.                 {  
  531.                     //创建一个FileInfo对象  
  532.                     FileInfo file = new FileInfo(filePath);  
  533.   
  534.                     //创建文件  
  535.                     FileStream fs = file.Create();  
  536.   
  537.                     //写入二进制流  
  538.                     fs.Write(buffer, 0, buffer.Length);  
  539.   
  540.                     //关闭文件流  
  541.                     fs.Close();  
  542.                 }  
  543.             }  
  544.             catch (Exception ex)  
  545.             {  
  546.                 //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);  
  547.                 throw ex;  
  548.             }  
  549.         }  
  550.         #endregion  
  551.  
  552.         #region 获取文本文件的行数  
  553.         /// <summary>  
  554.         /// 获取文本文件的行数  
  555.         /// </summary>  
  556.         /// <param name="filePath">文件的绝对路径</param>          
  557.         public static int GetLineCount(string filePath)  
  558.         {  
  559.             //将文本文件的各行读到一个字符串数组中  
  560.             string[] rows = File.ReadAllLines(filePath);  
  561.   
  562.             //返回行数  
  563.             return rows.Length;  
  564.         }  
  565.         #endregion  
  566.  
  567.         #region 获取一个文件的长度  
  568.         /// <summary>  
  569.         /// 获取一个文件的长度,单位为Byte  
  570.         /// </summary>  
  571.         /// <param name="filePath">文件的绝对路径</param>          
  572.         public static int GetFileSize(string filePath)  
  573.         {  
  574.             //创建一个文件对象  
  575.             FileInfo fi = new FileInfo(filePath);  
  576.   
  577.             //获取文件的大小  
  578.             return (int)fi.Length;  
  579.         }  
  580.         #endregion  
  581.  
  582.         #region 获取指定目录中的子目录列表  
  583.         /// <summary>  
  584.         /// 获取指定目录及子目录中所有子目录列表  
  585.         /// </summary>  
  586.         /// <param name="directoryPath">指定目录的绝对路径</param>  
  587.         /// <param name="searchPattern">模式字符串,"*"代表0或N个字符,"?"代表1个字符。  
  588.         /// 范例:"Log*.xml"表示搜索所有以Log开头的Xml文件。</param>  
  589.         /// <param name="isSearchChild">是否搜索子目录</param>  
  590.         public static string[] GetDirectories(string directoryPath, string searchPattern, bool isSearchChild)  
  591.         {  
  592.             try  
  593.             {  
  594.                 if (isSearchChild)  
  595.                 {  
  596.                     return Directory.GetDirectories(directoryPath, searchPattern, SearchOption.AllDirectories);  
  597.                 }  
  598.                 else  
  599.                 {  
  600.                     return Directory.GetDirectories(directoryPath, searchPattern, SearchOption.TopDirectoryOnly);  
  601.                 }  
  602.             }  
  603.             catch (IOException ex)  
  604.             {  
  605.                 throw ex;  
  606.             }  
  607.         }  
  608.         #endregion  
  609.  
  610.         #region 向文本文件写入内容  
  611.   
  612.         /// <summary>  
  613.         /// 向文本文件中写入内容  
  614.         /// </summary>  
  615.         /// <param name="filePath">文件的绝对路径</param>  
  616.         /// <param name="text">写入的内容</param>  
  617.         /// <param name="encoding">编码</param>  
  618.         public static void WriteText(string filePath, string text, Encoding encoding)  
  619.         {  
  620.             //向文件写入内容  
  621.             File.WriteAllText(filePath, text, encoding);  
  622.         }  
  623.         #endregion  
  624.  
  625.         #region 向文本文件的尾部追加内容  
  626.         /// <summary>  
  627.         /// 向文本文件的尾部追加内容  
  628.         /// </summary>  
  629.         /// <param name="filePath">文件的绝对路径</param>  
  630.         /// <param name="content">写入的内容</param>  
  631.         public static void AppendText(string filePath, string content)  
  632.         {  
  633.             File.AppendAllText(filePath, content);  
  634.         }  
  635.         #endregion  
  636.  
  637.         #region 将现有文件的内容复制到新文件中  
  638.         /// <summary>  
  639.         /// 将源文件的内容复制到目标文件中  
  640.         /// </summary>  
  641.         /// <param name="sourceFilePath">源文件的绝对路径</param>  
  642.         /// <param name="destFilePath">目标文件的绝对路径</param>  
  643.         public static void Copy(string sourceFilePath, string destFilePath)  
  644.         {  
  645.             File.Copy(sourceFilePath, destFilePath, true);  
  646.         }  
  647.         #endregion  
  648.  
  649.         #region 将文件移动到指定目录  
  650.         /// <summary>  
  651.         /// 将文件移动到指定目录  
  652.         /// </summary>  
  653.         /// <param name="sourceFilePath">需要移动的源文件的绝对路径</param>  
  654.         /// <param name="descDirectoryPath">移动到的目录的绝对路径</param>  
  655.         public static void Move(string sourceFilePath, string descDirectoryPath)  
  656.         {  
  657.             //获取源文件的名称  
  658.             string sourceFileName = GetFileName(sourceFilePath);  
  659.   
  660.             if (IsExistDirectory(descDirectoryPath))  
  661.             {  
  662.                 //如果目标中存在同名文件,则删除  
  663.                 if (IsExistFile(descDirectoryPath + "\" + sourceFileName))  
  664.                 {  
  665.                     DeleteFile(descDirectoryPath + "\" + sourceFileName);  
  666.                 }  
  667.                 //将文件移动到指定目录  
  668.                 File.Move(sourceFilePath, descDirectoryPath + "\" + sourceFileName);  
  669.             }  
  670.         }  
  671.         #endregion  
  672.  
  673.         #region 从文件的绝对路径中获取文件名( 不包含扩展名 )  
  674.         /// <summary>  
  675.         /// 从文件的绝对路径中获取文件名( 不包含扩展名 )  
  676.         /// </summary>  
  677.         /// <param name="filePath">文件的绝对路径</param>          
  678.         public static string GetFileNameNoExtension(string filePath)  
  679.         {  
  680.             //获取文件的名称  
  681.             FileInfo fi = new FileInfo(filePath);  
  682.             return fi.Name.Split(’.’)[0];  
  683.         }  
  684.         #endregion  
  685.  
  686.         #region 从文件的绝对路径中获取扩展名  
  687.         /// <summary>  
  688.         /// 从文件的绝对路径中获取扩展名  
  689.         /// </summary>  
  690.         /// <param name="filePath">文件的绝对路径</param>          
  691.         public static string GetExtension(string filePath)  
  692.         {  
  693.             //获取文件的名称  
  694.             FileInfo fi = new FileInfo(filePath);  
  695.             return fi.Extension;  
  696.         }  
  697.         #endregion  
  698.  
  699.         #region 清空指定目录  
  700.         /// <summary>  
  701.         /// 清空指定目录下所有文件及子目录,但该目录依然保存.  
  702.         /// </summary>  
  703.         /// <param name="directoryPath">指定目录的绝对路径</param>  
  704.         public static void ClearDirectory(string directoryPath)  
  705.         {  
  706.             if (IsExistDirectory(directoryPath))  
  707.             {  
  708.                 //删除目录中所有的文件  
  709.                 string[] fileNames = GetFileNames(directoryPath);  
  710.                 for (int i = 0; i < fileNames.Length; i++)  
  711.                 {  
  712.                     DeleteFile(fileNames[i]);  
  713.                 }  
  714.   
  715.                 //删除目录中所有的子目录  
  716.                 string[] directoryNames = GetDirectories(directoryPath);  
  717.                 for (int i = 0; i < directoryNames.Length; i++)  
  718.                 {  
  719.                     DeleteDirectory(directoryNames[i]);  
  720.                 }  
  721.             }  
  722.         }  
  723.         #endregion  
  724.  
  725.         #region 清空文件内容  
  726.         /// <summary>  
  727.         /// 清空文件内容  
  728.         /// </summary>  
  729.         /// <param name="filePath">文件的绝对路径</param>  
  730.         public static void ClearFile(string filePath)  
  731.         {  
  732.             //删除文件  
  733.             File.Delete(filePath);  
  734.   
  735.             //重新创建该文件  
  736.             CreateFile(filePath);  
  737.         }  
  738.         #endregion  
  739.  
  740.         #region 删除指定目录  
  741.         /// <summary>  
  742.         /// 删除指定目录及其所有子目录  
  743.         /// </summary>  
  744.         /// <param name="directoryPath">指定目录的绝对路径</param>
  745.         public static void DeleteDirectory(string directoryPath)
  746.         {
  747.             if (IsExistDirectory(directoryPath))
  748.             {
  749.                 Directory.Delete(directoryPath, true);
  750.             }
  751.         }
  752.         #endregion  
  753.     }

weinxin
微信公众号
博客微信公众号,欢迎关注。
广告也精彩

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

目前评论:2   其中:访客  1   博主  1

    • avatar 久伴 4

      久伴来访问了

      • avatar 萧瑟 博主

        @久伴:欢迎,欢迎