当前位置： 首页 > article >正文

C# 常用的文件处理方法

article 2025/1/21 22:13:30

C# 常用的文件处理方法

文章目录

  • C# 常用的文件处理方法
  • 前言
  • 文件相关操作
    • 创建文本文件
    • 获取文件大小
      • 获取文件大小（单位:B）
      • 获取文件大小（单位：KB）
      • 获取文件大小(单位：MB)
      • 获取文件大小（单位：B，KB，GB，TB）
    • 文件判断
      • 是否为图片
      • 是否为excle
      • 判断是否是允许后缀名
      • 是否为压缩包
    • 文件后缀获取
      • 获取文件后缀名
      • 获取文件纯后缀
    • 文件剪切粘贴
    • 文件粘贴
    • 文件复制
    • 文件上传
    • 文件下载
    • 文件删除
  • 文件压缩与解压
    • 文件压缩
    • 解压文件
  • 文件夹相关操作
    • 创建文件夹
    • 检测指定目录是否为空
    • 获取指定目录中的子目录列表
    • 获取文件夹中的所有文件
    • 获取指定目录中所有文件列表
    • 清空目录下所有文件
    • 删除指定目录及其所有子目录
  • 总结

前言

在开发中我们经常会遇到文件上传文件下载，excel导入，excel导出等情况，这里我就总结在此篇文章中，方便大家在需要时直接copy。

文件相关操作

创建文本文件

/// <summary>
/// 创建一个文件,并将字节流写入文件。
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
/// <param name="buffer">二进制流数据</param>
public static void CreateFile(string filePath, byte[] buffer)
{
	try
	{
		//判断文件是否存在，不存在创建该文件
		if (!IsExistFile(filePath))
		{
			FileInfo file = new FileInfo(filePath);
			FileStream fs = file.Create();
			fs.Write(buffer, 0, buffer.Length);
			fs.Close();
		}
		else
		{
			File.WriteAllBytes(filePath, buffer);
		}
	}
	catch (Exception ex)
	{
		LogHelper.WriteWithTime(ex);
	}
}

获取文件大小

大家在电脑上经常能看到文件大小为KB，Mb,那么大家真的知道他们代表的是什么吗？
‌B、KB、MB、TB是计算机存储容量的基本单位，分别表示字节（Byte）、千字节（Kilobyte）、兆字节（Megabyte）和太字节（Terabyte）

获取文件大小（单位:B）

B代表的就是Byte字节，是计算机存储容量的基本单位，通常由8个二进制位（bit）组成。1字节可以表示0到255之间的数值（无符号）或-127到127之间的数值（有符号）‌

public static int GetFileSize(string filePath)
{
	//创建一个文件对象
	FileInfo fi = new FileInfo(filePath);
	//获取文件的大小
	return (int)fi.Length;
}

获取文件大小（单位：KB）

KB代表的是Kilobyte，称为千字节，等于1024个字节。1KB相当于512个汉字（在GBK编码下），可以存储一篇约512个字的短文‌

/// <summary>
/// 获取一个文件的长度,单位为KB
/// </summary>
/// <param name="filePath">文件的路径</param>
public static double GetFileSizeByKb(string filePath)
{
	//创建一个文件对象
	FileInfo fi = new FileInfo(filePath);
	//获取文件的大小
	return Math.Round(Convert.ToDouble(filePath.Length) / 1024, 2);// ConvertHelper.ToDouble(ConvertHelper.ToDouble(fi.Length) / 1024, 1);
}

获取文件大小(单位：MB)

MB代表的是Megabyte，称为兆字节，等于1024个千字节，即1024 × 1024个字节。1MB可以存储约524288个汉字，相当于一部中等长度的小说‌

/// <summary>
/// 获取一个文件的长度,单位为MB
/// </summary>
/// <param name="filePath">文件的路径</param>
public static double GetFileSizeByMb(string filePath)
{
	//创建一个文件对象
	FileInfo fi = new FileInfo(filePath);
	//获取文件的大小
	return Math.Round(Convert.ToDouble(Convert.ToDouble(fi.Length) / 1024 / 1024), 2);
}

获取文件大小（单位：B，KB，GB，TB）

这里时混在一起计算的返回的单位可以为B，KB，GB，TB；
TB 代表的是Terabyte，称为太字节，等于1024个吉字节，即1024 × 1024 × 1024个字节。1TB的存储容量非常大，可以存储大量的数据，例如可以存放约1000多部720P的电影‌。
这些单位在计算机存储中非常重要，用于衡量数据的大小和容量。随着技术的进步，更高的存储容量单位如PB（拍字节）、EB（艾字节）、ZB（泽字节）和YB（尧字节）也逐渐被使用，分别表示更大的存储容量‌

/// <summary>
/// 计算文件大小函数(保留两位小数),Size为字节大小
/// </summary>
/// <param name="size">初始文件大小</param>
/// <returns></returns>
public static string ToFileSize(long size)
{
	string m_strSize = "";
	long FactSize = 0;
	FactSize = size;
	if (FactSize < 1024.00)
		m_strSize = FactSize.ToString("F2") + " 字节";
	else if (FactSize >= 1024.00 && FactSize < 1048576)
		m_strSize = (FactSize / 1024.00).ToString("F2") + " KB";
	else if (FactSize >= 1048576 && FactSize < 1073741824)
		m_strSize = (FactSize / 1024.00 / 1024.00).ToString("F2") + " MB";
	else if (FactSize >= 1073741824)
		m_strSize = (FactSize / 1024.00 / 1024.00 / 1024.00).ToString("F2") + " GB";
	return m_strSize;
}

文件判断

是否为图片

// 判断文件是否是bai图片
public static bool IsPicture(string fileName)
{
	string strFilter = ".jpeg|.gif|.jpg|.png|.bmp|.pic|.tiff|.ico|.iff|.lbm|.mag|.mac|.mpt|.opt|";
	char[] separtor = { '|' };
	string[] tempFileds = StringSplit(strFilter, separtor);
	foreach (string str in tempFileds)
	{
		if (str.ToUpper() == fileName.Substring(fileName.LastIndexOf("."), fileName.Length - fileName.LastIndexOf(".")).ToUpper()) { return true; }
	}
	return false;
}

是否为excle

// 判断文件是否是excle
public static bool IsExcel(string fileName)
{
	string strFilter = ".xls|.xlsx|.csv";
	char[] separtor = { '|' };
	string[] tempFileds = StringSplit(strFilter, separtor);
	foreach (string str in tempFileds)
	{
		if (str.ToUpper() == fileName.Substring(fileName.LastIndexOf("."), fileName.Length - fileName.LastIndexOf(".")).ToUpper()) { return true; }
	}
	return false;
}

判断是否是允许后缀名

/// <summary>
/// 判断上传文件后缀名
/// </summary>
/// <param name="strExtension">后缀名</param>
public static bool IsCanEdit(string strExtension)
{
	strExtension = strExtension.ToLower();
	if (strExtension.LastIndexOf(".", StringComparison.Ordinal) >= 0)
	{
		strExtension = strExtension.Substring(strExtension.LastIndexOf(".", StringComparison.Ordinal));
	}
	else
	{
		strExtension = ".txt";
	}
	string[] strArray = new string[] { ".htm", ".html", ".txt", ".js", ".css", ".xml", ".sitemap" };
	for (int i = 0; i < strArray.Length; i++)
	{
		if (strExtension.Equals(strArray[i]))
		{
			return true;
		}
	}
	return false;
}

是否为压缩包

public static bool IsZipName(string strExtension)
{
	strExtension = strExtension.ToLower();
	if (strExtension.LastIndexOf(".") >= 0)
	{
		strExtension = strExtension.Substring(strExtension.LastIndexOf("."));
	}
	else
	{
		strExtension = ".txt";
	}
	string[] strArray = new string[] { ".zip", ".rar" };
	for (int i = 0; i < strArray.Length; i++)
	{
		if (strExtension.Equals(strArray[i]))
		{
			return true;
		}
	}
	return false;
}

文件后缀获取

获取文件后缀名

这里获取的格式为：.jpg

/// <summary>
/// 获取文件的后缀名
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static string GetExtension(string filePath)
{
	FileInfo file = new FileInfo(filePath);
	return file.Extension;
}

获取文件纯后缀

这里获取出来的文件后缀格式为：jpg

/// <summary>
/// 返回文件扩展名，不含“.”
/// </summary>
/// <param name="filepath">文件全名称</param>
/// <returns>string</returns>
public static string GetFileExt(string filepath)
{
	if (string.IsNullOrEmpty(filepath))
	{
		return "";
	}
	if (filepath.LastIndexOf(".", StringComparison.Ordinal) > 0)
	{
		return filepath.Substring(filepath.LastIndexOf(".", StringComparison.Ordinal) + 1); //文件扩展名，不含“.”
	}
	return "";
}

文件剪切粘贴

/// <summary>
/// 剪切文件
/// </summary>
/// <param name="source">原路径</param>
/// <param name="destination">新路径</param>
public bool FileMove(string source, string destination)
{
	bool ret = false;
	FileInfo file_s = new FileInfo(source);
	FileInfo file_d = new FileInfo(destination);
	if (file_s.Exists)
	{
		if (!file_d.Exists)
		{
			file_s.MoveTo(destination);
			ret = true;
		}
	}
	if (ret == true)
	{
		//Response.Write("<script>alert('剪切文件成功！');</script>");
	}
	else
	{
		//Response.Write("<script>alert('剪切文件失败！');</script>");
	}
	return ret;
}

文件粘贴

/// <summary>
/// 将文件移动到指定目录
/// </summary>
/// <param name="sourceFilePath">需要移动的源文件的绝对路径</param>
/// <param name="descDirectoryPath">移动到的目录的绝对路径</param>
public static void Move(string sourceFilePath, string descDirectoryPath)
{
	string sourceName = GetFileName(sourceFilePath);
	if (IsExistDirectory(descDirectoryPath))
	{
		//如果目标中存在同名文件,则删除
		if (IsExistFile(descDirectoryPath + "\\" + sourceFilePath))
		{
			DeleteFile(descDirectoryPath + "\\" + sourceFilePath);
		}
		else
		{
			//将文件移动到指定目录
			File.Move(sourceFilePath, descDirectoryPath + "\\" + sourceFilePath);
		}
	}
}

文件复制

/// <summary>
/// 将源文件的内容复制到目标文件中
/// </summary>
/// <param name="sourceFilePath">源文件的绝对路径</param>
/// <param name="descDirectoryPath">目标文件的绝对路径</param>
public static void Copy(string sourceFilePath, string descDirectoryPath)
{
	File.Copy(sourceFilePath, descDirectoryPath, true);
}

文件上传

文件下载

文件删除

/// <summary>
/// 删除指定文件
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static void DeleteFile(string filePath)
{
	if (IsExistFile(filePath))
	{
		File.Delete(filePath);
	}
}

文件压缩与解压

文件压缩

压缩文件

/// <summary>
/// 压缩文件
/// </summary>
/// <param name="sourceFilePath">文件路径</param>
/// <param name="zipFilePath">压缩包保存路径</param>
public static void ZipFile(string sourceFilePath, string zipFilePath)
{
    System.IO.Compression.ZipFile.CreateFromDirectory(sourceFilePath, zipFilePath);
    // 创建并添加被压缩文件
    using (FileStream zipFileToOpen = new FileStream(sourceFilePath, FileMode.Create))
    {
        using (ZipArchive archive = new ZipArchive(zipFileToOpen, ZipArchiveMode.Create))
        {
            string filename = System.IO.Path.GetFileName(zipFilePath);
            ZipArchiveEntry readMeEntry = archive.CreateEntry(filename);
            using (System.IO.Stream stream = readMeEntry.Open())
            {
                byte[] bytes = System.IO.File.ReadAllBytes(zipFilePath);
                stream.Write(bytes, 0, bytes.Length);
            }
        }
    }
}

压缩文件中添加文件

/// <summary>
/// 在压缩文件中添加文件
/// </summary>
/// <param name="sourceFilePath">文件路径</param>
/// <param name="zipFilePath">压缩包保存路径</param>
public static void AddZipFile(string sourceFilePath, string zipFilePath)
{
    using (FileStream zipFileToOpen = new FileStream(zipFilePath, FileMode.Create))
    {
        using (ZipArchive archive = new ZipArchive(zipFileToOpen, ZipArchiveMode.Create))
        {
            string filename = System.IO.Path.GetFileName(sourceFilePath);
            ZipArchiveEntry readMeEntry = archive.CreateEntry(filename);
            using (System.IO.Stream stream = readMeEntry.Open())
            {
                byte[] bytes = System.IO.File.ReadAllBytes(sourceFilePath);
                stream.Write(bytes, 0, bytes.Length);
            }
        }
    }

}

解压文件

解压压缩文件

/// <summary>
/// 解压压缩文件
/// </summary>
/// <param name="zipFilePath">压缩包路径</param>
/// <param name="unzipFilePath">解压后文件保存路径</param>
public static void UzipFile(string zipFilePath, string unzipFilePath)
{
    using (FileStream instream = File.OpenRead(zipFilePath))
    {
        using (ZipArchive zip = new ZipArchive(instream))
        {

            foreach (ZipArchiveEntry et in zip.Entries)
            {
                using (Stream stream = et.Open())
                {
                    using (FileStream fsout = File.Create(System.IO.Path.Combine(unzipFilePath, et.Name)))
                    {
                        stream.CopyTo(fsout);
                    }
                }
            }
        }
    }
}

文件夹相关操作

创建文件夹

/// <summary>
/// 创建文件夹
/// </summary>
/// <param name="fileName">文件的绝对路径</param>
public static void CreateFiles(string fileName)
{
	try
	{
		//判断文件是否存在，不存在创建该文件
		if (!IsExistFile(fileName))
		{
			FileInfo file = new FileInfo(fileName);
			FileStream fs = file.Create();
			fs.Close();
		}
	}
	catch (Exception ex)
	{
		LogHelper.WriteWithTime(ex);
	}
}

检测指定目录是否为空

/// <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 (Exception)
	{
		return true;
	}
}

获取指定目录中的子目录列表

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

获取文件夹中的所有文件

/// <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)
{
	if (isSearchChild)
	{
		return Directory.GetDirectories(directoryPath, searchPattern, SearchOption.AllDirectories);
	}
	else
	{
		return Directory.GetDirectories(directoryPath, searchPattern, SearchOption.TopDirectoryOnly);
	}
}

获取指定目录中所有文件列表

/// <summary>
/// 获取指定目录中所有文件列表
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static string[] GetFileNames(string directoryPath)
{
	if (!IsExistDirectory(directoryPath))
	{
		throw new FileNotFoundException();
	}
	return Directory.GetFiles(directoryPath);
}

清空目录下所有文件

注意：该方法只会删除文件夹中的文件，文件夹会保存

/// <summary>
/// 清空指定目录下所有文件及子目录,但该目录依然保存.
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static void ClearDirectory(string directoryPath)
{
	if (!IsExistDirectory(directoryPath)) return;
	//删除目录中所有的文件
	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]);
	}
}

删除指定目录及其所有子目录

注意：该方法会将文件夹及其所有子文件都删除

/// <summary>
/// 删除指定目录及其所有子目录
/// </summary>
/// <param name="directoryPath">文件的绝对路径</param>
public static void DeleteDirectory(string directoryPath)
{
	if (IsExistDirectory(directoryPath))
	{
		Directory.Delete(directoryPath);
	}
}

总结

提示：这里对文章进行总结：

例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。


http://www.kler.cn/a/512643.html

相关文章：

  • 动态规划（多状态）
  • 虚幻商城 Fab 免费资产自动化入库
  • 通过Ukey或者OTP动态口令实现windows安全登录
  • Java开发提速秘籍：巧用Apache Commons Lang工具库
  • 【从零开始入门unity游戏开发之——C#篇46】C#补充知识点——命名参数和可选参数
  • Rust Actix Web 项目实战教程 mysql redis swagger：构建用户管理系统
  • 【STM32-学习笔记-12-】PWR电源控制
  • 数据结构（精讲）----绪论
  • C# 委托(Delegate)的使用方法及使用场景
  • MySQL可直接使用的查询表的列信息
  • Nginx：从入门到实战使用教程
  • 如何在Mac上优雅的使用nvm管理Node.js
  • 【 MySQL 学习2】常用命令
  • Chrome远程桌面无法连接怎么解决？
  • Vue.js组件开发-解决PDF签章预览问题
  • Python基础学习（五）文件和异常
  • AI之HardWare：英伟达NvidiaGPU性价比排名(消费级/专业级/中高端企业级)以及据传英伟达Nvidia2025年将推出RTX 5090/5080、华为2025年推出910C/910D
  • Android系统开发（八）：从麦克风到扬声器，音频HAL框架的奇妙之旅
  • Docker 之mysql从头开始——Docker下mysql安装、启动、配置、进入容器执行（查询）sql
  • 深度学习基础：自动梯度、线性回归与逻辑回归的 PyTorch 实践
  • 【GORM】初探gorm模型，字段标签与go案例
  • 手写 拖拽 修改参数
  • HDFS的Java API操作
  • 探索国产多相流仿真技术应用，积鼎科技助力石油化工工程数字化交付
  • 蓝桥杯 阶乘的和（C++完整代码+详细分析）
  • function isBulkReadStatement, file SQLiteDatabaseTracking.cpp