C#知识点-11(FileStream文件流操作,using代码块,加密解密,压缩解压缩,序列化和反序列化,StreamReader和StreamWriter)

FileStream文件流操作

读取数据
1、给定一个路径path

string path = @"C:\Users\Desktop\实验.txt";

2、创建一个读取数据的文件流对象

FileStream fsRead = new FileStream(path,FileMode.Open,FileAccess.Read);

        path:要读取的文件路径
        FileMode:对文件要执行的操作
        FileAccess:对文件中的数据要执行的操作
3、设置内存缓冲区的大小

byte[] buffer = new byte[1024 * 1024];//这里设置了1kb

4、在流中读取字节块并将该数据写入到缓存区中,用一个int类型的值接受读入缓存区的总字节数

int r= fsRead.Read(buffer,0,buffer.Length);

5、把字节数组中的数据,转换成我们认识的字符串

string s = Encoding.Default.GetString(buffer,0,r);

6、释放资源

            fsRead.Flush();//清除流的缓存区
            fsRead.Close();//关闭流
            fsRead.Dispose();//释放由Steam所使用的所有资源

using代码块

using代码块:把创建文件流对象的过程,写到using中,using会自动的帮助我们Flush Close Dispose
放到using中的对象,必须实现IDisposable接口

            using (FileStream fsRead = new FileStream(path, FileMode.Open, FileAccess.Read))
            {
                byte[] buffer = new byte[1024];
                int r = fsRead.Read(buffer,0,buffer.Length);
                string s = Encoding.Default.GetString(buffer);
                Console.WriteLine(s);
            }

写入数据

            string path2 = @"C:\Users\Desktop\实验2.txt";
            using (FileStream fsWrite = new FileStream(path2, FileMode.Create, FileAccess.Write))
            {
                byte[] buffer = new byte[1024];
                fsWrite.Write(buffer, 0, buffer.Length);
                Console.WriteLine("ok");
            }

使用FileStream实现对一个大文件的复制和粘贴

    internal class Program
    {
        static void Main(string[] args)
        {
            //使用FileStream实现对一个【大文件】的复制和粘贴
            //复制:读数据
            //粘贴:写数据
            string source = @"C:\Users\ThinkPad\Desktop\new.mp4";
            string target = @"C:\Users\ThinkPad\Desktop\new2.mp4";

            CopyFile(source, target);
            Console.WriteLine("OK");
            Console.ReadKey();
        }

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

                        //6、进度条  fsRead.Length 5000M 4.88G
                        double d = (double)fsRead.Position / fsRead.Length * 100;

                        Console.WriteLine("当前进度{0}%", d);
                    }
                }
            }
        }
    }

加密解密

加密就是假设把一个数据先通过FileStream.Read读取出来,在缓存区中把每个字节取出来给他一个特定的规律让它发生变化,比如说我用255减去这个数字,然后用FileStream.Write再把加密后的数据写入到新文件中。
解密就是一样的操作思想

    internal class Program
    {
        static void Main(string[] args)
        {
            //文件的加密和解密
            //双方必须要按照同一个算法对文件进行解析

            //加密:255统一的减去每个字节
            //250    ----  5
            //55     -----200
            //100  ----- 155
            //解密:
            //5     ---- 250
            //200  ----55
            //155  --- 100
            //加密
            //string source = @"C:\Users\ThinkPad\Desktop\1.txt";
            //string target = @"C:\Users\ThinkPad\Desktop\2.txt";
            //JiaMi(source, target);
            //Console.WriteLine("OKOKOK");


            //解密
            string source = @"C:\Users\ThinkPad\Desktop\2.txt";
            string target = @"C:\Users\ThinkPad\Desktop\3.txt";
            JieMi(source, target);
            Console.WriteLine("OKOKOK");
            Console.ReadKey();
        }
        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);
                }
            }
        }
        static void JieMi(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);
                }
            }
        }
    }

压缩解压

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

//压缩
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 JiaYa(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);
                    }
                }
            }

        }

序列化和反序列化

序列化:对象转换为二进制
反序列化:二进制转换为对象
为什么要对 对象 进行持久化的保存?
a.数据传输
b.我们软件中,用户的配置,可能是需要进行持久化保存的,我们可以把用户的配置,保存到对象中,并使用序列化的技术持久化的保存到本地文件中,下次再启动程序的时候,再通过反序列化的技术,获取之前保存的对象数据,然后进行下一步的操作。
[Serializable] //表示当前类可以被序列化,没有标记的,不允许被序列化
[NonSerialized]//表示字段不可以被序列化

    internal class Program
    {
        static void Main(string[] args)
        {
            VisualStudioSon vs = new VisualStudioSon();
            vs.Font = "微软雅黑";
            vs.FontColor = "蓝色";
            vs.BackGoundColor = "白色";
            string path = @"C:\Users\ThinkPad\Desktop\object.txt";
            using (FileStream fsWrite = new FileStream(path, FileMode.Create, FileAccess.Write))
            {
                //序列化   对象----->二进制
                BinaryFormatter bf = new BinaryFormatter();
                //参数一:写入流对象
                //参数二:序列化对象
                bf.Serialize(fsWrite, vs);
            }
            Console.WriteLine("序列化成功!!!!!");

            //string path = @"C:\Users\ThinkPad\Desktop\object.txt";
            //using (FileStream fsRead = new FileStream(path, FileMode.Open, FileAccess.Read))
            //{
            //    BinaryFormatter bf = new BinaryFormatter();
            //    //Deserialize 从读取文件的流中,把对象解析(反序列化)出来
            //    VisualStudio vs = (VisualStudio)bf.Deserialize(fsRead);
            //    Console.WriteLine("软件的字体是{0},字体颜色是{1},背景颜色是{2}", vs.Font, vs.FontColor, vs.BackGoundColor);
            //}
        }

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

        public string FontColor { get; set; }

        public string BackGoundColor { get; set; }


        public void SayHell0()
        {
            Console.WriteLine("Hello World");
        }
    }
    //[NonSerialized]
    [Serializable]
    public class VisualStudioSon : VisualStudio
    {
        [NonSerialized]
        private Person _p;
        //public Person p { get; set; }
        private string _name;

        public void VSSSayHi(Student s)
        {
        }
    }

StreamReader和StreamWriter

用处:专门用来操作文本数据的读写

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

            //}

            using (StreamWriter sw = new StreamWriter(@"C:\Users\ThinkPad\Desktop\object.txt", true,Encoding.Default))
            {
                sw.WriteLine("我爱北京天安门");
            }
            Console.WriteLine("OKOKOK");
            Console.WriteLine("OKOKOK");
            Console.ReadKey();

  • 25
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值