您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:文件操作大全,文件操作类1

新葡亰496net:文件操作大全,文件操作类1

发布时间:2019-11-23 15:13编辑:奥门新萄京娱乐场浏览(181)

    C#中没有重命名的方法,自己写了一个方法,来处理文件的重命名。

    C#文件操作大全

    using System;
    using System.Text;
    using System.IO;

    /// <summary>   

    文件与文件夹操作主要用到以下几个类:

    namespace DotNet.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

    /// 重命名文件夹内的所有子文件夹   

      1.File类:  

            #region 检测指定文件是否存在,如果存在返回true
            /// <summary>
            /// 检测指定文件是否存在,如果存在则返回true。
            /// </summary>
            /// <param name="filePath">文件的绝对路径</param>       
            public static bool IsExistFile(string filePath)
            {
                return File.Exists(filePath);
            }
            #endregion

    /// </summary>   

    提供用于创建、复制、删除、移动和打开文件的静态方法,并协助创建 FileStream 对象。

            #region 获取指定目录中的文件列表
            /// <summary>
            /// 获取指定目录中所有文件列表
            /// </summary>
            /// <param name="directoryPath">指定目录的绝对路径</param>       
            public static string[] GetFileNames(string directoryPath)
            {
                //如果目录不存在,则抛出异常
                if (!IsExistDirectory(directoryPath))
                {
                    throw new FileNotFoundException();
                }

    /// <param name="directoryName">文件夹名称</param>   

        msdn:

                //获取文件列表
                return Directory.GetFiles(directoryPath);
            }
            #endregion

    /// <param name="newDirectoryName">新子文件夹名称格式字符串</param>   

      2.FileInfo类:

            #新葡亰496net,region 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.
            /// <summary>
            /// 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.
            /// </summary>
            /// <param name="directoryPath">指定目录的绝对路径</param>       
            public static string[] GetDirectories(string directoryPath)
            {
                try
                {
                    return Directory.GetDirectories(directoryPath);
                }
                catch (IOException ex)
                {
                    throw ex;
                }
            }
            #endregion

    public void RenameDirectories(string directoryName, string newDirectoryName)   

        提供创建、复制、删除、移动和打开文件的实例方法,并且帮助创建 FileStream 对象

            #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();
                }

    {   

        msdn:

                try
                {
                    if (isSearchChild)
                    {
                        return Directory.GetFiles(directoryPath, searchPattern, SearchOption.AllDirectories);
                    }
                    else
                    {
                        return Directory.GetFiles(directoryPath, searchPattern, SearchOption.TopDirectoryOnly);
                    }
                }
                catch (IOException ex)
                {
                    throw ex;
                }
            }
            #endregion

      int i = 1;   

      3.Directory类:

            #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[] sDirectories = Directory.GetDirectories(directoryName);   

        公开用于创建、移动和枚举通过目录和子目录的静态方法。

                    //判断是否存在文件夹
                    string[] directoryNames = GetDirectories(directoryPath);
                    if (directoryNames.Length > 0)
                    {
                        return false;
                    }

      foreach (string sDirectory in sDirectories)   

        msdn:

                    return true;
                }
                catch
                {
                    //这里记录日志
                    //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
                    return true;
                }
            }
            #endregion

        {   

      4.DirectoryInfo类:

            #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);

        string sDirectoryName = Path.GetFileName(sDirectory);   

        公开用于创建、移动和枚举目录和子目录的实例方法。

                    //判断指定文件是否存在
                    if (fileNames.Length == 0)
                    {
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                    //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
                }
            }

        string sNewDirectoryName = string.Format(newDirectoryName, i );   

        msdn:

            /// <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);

        string sNewDirectory = Path.Combine(directoryName, sNewDirectoryName);   

      (注:以下出现的dirPath表示文件夹路径,filePath表示文件路径)

                    //判断指定文件是否存在
                    if (fileNames.Length == 0)
                    {
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                    //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
                }
            }
            #endregion

             Directory.Move(sDirectory, sNewDirectory);   

     

            #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

        }   

    1.创建文件夹  

    • "\" dir))
                      Directory.CreateDirectory(System.Web.HttpContext.Current.Request.PhysicalApplicationPath
    • "\" dir);
              }
              #endregion

    }  

    Directory.CreateDirectory(@"D:TestDir");

            #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

     

    2.创建文件

    • "\" dir))
                      Directory.Delete(System.Web.HttpContext.Current.Request.PhysicalApplicationPath
    • "\" dir);
              }
              #endregion

     

      创建文件会出现文件被访问,以至于无法删除以及编辑。建议用上using。

            #region 删除文件
            /// <summary>
            /// 删除文件
            /// </summary>
            /// <param name="file">要删除的文件路径和名称</param>
            public static void DeleteFile(string file)
            {
                if (File.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath

                    // 列表中的原始文件全路径名
                    string oldStr = ft.FileRoute @"/" ft.FileName ft.ExName;

    using (File.Create(@"D:TestDirTestFile.txt"));

    • file))
                      File.Delete(System.Web.HttpContext.Current.Request.PhysicalApplicationPath
    • file);
              }
              #endregion

                    // 新文件名
                    string newStr = ft.FileRoute @"/" preChar   name nextChar ft.ExName;

    3.删除文件
      删除文件时,最好先判断该文件是否存在!

            #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

                    // 改名方法
                    FileInfo fi = new FileInfo(oldStr);
                    fi.MoveTo(Path.Combine(newStr));

    if (File.Exists(filePath))
    {
    File.Delete(filePath);
    }

    • "\" dir, false, System.Text.Encoding.GetEncoding("GB2312"));
                  sw.Write(pagestr);
                  sw.Close();
              }
              #endregion

    4.删除文件夹

            #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

      删除文件夹需要对异常进行处理。可捕获指定的异常。msdn:

    • "\" dir1))
                      File.Move(System.Web.HttpContext.Current.Request.PhysicalApplicationPath
    • "\" dir1, System.Web.HttpContext.Current.Request.PhysicalApplicationPath "\"
    • dir2);
              }
              #endregion

    Directory.Delete(dirPath); //删除空目录,否则需捕获指定异常处理
    Directory.Delete(dirPath, true);//删除该目录以及其所有内容

            #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

    5.删除指定目录下所有的文件和文件夹

    • "\" dir1))
                  {
                      File.Copy(System.Web.HttpContext.Current.Request.PhysicalApplicationPath
    • "\" dir1, System.Web.HttpContext.Current.Request.PhysicalApplicationPath "\"
    • dir2, true);
                  }
              }
              #endregion

      一般有两种方法:1.删除目录后,创建空目录 2.找出下层文件和文件夹路径迭代删除

            #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

    复制代码
    /// <summary>
    /// 删除指定目录下所有内容:方法一--删除目录,再创建空目录
    /// </summary>
    /// <param name="dirPath"></param>
    public static void DeleteDirectoryContentEx(string dirPath)
    {
    if (Directory.Exists(dirPath))
    {
    Directory.Delete(dirPath);
    Directory.CreateDirectory(dirPath);
    }
    }

            #region 复制文件夹
            /// <summary>
            /// 复制文件夹(递归)
            /// </summary>
            /// <param name="varFromDirectory">源文件夹路径</param>
            /// <param name="varToDirectory">目标文件夹路径</param>
            public static void CopyFolder(string varFromDirectory, string varToDirectory)
            {
                Directory.CreateDirectory(varToDirectory);

    /// <summary>
    /// 删除指定目录下所有内容:方法二--找到所有文件和子文件夹删除
    /// </summary>
    /// <param name="dirPath"></param>
    public static void DeleteDirectoryContent(string dirPath)
    {
    if (Directory.Exists(dirPath))
    {
    foreach (string content in Directory.GetFileSystemEntries(dirPath))
    {
    if (Directory.Exists(content))
    {
    Directory.Delete(content, true);
    }
    else if (File.Exists(content))
    {
    File.Delete(content);
    }
    }
    }
    }
    复制代码

                if (!Directory.Exists(varFromDirectory)) return;

    6.读取文件

                string[] directories = Directory.GetDirectories(varFromDirectory);

      读取文件方法很多,File类已经封装了四种:

                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

      一、直接使用File类

            #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

        1.public static string ReadAllText(string path); 

            #region 删除指定文件夹对应其他文件夹里的文件
            /// <summary>
            /// 删除指定文件夹对应其他文件夹里的文件
            /// </summary>
            /// <param name="varFromDirectory">指定文件夹路径</param>
            /// <param name="varToDirectory">对应其他文件夹路径</param>
            public static void DeleteFolderFiles(string varFromDirectory, string varToDirectory)
            {
                Directory.CreateDirectory(varToDirectory);

        2.public static string[] ReadAllLines(string path);

                if (!Directory.Exists(varFromDirectory)) return;

        3.public static IEnumerable<string> ReadLines(string path);

                string[] directories = Directory.GetDirectories(varFromDirectory);

        4.public static byte[] ReadAllBytes(string path);

                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

        分别有StreamReader和FileStream。详细内容请看代码。  

            /// <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);

    复制代码
    //ReadAllLines
    Console.WriteLine("--{0}", "ReadAllLines");
    List<string> list = new List<string>(File.ReadAllLines(filePath));
    list.ForEach(str =>
    {
    Console.WriteLine(str);
    });

                //        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);

    //ReadAllText
    Console.WriteLine("--{0}", "ReadAllLines");
    string fileContent = File.ReadAllText(filePath);
    Console.WriteLine(fileContent);

                //        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);

    //StreamReader
    Console.WriteLine("--{0}", "StreamReader");
    using (StreamReader sr = new StreamReader(filePath))
    {
    //方法一:从流的当前位置到末尾读取流
    fileContent = string.Empty;
    fileContent = sr.ReadToEnd();
    Console.WriteLine(fileContent);
    //方法二:一行行读取直至为NULL
    fileContent = string.Empty;
    string strLine = string.Empty;
    while (strLine != null)
    {
    strLine = sr.ReadLine();
    fileContent = strLine "rn";
    }
    Console.WriteLine(fileContent);
    }
    复制代码    

                //        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);

    7.写入文件

                //        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);

    复制代码
    //WriteAllLines
    File.WriteAllLines(filePath,new string[]{"11111","22222","3333"});
    File.Delete(filePath);

                //        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);

    //WriteAllText
    File.WriteAllText(filePath, "11111rn22222rn3333rn");
    File.Delete(filePath);

                //        sw = new StreamWriter(Request.PhysicalApplicationPath "\" cDir "\Search.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));
                //        sw.Write(TempStr);
                //        sw.Close();
                //    }
                //}
            }

    //StreamWriter
    using (StreamWriter sw = new StreamWriter(filePath))
    {
    sw.Write("11111rn22222rn3333rn");
    sw.Flush();
    }
    复制代码

            #region 创建一个目录
            /// <summary>
            /// 创建一个目录
            /// </summary>
            /// <param name="directoryPath">目录的绝对路径</param>
            public static void CreateDirectory(string directoryPath)
            {
                //如果目录不存在则创建该目录
                if (!IsExistDirectory(directoryPath))
                {
                    Directory.CreateDirectory(directoryPath);
                }
            }
            #endregion

    9.文件路径

            #region 创建一个文件
            /// <summary>
            /// 创建一个文件。
            /// </summary>
            /// <param name="filePath">文件的绝对路径</param>
            public static void CreateFile(string filePath)
            {
                try
                {
                    //如果文件不存在则创建该文件
                    if (!IsExistFile(filePath))
                    {
                        //创建一个FileInfo对象
                        FileInfo file = new FileInfo(filePath);

      文件和文件夹的路径操作都在Path类中。另外还可以用Environment类,里面包含环境和程序的信息。

                        //创建文件
                        FileStream fs = file.Create();

    复制代码
    string dirPath = @"D:TestDir";
    string filePath = @"D:TestDirTestFile.txt";
    Console.WriteLine("<<<<<<<<<<<{0}>>>>>>>>>>", "文件路径");
    //获得当前路径
    Console.WriteLine(Environment.CurrentDirectory);
    //文件或文件夹所在目录
    Console.WriteLine(Path.GetDirectoryName(filePath)); //D:TestDir
    Console.WriteLine(Path.GetDirectoryName(dirPath)); //D:
    //文件扩展名
    Console.WriteLine(Path.GetExtension(filePath)); //.txt
    //文件名
    Console.WriteLine(Path.GetFileName(filePath)); //TestFile.txt
    Console.WriteLine(Path.GetFileName(dirPath)); //TestDir
    Console.WriteLine(Path.GetFileNameWithoutExtension(filePath)); //TestFile
    //绝对路径
    Console.WriteLine(Path.GetFullPath(filePath)); //D:TestDirTestFile.txt
    Console.WriteLine(Path.GetFullPath(dirPath)); //D:TestDir
    //更改扩展名
    Console.WriteLine(Path.ChangeExtension(filePath, ".jpg"));//D:TestDirTestFile.jpg
    //根目录
    Console.WriteLine(Path.GetPathRoot(dirPath)); //D:
    //生成路径
    Console.WriteLine(Path.Combine(new string[] { @"D:", "BaseDir", "SubDir", "TestFile.txt" })); //D:BaseDirSubDirTestFile.txt
    //生成随即文件夹名或文件名
    Console.WriteLine(Path.GetRandomFileName());
    //创建磁盘上唯一命名的零字节的临时文件并返回该文件的完整路径
    Console.WriteLine(Path.GetTempFileName());
    //返回当前系统的临时文件夹的路径
    Console.WriteLine(Path.GetTempPath());
    //文件名中无效字符
    Console.WriteLine(Path.GetInvalidFileNameChars());
    //路径中无效字符
    Console.WriteLine(Path.GetInvalidPathChars());
    复制代码

                        //关闭文件流
                        fs.Close();
                    }
                }
                catch (Exception ex)
                {
                    //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
                    throw ex;
                }
            }

    10.文件属性操作  

            /// <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);

      File类与FileInfo都能实现。静态方法与实例化方法的区别!

                        //创建文件
                        FileStream fs = file.Create();

    复制代码
    //use File class
    Console.WriteLine(File.GetAttributes(filePath));
    File.SetAttributes(filePath,FileAttributes.Hidden | FileAttributes.ReadOnly);
    Console.WriteLine(File.GetAttributes(filePath));

                        //写入二进制流
                        fs.Write(buffer, 0, buffer.Length);

    //user FilInfo class
    FileInfo fi = new FileInfo(filePath);
    Console.WriteLine(fi.Attributes.ToString());
    fi.Attributes = FileAttributes.Hidden | FileAttributes.ReadOnly; //隐藏与只读
    Console.WriteLine(fi.Attributes.ToString());

                        //关闭文件流
                        fs.Close();
                    }
                }
                catch (Exception ex)
                {
                    //LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
                    throw ex;
                }
            }
            #endregion

    //只读与系统属性,删除时会提示拒绝访问
    fi.Attributes = FileAttributes.Archive;
    Console.WriteLine(fi.Attributes.ToString());
    复制代码

            #region 获取文本文件的行数
            /// <summary>
            /// 获取文本文件的行数
            /// </summary>
            /// <param name="filePath">文件的绝对路径</param>       
            public static int GetLineCount(string filePath)
            {
                //将文本文件的各行读到一个字符串数组中
                string[] rows = File.ReadAllLines(filePath);

    11.移动文件夹中的所有文件夹与文件到另一个文件夹

                //返回行数
                return rows.Length;
            }
            #endregion

      如果是在同一个盘符中移动,则直接调用Directory.Move的方法即可!跨盘符则使用下面递归的方法!

            #region 获取一个文件的长度
            /// <summary>
            /// 获取一个文件的长度,单位为Byte
            /// </summary>
            /// <param name="filePath">文件的绝对路径</param>       
            public static int GetFileSize(string filePath)
            {
                //创建一个文件对象
                FileInfo fi = new FileInfo(filePath);

    复制代码
    /// <summary>
    /// 移动文件夹中的所有文件夹与文件到另一个文件夹
    /// </summary>
    /// <param name="sourcePath">源文件夹</param>
    /// <param name="destPath">目标文件夹</param>
    public static void MoveFolder(string sourcePath,string destPath)
    {
    if (Directory.Exists(sourcePath))
    {
    if (!Directory.Exists(destPath))
    {
    //目标目录不存在则创建
    try
    {
    Directory.CreateDirectory(destPath);
    }
    catch (Exception ex)
    {
    throw new Exception("创建目标目录失败:" ex.Message);
    }
    新葡亰496net:文件操作大全,文件操作类1。}
    //获得源文件下所有文件
    List<string> files = new List<string>(Directory.GetFiles(sourcePath));
    files.ForEach(c =>
    {
    string destFile = Path.Combine(new string[]{destPath,Path.GetFileName(c)});
    //覆盖模式
    if (File.Exists(destFile))
    {
    File.Delete(destFile);
    }
    File.Move(c, destFile);
    });
    //获得源文件下所有目录文件
    List<string> folders = new List<string>(Directory.GetDirectories(sourcePath));

                //获取文件的大小
                return (int)fi.Length;
            }
            #endregion

    folders.ForEach(c =>
    {
    string destDir = Path.Combine(new string[] { destPath, Path.GetFileName(c) });
    //Directory.Move必须要在同一个根目录下移动才有效,不能在不同卷中移动。
    //Directory.Move(c, destDir);

            #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

    //采用递归的方法实现
    MoveFolder(c, destDir);
    });
    }
    else
    {
    throw new DirectoryNotFoundException("源目录不存在!");
    }
    }
    复制代码

            #region 向文本文件写入内容

    12.复制文件夹中的所有文件夹与文件到另一个文件夹

            /// <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

      如果是需要移动指定类型的文件或者包含某些字符的目录,只需在Directory.GetFiles中加上查询条件即可!

            #region 向文本文件的尾部追加内容
            /// <summary>
            /// 向文本文件的尾部追加内容
            /// </summary>
            /// <param name="filePath">文件的绝对路径</param>
            /// <param name="content">写入的内容</param>
            public static void AppendText(string filePath, string content)
            {
                File.AppendAllText(filePath, content);
            }
            #endregion

    复制代码
    /// <summary>
    /// 复制文件夹中的所有文件夹与文件到另一个文件夹
    /// </summary>
    /// <param name="sourcePath">源文件夹</param>
    /// <param name="destPath">目标文件夹</param>
    public static void CopyFolder(string sourcePath,string destPath)
    {
    if (Directory.Exists(sourcePath))
    {
    if (!Directory.Exists(destPath))
    {
    //目标目录不存在则创建
    try
    {
    Directory.CreateDirectory(destPath);
    }
    catch (Exception ex)
    {
    throw new Exception("创建目标目录失败:" ex.Message);
    }
    }
    //获得源文件下所有文件
    List<string> files = new List<string>(Directory.GetFiles(sourcePath));
    files.ForEach(c =>
    {
    string destFile = Path.Combine(new string[]{destPath,Path.GetFileName(c)});
    File.Copy(c, destFile,true);//覆盖模式
    });
    //获得源文件下所有目录文件
    List<string> folders = new List<string>(Directory.GetDirectories(sourcePath));
    folders.ForEach(c =>
    {
    string destDir = Path.Combine(new string[] { destPath, Path.GetFileName(c) });
    //采用递归的方法实现
    CopyFolder(c, destDir);
    });
    }
    else
    {
    throw new DirectoryNotFoundException("源目录不存在!");
    }
    }
    复制代码

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

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:文件操作大全,文件操作类1

    关键词:

上一篇:新葡亰496net:主干语法

下一篇:没有了