C#学习的第十二天

1.文件流

File读写文件都是一次性的

使用文件流来读取文件

1.创建读取数据的文件流对象

1.1path：要操作的文件路径

1.2FileMode是对文件要执行的操作

1.3 FileAccess是对文件中数据要执行的操作

如下图所示：是对桌面文件的打开和读的操作 

 设置内存缓冲区，使文件流能够缓缓的读取文件而不是一下读取，文件缓冲区的设置如下所示：

接受读取的有效字节数，用文件流中Read()的方法:将流中读取到的字节数写入给定的缓冲区。

将指定字节的数组里面的数据转换为我们认识的字符串，具体实现如下所示：最后一步使用完流资源后我们要释放内存空间，因此要自己手动来释放，GC回收机制不会帮我们自动回收流的资源。 

1.Using的作用

1.using代码块，把创建文件流对象的过程，写道using中,using会自动帮我们Flush Close Dispose
2.放到using中的对象，必须实现IDisposable接口
3.读数据

具体用法 如下图所示：

使用FileStream实现对一个大文件的复制：

具体代码如下图所示：

namespace program6
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //使用FileStream实现对一个大文件的粘贴和复制
            string source = @"C:\Users\26352\Desktop\1.txt";
            string target = @"C:\Users\26352\Desktop\2.txt";
            CopyFile(source, target);

            Console.ReadKey();
        }
        static void CopyFile(string source, string target)
        {
            //创建读取的文件流对象
            using (FileStream fsRead = new FileStream(source, FileMode.Open, FileAccess.Read))
            {
                //创建写入的文件流对象
                using (FileStream fsWrite = new FileStream(target, FileMode.Create, FileAccess.Write))
                {
                    //读取的必须要创建缓冲区
                    byte[] buffer = new byte[1024 * 1024 * 5];
                    //开始读取数据，r:本次读取实际读取到的有效字节数
                    int r = 0;
                    while ((r = fsRead.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        //写数据
                        fsWrite.Write(buffer, 0, r);
                    }
                }
            }
        }
    }
}

 如果要实现进度条，可以再加一个

2.文件加密

文件的加密和解密要按照一个固定的算法来实现

双方必须要按照同一个算法对文件进行解析

具体案例：使用相同的算法来实现，解密过程也要按照同一算法来解析 

namespace program7
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //文件加密
            //加密
            string source = @"C:\Users\263527\Desktop\1.txt";
            string target = @"C:\Users\263527\Desktop\2.txt";
            JiaMi(source, target);
            Console.WriteLine("OKOKOK");
        }
        static void JiaMi(string source, string target)
        {
            using (FileStream fsRead = new FileStream(source, FileMode.Open, FileAccess.Read))
            {
                using (FileStream fsWrite = new FileStream(target, FileMode.Create, FileAccess.Write))
                {
                    byte[] buffer = new byte[1024];
                    //加密
                    int r = fsRead.Read(buffer, 0, buffer.Length);    //3

                    //把前r个字符拿出来，开始解密
                    for (int i = 0; i < r; i++)
                    {
                        buffer[i] = (byte)(byte.MaxValue - buffer[i]);  // 0 -255
                    }

                    //写入
                    fsWrite.Write(buffer, 0, r);

                }
            }
        }

    }
}

3. 文件的加压与解压

压缩文件的过程
1、读取源文件的的数据
2、把源文件的数据，用算法开始压缩  CompressionMode.Compress
3、把压缩后的数据，写入到指定的目标文件下

具体压缩和解压代码如下 ：

namespace program8
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string source = @"C:\Users\ThinkPad\Desktop\33333.zip";
            string target = @"C:\Users\ThinkPad\Desktop\2222222.txt";

            YaSuo(source, target);
            JieYa(source, target);

            Console.WriteLine("OKOKOK");
            Console.ReadKey();

        }

        static void YaSuo(string source, string target)
        {
            using (FileStream fsRead = new FileStream(source, FileMode.Open, FileAccess.Read))
            {
                using (FileStream fsWrite = new FileStream(target, FileMode.Create, FileAccess.Write))
                {
                    //gZip压缩对象，封装了写入的流对象
                    using (GZipStream gZip = new GZipStream(fsWrite, CompressionMode.Compress))
                    {
                        byte[] buffer = new byte[1024];
                        int r = fsRead.Read(buffer, 0, buffer.Length);
                        //一边【压缩】一边写
                        gZip.Write(buffer, 0, r);  //fsWrite.Write()
                    }
                }
            }
        }
        static void JieYa(string source, string target)
        {
            using (FileStream fsRead = new FileStream(source, FileMode.Open, FileAccess.Read))
            {
                using (FileStream fsWrite = new FileStream(target, FileMode.Create, FileAccess.Write))
                {
                    using (GZipStream gZip = new GZipStream(fsRead, CompressionMode.Decompress))
                    {
                        byte[] buffer = new byte[1024 * 1024];
                        //从读取数据的流，进行解压
                        //返回本次实际读取并解压的字节数
                        int r = gZip.Read(buffer, 0, buffer.Length);

                        //一边读，一边解压，一边把数据写入内存的缓冲区。
                        //同时，把缓冲区内解压后的数据，写入到目标路径下
                        fsWrite.Write(buffer, 0, r);
                    }
                }
            }

        }
    }
}

4.对象序列化 

序列化：对象转换为二进制

反序列化：二进制转换为对象

为什么要对对象进行持久化的保存？

a.数据传输。

b. 我们软件中，用户的配置，可能是需要进行持久化保存的，我们可以把用户的配置，保存到对象中，并使用序列化的技术持久化的保存到本地文件中，下次再启动程序的时候，再通过反序列化的技术，获取之前保存的对象数据，然后进行下一步的操作。

以下是序列化的代码具体实现：要创建BinaryFormatter这个对象，调用Serialize（）方法 

namespace program9
{
    internal class Program
    {
        static void Main(string[] args)
        {
            VisualStudio vs =new VisualStudio();
            vs.Font = "微软雅黑";
            vs.FontColor = "蓝色";
            vs.BackGroundColor = "白色";
            string path = @"C:\Users\26352\Desktop\1.txt";
            using(FileStream fsWrite = new FileStream(path,FileMode.Create,FileAccess.Write))
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(fsWrite, vs);
            }
            Console.WriteLine("序列化成功！！！");
            Console.ReadKey();
        }
    }

    [Serializable]//表示当前类可以被序列化，没有标记的，不允许被序列化
    public class VisualStudio
    {
        public string Font { get; set; }
        public string FontColor { get; set; }

        public string BackGroundColor { get; set; }
        public void SayHello()
        {
            Console.WriteLine("Hello World");
        }
    }
}

 5.StreamReader和StreamWriter 

StreamReader和StreamWriter  专门用来操作文本数据的读写
File :一次性读取，不管源文件有多大，都是一次性加载到内存中。
FileStream:一点一点，多次的读或者写。对内存和cpu的压力影响较小。
GZipStream:压缩流  压缩和解压缩

StreamReader和StreamWriter是一行一行的读取文件，不会出现乱码情况，用一个循环来实现StreamReader和StreamWriter的代码，具体实现如下图所示：

    using (StreamReader sr = new StreamReader(@"C:\Users\ThinkPad\Desktop\object.txt", Encoding.Default))
    {
        //一行一行的读  \0  \n
        //只要没读取到流的结尾，就一直读
        while (!sr.EndOfStream)
        {
            Console.WriteLine(sr.ReadLine());
        }

    }