文件及IO操作(三)

• 文件及IO操作(一)
• 文件及IO操作(二)

什么是流？

• 文件的数据从存储介质到内存再到程序程序，以及这个反向的过程里数据仿佛在一个通道中流动，我们把这个通道成为流。

                           

• 按照输入源的不同流分为文件流、内存流、网络流等。

System.IO为我们提供了一个抽象类Stream。它在基础序列数据源与应用程序之间架设起了流动的通道。

常见操作：

• Read：读出流中的数据。
• Write： 向数据源中写入数据。
• Seek： 在流中定位。

BinaryReader 和 BinaryWrite类，以二进制格式操作数据

    下表描述BinaryReader类常用的一些方法：

1. colse：关闭当前读者和相应的流
2. Read：从下层流读取字符，并且增加流的当前位置

下表描述BinaryWriter类的一些常用方法：

Close	关闭当前BinaryWriter和下层的流
Seek	在当前流设置位置
Write	写值到当前流
Flush	清除当前writer的所有缓存，导致任何缓存的数据被写入到下层的设备中

Stream类

Stream类是IO名称空间中最重要的类之一，它是派生FileStream、MemoryStream和BufferedStream等不同类的抽象类

MemoryStream类用于向内存(而不是磁盘)读写数据

　　Read() ----读MemoryStream并装值写入缓冲区
　　ReadByte() ----从MemoryStream读一个字节
　　Write() ----从缓冲区向MemoryStream写值
　　WriteByte() ----从缓冲区向MemoryStream写一个字节
　　WriteTo() ----将此内存流的内容写入别一个内存流

BufferedStream类用于对缓冲区进行读/写,有两个构造函数

public BufferedStream(Stream stName);
public BufferedStream(Stream stName, int bsize);  //  bsize表示缓冲区大小

static void Main(string[] args)
        {
            MemoryStream memStr = new MemoryStream();
            BufferedStream buffStr = new BufferedStream(memStr);
            buffStr.WriteByte((byte)100);          
            buffStr.Position = 0;  //取得memStr的当前位置Positon属性为0，以便buffStr的当前位置设置为流的开始
            byte[] arrb = { 1, 2, 3 };
            buffStr.Read(arrb, 0, 1);  // 用流的当前位置的值填充字节数组arrb
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine("这个值是{0}", arrb[i]);
            }
            Console.WriteLine("ReadByte()的返回值是{0}", buffStr.ReadByte());  // 返回-1表示流的末尾
            Console.ReadKey();
        }

FileStream类

FileStream（文件流）是Stream派生出的子类，使用这个类我们可以建立文件与程序的通道，对文件进行二进制数据的读写

• • Stream类被用来从文本文件中读取和写入数据。
  • 它是一个抽象类，它支持读写自己到流。主要实现派生类FileStream
  • 如果文件的数据仅是文本，那么你可以使用StreamReader类和StreamWriter类来完成相应的读和写任务。

FileStream 类用于对文件执行读/写操作,Read()和Write()方法用于读/写操作
FileStream类构造函数有许多重写形式，以方便创建该类的实例
　　FileStream(string FilePath,FileMode)
　　FileStream(stirng FilePath,FileMode,FileAccess)
　　FileStream(string FilePath,FileMode,FileAccess,FileShare)
FileMode为enum类型（创建或打开），其值如下：
　　Append:打开一个文件并查找到文件末尾，以便能够附加新的数据，如果文件不存在，则新建一个文件
　　Create:用指定名称新建一个文件，如果存在具有相同名称的文件，则覆盖旧文件
　　CreateNew:新建一个文件
　　Open:打开一个文件，指定文件必须存在
　　OpenOrCreate:与Open类似，只是指定文件不存在时，新建一个
　　Truncate:根据此枚举，打开指定文件并将之截断为0字节(大小为0字节)，文件必须存在
FileAccess枚举值（读写权限）：Read / Write / ReadWrite
FileShare枚举值（共享）：
　　None:谢绝共享当前文件。文件关闭前，打开该文件的任何请求都将失败
　　Read:只能对文件进行读取操作
　　Write:可以对文件进行写入操作
　　ReadWrite:可以进行对文件的读写和写入两种操作

例1：

static void Main(string[] args)
        {
            

            //===============================写入================================
            //使用FileStream读写文件
            string path = @"e:1.txt";

            Console.WriteLine("输入你要写入的文件内容：");
            string info = Console.ReadLine();
            //创建文件流，对str文件写操作
            FileStream fs = new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
            //把输入的字符串解码成字节数组
            byte[] array = new UTF8Encoding(true).GetBytes(info);//UTF8编码

            //byte[] array = new ASCIIEncoding().GetBytes(info);
            //写入
            fs.Write(array, 0, array.Length);


            fs.Flush();//清空缓存区
            fs.Close();//关闭流

            Console.WriteLine("写入成功");

            //===============================读取================================

            FileStream fs1 = new FileStream(path, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
            //定义数组用于接收读取的内容
            byte[] arr = new byte[fs1.Length];
            //读取
            fs1.Read(arr, 0, arr.Length);

            fs1.Close();//关闭流

            Console.WriteLine("读取到得内容如下：");
            Console.WriteLine(new UTF8Encoding(true).GetString(arr));
}

例2：

 static void Main(string[] args)
        {
            List<string> li = new List<string>();

            Console.WriteLine("-------------二进制文件写入--------------------
");
            Console.WriteLine("请输入你的个人信息：");
            Console.Write("您的姓名：");
            li.Add(Console.ReadLine());
            Console.Write("你的年龄：");
            li.Add(Console.ReadLine());
            Console.Write("你的爱好：");
            li.Add(Console.ReadLine());
            Console.Write("你的说明：");
            li.Add(Console.ReadLine());

            string pathtxt = @"e:10.text";
            string str = string.Empty;

            FileStream sw = new FileStream(pathtxt, FileMode.Create, FileAccess.Write, FileShare.Write);

            string str1 = "";
            foreach (string s in li)
            {
                str1 += s + "
";
            }
           byte[] b = UTF8Encoding.Default.GetBytes(str1);
            sw.Write(b, 0, b.Length);

            sw.Flush();
            sw.Close();

            Console.WriteLine("二进制文件写入成功！");
            Console.WriteLine("-------------二进制文件读取--------------------
");
            Console.WriteLine("读取二进制文件");
            FileStream file = new FileStream(pathtxt, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
           
            byte[] a = new byte[file.Length];
            while ((file.Read(a, 0, a.Length)) > 0)
            {
                Console.Write(UTF8Encoding.Default.GetString(a));
            }
            file.Flush();
            file.Close();
        }

 

你写了一个程序，其中要对硬盘上的一个文件操作，FileStream fs = new FileStream(fileName)
这样就是建立了一个文件缓冲流，换句话的意思就是说你通过这条程序，计算机给了一块内存空间，但是呢这块内存
空间不是你想干什么就干涉么的，他是专门存fileName这个文件里面的内容的，内存空间的大小，和其他信息，简单地
操作时没有办法访问的。当你要从文件里面读取一个Int整数的时候，程序做的不仅仅是读取一个int型整数，他会把该
数据附近的一大块数据都读出来放在刚才的那块空间中，为什么这么做呢，因为CPU访问硬盘比访问内存慢多了，所以
一开始读出很多的数据，后面需要使用的时候直接使用读出来的，就防止了再次访问硬盘。
相应的，你要网文件里面写入数据，也是先存到这个内存里，等存的东西足够多了，或者过了足够的时间，系统一次性
把内容写入硬盘。

TextReader类

TextReader类是StreamReader和StringReader类的抽象基类，可用于读取有序的字符序列
　　Read() 读取输入流中的下一个字符或下一组字符
　　ReadLine() 从当前流中读取一行字符并将数据作为字符串返回
　　ReadToEnd() 从流的当前位置到末尾读取流

class Program
    {
        static string ans = "y";
        static void Main(string[] args)
        {
            Console.WriteLine("1.读取文件");
            Console.WriteLine("2.读取字符串");
            try
            {
                Reading();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.ReadKey();
            }
        }
        static void Reading()
        {
            if (ans == "Y" || ans == "y")
            {
                Console.Write("输入你的选择[1/2]:");
                int choice = Convert.ToInt32(Console.ReadLine());
                if (choice == 1)
                {
                    Console.WriteLine("输入文件名:");
                    string filename = Console.ReadLine();
                    if (!File.Exists(filename))
                    {
                        Console.WriteLine(filename + "不存在！");
                        return;
                    }
                    StreamReader sr = File.OpenText(filename);
                    string input;
                    while ((input = sr.ReadLine()) != null)
                    {
                        Console.WriteLine(input);
                    }
                    Console.WriteLine("已达到流末尾。");
                    sr.Close();
                    Console.Write("要继续吗？[Y/N]:");
                    ans = Console.ReadLine();
                    Reading();
                }
                else if (choice == 2)
                {
                    Console.Write("输入字符串:");
                    string str = Console.ReadLine();
                    char[] b = new char[str.Length];
                    StringReader sr = new StringReader(str);
                    sr.Read(b, 0, str.Length);
                    Console.WriteLine(b);
                    Console.WriteLine("要继续吗[Y/N]:");
                    ans = Console.ReadLine();
                    Reading();
                }
                else
                {
                    Console.WriteLine("输入1或2作为选择:");
                }
            }
        }
    }

TextWrite类

TextWrite类用于编写有序字符的类的抽象基类。StreamWriter和StringWriter类是TextWriter类的两个派生类
　　Write() 将数据写入流
　　WriteLine() 将数据写入流,并在结尾标记结束符
　　StringWriter类用于装数据写入字符串，与StreamWriter类类似，区别仅在于它是向字符串(而不是向流)写入

class Program
    {
        static string ans = "y";
        static void Main(string[] args)
        {
            Writing();
        }
        static void Writing()
        {
            if (ans == "Y" || ans == "y")
            {
                Console.WriteLine("输入文件名:");
                string filename = Console.ReadLine();
                if (!File.Exists(filename))
                {
                    Console.WriteLine(filename + "不存在!");
                    return;
                }
                StreamWriter sr = File.AppendText(filename);
                Console.Write("输入要写入的字符串:");
                string str = Console.ReadLine();
                sr.WriteLine(str);
                sr.Close();
                Console.Write("要继续吗?[Y/N]：");
                ans = Console.ReadLine();
                Writing();
            }
        }
    }

 StreamReader 类

1. 1. StreamReader类从TextReader抽象类继承。
   2. 类TextReader表示一个读者，它可以读取一系列字符。

下表描述了StreamReader类的通用方法：

方法	描述
Close	关闭StreamReader类的对象和相应的流，并且释放与reader相关的任何系统资源
Peek	返回下一个可用的字符但不消费它
Read	从流中读取下一个字符或下一个字符集
ReadLine	从当前流读取一行字符，并且返回数据为字符串
Seek	允许在文件内移动读/写位置到任何地方

StreamWriter 类

1. 1. StreamWriter类继承自TextWriter抽象类。
   2. TextWriter类表示一个writer，它可以写一系列字符

下表描述了StreamWriter类的一些常用的方法：

方法	描述
Close	关闭当前StreamWriter的对象和相应的流
Flush	清除当前writer的所有缓冲，导致任何缓冲的数据被写入相应的流
Write	写入流
WriteLine	通过覆盖参数写入指定数据，在行的最后

 static void Main(string[] args)
        {
            string path = @"e:1.txt";

            //创建写文本文件，并同意追加
            StreamWriter sw = new StreamWriter(path, true);
            //逐行写入
            sw.WriteLine("编号：");
            sw.WriteLine("姓名：");
            sw.WriteLine("性别：");
            sw.WriteLine("地址：");
            sw.WriteLine("电话：");
            sw.WriteLine();

            sw.Flush();//清除当前缓冲区
            sw.Close();//关闭流
           // Process.Start("notepad.exe", path);//打开记事本

            //StreamReader和StreamWriter读取文本文件
            StreamReader sr = new StreamReader(@"e:1.txt", Encoding.UTF8);

            string s = string.Empty;
            while ((s = sr.ReadLine()) != null)
            {
                //string s = sr.ReadLine();
                Console.WriteLine(s);
            }
        }

 流的写入用完后一定要记得Flush（清缓冲）同时如果不用流的话，把相应的流Close(关闭)！

Flush的作用就是强制执行了一次把数据写出硬盘，这样，你写入的数据确实到了文件中，否则如果程序突然中断，你 
要写入的内容也许还没写到文件中，就造成了数据丢失。