c#文件操作简单封装工具类

因为在.net mvc 中 File类命名空间总是冲突，自己封装了一个FileHelper类，今日分享给大家

 

  public static class FileHelper
  {

      /// <summary>
      /// 文件下载
      /// </summary>
      /// <param name="downLoadUrl">下载请求地址</param>
      /// <param name="savePath">保存路径</param>
      /// <param name="fileName">文件名</param>
      /// <param name="fileExtension">文件拓展名</param>
      /// <returns>文件路径</returns>
      public static async Task<string> FileDownLoadAsync(string downLoadUrl, string savePath, string fileName, string fileExtension)
      {
          using (HttpClient client = new HttpClient())
          {
              // 发送GET请求并获取数据
              byte[] fileData = await client.GetByteArrayAsync(downLoadUrl);               
              var filepath = Path.Combine(savePath, fileName);
              File.WriteAllBytes(filepath, fileData);
              return filepath;
          }
      }

      /// <summary>
      /// 根据输入的文件夹路径创建目录路径。
      /// </summary>
      /// <param name="directoryPath">文件夹路径。</param>
      /// <param name="isDelFile">指定是否清除文件夹中的文件（如果文件夹已存在）。</param>
      /// <returns>目录路径。</returns>
      public static string CreateFolder(string directoryPath, bool isDelFile = false)
      {
          if (!Directory.Exists(directoryPath))
          {
              Directory.CreateDirectory(directoryPath);
          }

          if (isDelFile)
          {
              DeleteFolderContents(directoryPath);
          }
          return directoryPath;
      }

      /// <summary>
      /// 删除指定文件夹中的所有文件和子文件夹，但保留文件夹本身。
      /// </summary>
      /// <param name="folderPath">应删除其内容的文件夹路径。</param>
      public static void DeleteFolderContents(string folderPath)
      {
          // 删除文件夹中的所有文件
          foreach (string file in Directory.GetFiles(folderPath))
          {
              try
              {
                  File.Delete(file);
              }
              catch (Exception ex)
              {
                  // 处理删除文件时发生的异常
                  Console.WriteLine($"无法删除文件 '{file}': {ex.Message}");
              }
          }

          // 递归删除文件夹中所有子文件夹的内容
          foreach (string subfolder in Directory.GetDirectories(folderPath))
          {
              try
              {
                  DeleteFolderContents(subfolder);
              }
              catch (Exception ex)
              {
                  // 处理递归删除子文件夹时发生的异常
                  Console.WriteLine($"无法删除文件夹 '{subfolder}': {ex.Message}");
              }
          }
      }


      /// <summary>
      /// 将文件重命名为源文件名+bak+日期，并可选择备份到指定路径。
      /// </summary>
      /// <param name="filePath">要备份的文件路径。</param>
      /// <param name="backupPath">可选参数，备份文件的路径。如果不填，则默认为原路径。</param>
      public static void BackupFile(string filePath, string backupPath = null)
      {
          if (File.Exists(filePath))
          {
              string directory = Path.GetDirectoryName(filePath);
              string fileName = Path.GetFileNameWithoutExtension(filePath);
              string extension = Path.GetExtension(filePath);
              string date = DateTime.Now.ToString("yyyyMMddHHmmss");

              string newFilePath;
              if (string.IsNullOrEmpty(backupPath))
              {
                  newFilePath = Path.Combine(directory, $"{fileName}_bak_{date}{extension}");
              }
              else
              {
                  // 如果备份路径不存在，则创建备份路径
                  if (!Directory.Exists(backupPath))
                  {
                      Directory.CreateDirectory(backupPath);
                  }

                  newFilePath = Path.Combine(backupPath, $"{fileName}_bak_{date}{extension}");
              }

              File.Move(filePath, newFilePath);
              Console.WriteLine($"文件 '{filePath}' 已重命名为 '{newFilePath}'。");
          }
          else
          {
              throw new FileNotFoundException($"文件 '{filePath}' 不存在。");
          }
      }

      /// <summary>
      /// 移动文件从一个位置到另一个位置。
      /// </summary>
      /// <param name="sourceFilePath">源文件的路径。</param>
      /// <param name="destinationFilePath">目标文件的路径(要带名字)。</param>
      public static void MoveFile(string sourceFilePath, string destinationFilePath)
      {
          // 检查源文件是否存在
          if (!File.Exists(sourceFilePath))
          {
              throw new FileNotFoundException("源文件不存在。", sourceFilePath);
          }

          // 移动文件
          File.Move(sourceFilePath, destinationFilePath);
      }
      /// <summary>
      /// 将给定的字节数组保存为指定路径的文件。
      /// </summary>
      /// <param name="bytes">要保存为文件的字节数组。</param>
      /// <param name="saveFileFullPath">要保存文件的完整路径。</param>
      public static void SaveFile(this byte[] bytes, string saveFileFullPath)
      {
          File.WriteAllBytes(saveFileFullPath, bytes);
      }

      /// <summary>
      /// 从指定的源目录创建zip文件。
      /// </summary>
      /// <param name="sourceDirectory">源目录的路径。</param>
      /// <param name="zipFilePath">目标zip文件的路径。</param>
      /// <param name="encoding">字符编码 【设置默认编码为UTF-8】</param>
      public static void CreateZipFile(string sourceDirectory, string zipFilePath, Encoding encoding)
      {
          using (var zip = ZipArchive.Create())
          {
              foreach (var file in Directory.EnumerateFiles(sourceDirectory))
              {
                  zip.AddEntry(Path.GetFileName(file), file);
              }
              var options = new WriterOptions(CompressionType.Deflate)
              {
                  ArchiveEncoding = new ArchiveEncoding
                  {
                      Default = encoding // 设置默认编码为UTF-8
                  },
                  LeaveStreamOpen = false
              };
              zip.SaveTo(zipFilePath, options);
          }
      }


      /// <summary>
      /// 将zip文件解压缩到指定的解压目录。
      /// </summary>
      /// <param name="zipFilePath">要解压缩的zip文件的路径。</param>
      /// <param name="extractionDirectory">解压目录的路径。</param>
      public static void ExtractZipFile(string zipFilePath, string extractionDirectory)
      {
          using (var zip = ZipArchive.Open(zipFilePath))
          {
              foreach (var entry in zip.Entries)
              {
                  entry.WriteToDirectory(extractionDirectory, new ExtractionOptions()
                  {
                      ExtractFullPath = true,
                      Overwrite = true
                  });
              }
          }
      }

      /// <summary>
      /// 将一个文件转换为byte[]
      /// </summary>
      /// <param name="filePath">文件路径</param>
      /// <returns>byte[]</returns>
      public static byte[] FileConvertToByteArray(string filePath)
      {
          if (File.Exists(filePath))
          {
              return File.ReadAllBytes(filePath);
          }
          return null;
      }
  }