C# 文件读写系列二
读取文件原则上非常简单,但它不是通过FileInfo和DirectoryInfo来完成的,关于FileInfo和DirectoryInfo请参考C# 文件操作系列一,在.Net Framework4.5中可以通过File类来读写文件,在.Net Framework2.0推出之前,读写文件是相当费劲的,但是在.Net Framework2.0推出之后,它对File类进行了扩展,只要编写一行代码,就能对文件进行读写,下面通过一个窗体应用程序来展示文件的读写功能。
一、文件读取
1、通过File类的静态方法ReadAllText()进行文件的读取。
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace FileReadWrite
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
ReadFile();
}
protected void ReadFile()
{
if (string.IsNullOrEmpty(textBox1.Text))
{
MessageBox.Show("请输入文件路径!");
}
else
{
string res = File.ReadAllText(textBox1.Text,Encoding.Default);
textBox2.Text = res;
}
}
}
}
2、通过File类的静态方法ReadAllLines()进行文件的读取,代码如下:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace FileReadWrite
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
ReadFile();
}
protected void ReadFile()
{
if (string.IsNullOrEmpty(textBox1.Text))
{
MessageBox.Show("请输入文件路径!");
}
else
{
string[] res = File.ReadAllLines(textBox1.Text,Encoding.Default);
StringBuilder result = new StringBuilder();
foreach (string re in res)
{
result.Append(re);
}
textBox2.Text = result.ToString();
}
}
}
}
3、通过File类的静态方法ReadAllBytes()进行文件的读取,代码如下:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace FileReadWrite
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
ReadFile();
}
protected void ReadFile()
{
if (string.IsNullOrEmpty(textBox1.Text))
{
MessageBox.Show("请输入文件路径!");
}
else
{
byte[] res = File.ReadAllBytes(textBox1.Text);
StringBuilder sb = new StringBuilder();
foreach (var b in res)
{
sb.Append(b.ToString());
}
textBox2.Text = sb.ToString();
}
}
}
}
二、文件写入
File提供了ReadAllBytes()、ReadAllLines()、ReadAllText()等读取文件的方式,所以对应的就会有相对应的写入文件的方式WriteAllBytes()、WriteAllLines()、WriteAllText()。
这里就不多做阐述.
三、通过流来操作文件
1、流的概念相信大家都不陌生,无论是哪种语言、哪种平台都会有流的存在,流是一个用于传输数据的对象,流可以双向传输,分为读取流和写入流。
a、读取流:数据从外部源传输到程序中
b、写入流:数据从程序传输到外部源中
外部源通常是一个文件,但也不都是一个文件,它也可能是:
a、网络上的数据(可通过一些网络协议进行读写)
.Net提供了一个System.Net.Sockets.NetworkStream类,可以通过它来处理网络数据。
b、读写到内存区域上的数据
.Net提供了一个System.IO.MemoryStream类,可以通过它来读取内存.
c、读写到命名管道上的数据
读写管道没有提供基本的流类,但是有一个泛型流类System.IO.Stream,如果要编写这样一个类,就可以从这个基类继承.
d、另一个计算机上发送的数据
e、外部源甚至可以代码中的一个变量,使用流在变量之间传输数据是一个常用的技巧,可以在数据类型之间转换数据。
使用一个独立的对象来传输数据,比使用FileInfo和DirectoryInfo类更好,应为把传输数据(名词)的概念和特定数据源分离开来,可以更容易的交换数据源。流对象本身包含许多通用的代码,可以在外部数据源和代码中的变量之间移动数据,把这些代码与特定数据源的概念区分开来,可以实现不同环境下代码的重用(通过继承).例如像StringReader和StringWriter,StreamReader和StreamWriter一样,都是同一继承树的一部分,这些类的后台一定共享很多的代码.
2、FileStream类
(1)、FileStream类的作用
a、这个类只要用于读取二进制文件中的二进制数据,当然也可以使用它读取任何文件,通常读取二进制文件要使用FileStream
b、FileStream对象实例表示在磁盘或网络路径上指向文件的流,这个类提供了在文件中读取字节的方法,但是经常使用StreamReader和StreamWriter来执行这些功能,因为FileStream操作的是字节和字节数组,而Stream类操作的是字符数据.
(2)、FileStream的构造方式
虽然.Net 提供了15种方式构建一个FileStream对象实例,但是构建一个FileStream对象实例,主要需要以下4条信息(也就是构造函数的参数):
a、要访问的文件
b、表示如何打开文件的模式。例如,新建一个文件或者打开一个现有的文件。如果打开一个现有的文件,写入操作是覆盖文件,还是追加到文件的末尾。
c、表示文件的访问方式------是只读,只写,还是读写?
d、共享访问------表示访问是否独占文件.如果允许其他流同时访问文件,则这些流是只读还是只写还是读写文件。
.Net提供的FileStream构造函数主要分为两类
一类是构造函数的第一个参数是一个文件的完整路径的字符串,其余的参数大致是FileMode、FileAcess、FileShare等...
一类是构造函数用老式的windows-api分格的windows句柄来处理文件...
本文主要用的是第一类,第一个参数是文件的完整路径的字符串的这一类的构造函数,构造形式如下:
接下来主要介绍如上构造函数中的三个参数:FileMode、FileAcess、FileShare
a、FileAccess枚举
注意,该枚举有一个Flags特性标签,说明FileAccess的枚举值可以进行按位的"|"或者按位的"&"运算,关于这个不清楚,请参考C# 特性(Attribute)之Flag特性
b、FileMode枚举
namespace System.IO
{
using System;
using System.Runtime.InteropServices;
[Serializable, ComVisible(true)]
public enum FileMode
{
/*
* 创建新文件,此操作需要 System.Security.Permissions.FileIOPermissionAccess.Write权限
* 如果文件已存在,将引发System.IO.IOException
*/
CreateNew = 1,
/*
* 指定操作系统打开现有文件,文件一旦打开,就会截断成零字节大小
* 此操作需要 System.Security.Permissions.FileIOPermissionAccess.Write
* 尝试读取通过Truncate打开文件将导致异常.
*/
Truncate = 5,
/*
* 指定操作系统创建新文件.如果文件已存在,那么它将被覆盖
* 此操作需要 System.Security.Permissions.FileIOPermissionAccess.Write
* FileMode.Create<=>相当于如果文件不存在则使用System.IO.FileMode.CreateNew
* 如果文件存在,则使用System.IO.FileMode.Truncate.
* 注:如果文件已存在但是为隐藏文件,则将引发System.UnauthorizedAccessException
*/
Create = 2,
/*
* 若文件存在,则找到文件并定位到文件结尾.如果文件不存在,则创建一个新文件
* FileMode.Append只能与FileAccess.Write一起使用.尝试查找文件尾之前的位置会引发System.IO.IOException
* 并且任何尝试读取的操作都会失败并引发 System.NotSupportedException
*/
Append = 6,
/*
* 指定操作系统打开现有的文件,打开文件的能力取决于System.IO.FileAccess.
* 如果文件不存在,则引发System.IO.FileNotFoundException.
*/
Open = 3,
/*
* 指定操作系统应打开文件.打开文件的能力取决于 System.IO.FileAccess 所指定的值.
* 如果该文件不存在,则引发System.IO.FileNotFoundException.
*/
OpenOrCreate = 4,
}
}c、FileShare枚举
这个枚举主要实现的是"文件读写锁"的功能,在开发过程中,我们往往需要大量读写文件的操作,在本地往往能完美运行(单线程),但是项目上线后,就会出现一系列的问题.(.Net本身是多线程环境),下面简单列举一些在多线程环境中会出现的问题.
i、写入一些内容到一个文件中,另一个线程/进程要读取文件的内容时报异常,提示System.IO.IOException:文件真由另一进程使用,因此该进程无法访问该文件.
ii、和上面i的顺序相反,在对一个文件进行读操作时,此时另一个线程/进程向该文件进行追加内容操作,也会报i中的异常.
iii、对一个文件进行简单的读写操作后,想删除文件,依然报上述的错误.
出现上述异常有两种可能的原因
第一种是对文件进行完一个操作后,没有进行资源的释放
第二种是当进行完一个操作后,可能要到某个时刻才真正结束,亦或是需要指定某个触发机制,操作才会真正结束
下面开始逐个解析FileShare的每个枚举值
// Generated by .NET Reflector from C:\Windows\Microsoft.Net\assembly\GAC_64\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll
namespace System.IO
{
using System;
using System.Runtime.InteropServices;
[Serializable, Flags, ComVisible(true)]
public enum FileShare
{
/*
* 谢绝共享当前文件.文件关闭前,打开该文件的任何请求(由此进程或者另一进程)都将抛出异常
*/
None = 0,
/*
* 允许随后打开文件读取,如果未指定此标记,则文件关闭前,,打开该文件的任何请求(由此进程或者另一进程)都将抛出异常
* 但是,即使指定了该标记,仍可能需要附加权限才能够访问该文件.
*/
Read = 1,
/*
* 允许随后打开文件写入,如果未指定此标记,则文件关闭前,,打开该文件的任何请求(由此进程或者另一进程)都将抛出异常
* 但是,即使指定了该标记,仍可能需要附加权限才能够访问该文件.
*/
Write = 2,
/*
* 允许随后打开文件写入或读取,如果未指定此标记,则文件关闭前,,打开该文件的任何请求(由此进程或者另一进程)都将抛出异常
* 但是,即使指定了该标记,仍可能需要附加权限才能够访问该文件.
*/
ReadWrite = 3,
/*
* 允许随后删除文件
*/
Delete = 4,
/*
* 使文件可由子进程继承,Win32不直接支持此功能.
*/
Inheritable = 0x10
}
}在讲解各个枚举值之前,先提供两个方法,用于测试,一个是写文件的方法
static void WriteFile(FileMode filemode,FileAccess fileacess,FileShare fileshare)
{
var content = "测试";
FileStream fs = new FileStream(FilePath, filemode, fileacess, fileshare);
var buffer=Encoding.Default.GetBytes(content);
fs.Write(buffer, 0,buffer.Length);
fs.Flush();
}一个是读文件的方法
static void ReadFile(FileAccess fileaccess,FileShare fileshare)
{
FileStream fs=default(FileStream);
try
{
fs = new FileStream(FilePath, FileMode.Open, fileaccess, fileshare);
var buffer = new byte[fs.Length];
fs.Position = 0;
fs.Read(buffer, 0, buffer.Length);
Console.WriteLine(Encoding.Default.GetString(buffer));
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}FileShare.Read
允许随后打开文件读取,所以有如下示例代码:
WriteFile(FileMode.Create, FileAccess.Write, FileShare.Read);
ReadFile(FileAccess.Read, FileShare.Read);
Console.ReadKey();
按照FileShare.Read的关法用法说明,出现上述问题只有一个原因,就是"允许随后打开文件读取"之前的操作可能不能是WriteFile,亦或只能是ReadFile,修改代码如下:
ReadFile(FileAccess.Read, FileShare.Read);
ReadFile(FileAccess.Read, FileShare.Read);
Console.ReadKey();
到这一步还不能确认上面的假设,现在修改代码如下:
ReadFile(FileAccess.Read, FileShare.Read);
WriteFile(FileMode.Create, FileAccess.Write, FileShare.Read);
Console.ReadKey();
ok,通过上面的3个demo说明FileShare.Read(只读共享)只有在连续读取文件才有效.
FileShare.Write
允许随后打开文件写入,和FileShare.Read一样,FileShare.Write(只写共享)只有在连续写入文件是才有效,代码如下:
WriteFile(FileMode.Create, FileAccess.Write, FileShare.Write,"测试");
WriteFile(FileMode.Append, FileAccess.Write, FileShare.Write,"追加内容");
注:设置文件的共享方式为Write后,使用windows记事本也无法打开了.
FileShare.ReadWrite
综合FileShare.Read和FileShare.Write的特性
FileShare.None/FileShare.Delete
有了上面的经验，相信这两个你也很容易的就理解了，None则为不允许后续有任何操作，而Delete则是允许你随后进行删除操作。
(3)、通过FileInfo构建FileStream
a、通过FileInfo的实例方法OpenRead构建FileStream,代码如下:
FileInfo fi = new FileInfo(FilePath);
FileStream fs = fi.OpenRead();
byte[] bt = new byte[fs.Length];
fs.Read(bt, 0, bt.Length);
Console.WriteLine(Encoding.Default.GetString(bt));
查看OpenRead()的源代码,代码如下:
public FileStream OpenRead()
{
return new FileStream(base.FullPath, FileMode.Open, FileAccess.Read, FileShare.Read, 0x1000, false);
}现在一目了然,其实FileInfo的实例方法OpenRead其实是构建了一个FileStream的实例.
b、通过FileInfo的实例方法OpenWrite构建FileStream,代码如下:
FileInfo fi = new FileInfo(FilePath);
FileStream fs = fi.OpenWrite();
byte[] bt = Encoding.Default.GetBytes("测试");
fs.Write(bt, 0, bt.Length);
查看OpenWrite方法的源码,如下:
public FileStream OpenWrite()
{
return new FileStream(base.FullPath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
}和OpenRead()一样,它的内部原理也是构建了一个FileStream实例.
c、通过FileInfo的实例方法Open构建FileStream,代码如下:
FileInfo fi = new FileInfo(FilePath);
FileStream fs = fi.Open(FileMode.Create, FileAccess.Write, FileShare.None);
byte[] bt = Encoding.Default.GetBytes("测试");
fs.Write(bt, 0, bt.Length);和OpenRead()、OpenWrite()一样,它的内部原理也是构建了一个FileStream实例.但是Open的参数是可配置的,不像OpenRead()、OpenWrite()
Open源码如下:
public FileStream Open(FileMode mode)
{
return this.Open(mode, FileAccess.ReadWrite, FileShare.None);
}
public FileStream Open(FileMode mode, FileAccess access)
{
return this.Open(mode, access, FileShare.None);
}
public FileStream Open(FileMode mode, FileAccess access, FileShare share)
{
return new FileStream(base.FullPath, mode, access, share);
}(4)、关闭流
通过上面的内容了解了构建一个FileStream其实就是构建了一个文件流,通过查阅源码可以发现FileStream继承了Stream,而Stream实现了IDisposable接口,所以当我们使用完FileStream,必须显示的调用Dispose或者使用using语句块,来释放资源.
FileStream提供了一个Close实例方法,来释放资源,和完成GC的回收,Close源码如下:
public virtual void Close()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}关闭流会释放与它相关的资源,允许其他应用程序为同一个文件设置流,这个操作也会刷新缓冲区.在打开和关闭流之间,可以读写其中的数据.
(4)、通过FileStream的实例方法读取流
a、ReadByte()
ReadByte()是读取流数据的最简单的方式,他从流中读取一个字节,把结果转换成0~255之间的整数.如果达到该流的末尾,就返回-1,ReadByte()返回的是下一个流中的下一个字节,代码如下:
int nextByte = fs.ReadByte();b、Read()
如果要一次读取多个字节,就调用Read(),把特定数量的字节读入到一个数组中,Read()返回实际读取的字节数,如果这个数是0,就表示达到了流的末尾,代码如下:
int nBytes=10;
int nextByte = fs.Read(bt, 0, nBytes);(5)、通过FileStream的实例方法写入流(给文件写入内容流)
a、WriteByte()
将一个字节写入流中,代码如下:
FileStream fs = new FileStream(FilePath, FileMode.Create, FileAccess.Write, FileShare.None);
byte bt = 100;
fs.WriteByte(bt);b、Write()
将一个字节数组写入流中,代码如下:
FileStream fs = new FileStream(FilePath, FileMode.Create, FileAccess.Write, FileShare.None);
byte[] bytes = Encoding.Default.GetBytes("测试");
fs.Write(bytes, 0, bytes.Length);(6)、二进制文件读取器
新建一个windows窗体应用程序,主要是将选中的文件,转换成二进制形式.
代码如下:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace BinaryFileReader
{
public partial class Form1 : Form
{
private readonly FileDialog choseOpenFileDialog = new OpenFileDialog();
private string choseFilePath;
public Form1()
{
InitializeComponent();
menuFileOpen.Click += menuFileOpen_Click;
choseOpenFileDialog.FileOk += choseOpenFileDialog_FileOk;
}
private void choseOpenFileDialog_FileOk(object sender, CancelEventArgs e)
{
choseFilePath = choseOpenFileDialog.FileName;
this.Text = Path.GetFileName(choseFilePath);
textBox1.Text = choseFilePath;
DisplayFileName();
}
private void menuFileOpen_Click(object sender, EventArgs e)
{
choseOpenFileDialog.ShowDialog();
}
private void DisplayFileName()
{
int sizePerRow = 16;//每行显示的字符数
FileStream fs = new FileStream(choseFilePath, FileMode.Open, FileAccess.Read);
long nBytesToRead = fs.Length;
if (nBytesToRead > 65536 / 4)
nBytesToRead = 65536 / 4;//需要显示的字符数
int nLines = (int)(nBytesToRead / sizePerRow) + 1;//总行数
string[] lines = new string[nLines];
int nBytesRead = 0;
for (int i = 0; i < nLines; i++)
{
StringBuilder nextLine = new StringBuilder();
nextLine.Capacity = 4 * sizePerRow;
for (int j = 0; j < sizePerRow; j++)
{
int nextByte = fs.ReadByte();
nBytesRead++;
if (nextByte == 0 || nBytesRead > 65535)
break;
char nextChar = (char)nextByte;
if (nextChar < 16)//char值小于16的字符都不是可打印字符
nextLine.Append(" x0" + string.Format("{0,1:X}", (int)nextChar));
else if (char.IsLetterOrDigit(nextChar) || char.IsPunctuation(nextChar))//字母数字十进制标点正常显示
nextLine.Append(" " + nextChar + " ");
else
nextLine.Append(" x" + string.Format("{0,2:X}", (int)nextChar));
}
lines[i] = nextLine.ToString();
}
fs.Close();
this.textBox2.Lines = lines;
}
}
}
3、关于流缓存的问题
如果一个C#或者.Net程序需要读取Windows操作系统下面的一个文件,那么就可以通过文件流的方式,而如果需要读取文件流中的两个字节,那么该流则会把请求传递给Windows,注意此时Windows不会直接连接文件系统,在定位文件,并完成读取操作。而是在一次读取过程中,检索文件中的一个大块,并把该块保存到一个内存区域即缓冲区上。(后面系列的StreamReader和StreamWriter将会用到缓冲区.)以后对流中数据的请求,就会从该缓冲区中读取,直到读取完该缓冲区位置。此时windows会从文件中在获取另一个数据块.写入文件的方式与此相同,对于文件,操作系统会自动完成读写操作。
注:如果需要编写一个流类从没有缓存的设备中读取数据。如果是这样,就应从BufferedStream派生一个类,它实现一个缓冲区(但BufferedStream并不适用于应用程序频繁的切换读数据和写数据的情况).