NET基础学习笔记8

文件流

拷贝文件的两种方式：

第一种将源文件内容全部读到内存中，再写到目标文件中；读取源文件的1KB内存，写到目标文件中，再读取源文件的1KB内存，再写到目标文件中。

第二种方式就是一种流的操作。

Stream不会将所有内容一次性读取到内存中，有一个指针，指针指到哪里才能读、写到哪里。

两种方式：
直接把一个缸中的水倒入另一个缸中。（用File直接操作）
用个桶来把一个缸中的水舀到另一个缸中。（用流的方式操作）

把字符串转化为byte字符数组 byte[] byts=System.Text.Encoding.UTF8.GetBytes(msg);

把byte数组转换为一个字符串：string msg=System.Text.Encoding.UTF8.GetString(byts);

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace 文件流的操作
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 通过文件流读取磁盘上的文件
            ////1.创建文本流
            //FileStream fsRead = new FileStream(@"1.txt", FileMode.Open);
            ////2.创建缓存区
            //byte[] byts = new byte[fsRead.Length];
            ////3.开始读取
            //int r = fsRead.Read(byts, 0, byts.Length);
            //fsRead.Close();
            //fsRead.Dispose();
            //string readfile=System.Text.Encoding.UTF8.GetString(byts);
            //Console.WriteLine(readfile);
            
            #endregion

            #region 通过文件流写入文件
            //1.创建文件流
            FileStream fs = new FileStream(@"c:1.txt", FileMode.OpenOrCreate);
            string msg = "创建文件流然后把东西存入文件";
            //2.创建byte[]缓存区
            byte[] byts=System.Text.Encoding.UTF8.GetBytes(msg);
            //3.将byts中的内容写入文件中。
            fs.Write(byts, 0, byts.Length);
            //4.关闭文件流.
            fs.Close();//不关闭，写不进去
            fs.Dispose();
            Console.WriteLine("写入成功");
            #endregion

            Console.WriteLine("OK");
            Console.ReadKey();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace 文件读取到内存中
{
    class Program
    {
        static void Main(string[] args)
        {
            //源路径
            string source = @"E:HTCDriver3.0.0.005.rar";
            //目标路径
            string target = @"F:HTCDriver3.0.0.005.rar";

            CopyFile(source, target);
        }

        private static void CopyFile(string source, string target)
        {
           //文件流的使用步骤：
           //1.创建一个文本流：
            using (FileStream fs = new FileStream(source, FileMode.Open))
            {
                using (FileStream ws = new FileStream(target, FileMode.OpenOrCreate))
                {
                    //2.读或者写:
                    //创建缓存区。byte表示字节。8个bit表示8位。每次读取的内容都要放在缓冲区中。
                    byte[] byts = new byte[1024 * 1024 * 5];
                    //第一个参数：byts，表示将文件中的字节读取到该数组中。
                    //第二个参数：表示从文件中读取出的字节数，要放到byts这个数组中，从第几个开始放。
                    //第三个参数：这次最多读取多少个字节。
                    //返回表示本次实际读取到了多少个字节。
                    long readlength = fs.Length;
                    double parportion=0.0;
                    while (parportion != 1.0)
                    {
                        int result = fs.Read(byts, 0, byts.Length);
                        string strfile = System.Text.Encoding.UTF8.GetString(byts);
                        ws.Write(byts, 0, result);
                        long writelength = ws.Length;
                        parportion = (double)writelength / readlength;
                        Console.WriteLine("复制到{0}%",parportion*100);
                    }
                }
            }

            Console.WriteLine("复制完成");
            Console.ReadKey();

        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;

namespace _1加密文件
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Emcrypt(textBox1.Text, textBox2.Text);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Deciphering(textBox2.Text, textBox3.Text);
        }

        public void Emcrypt(string souce, string goal)
        {
            using(FileStream readstram=new FileStream(souce,FileMode.OpenOrCreate))
            {
                using (FileStream writestream = new FileStream(goal, FileMode.Create))
                {
                    int readnumber;
                    byte[] bys = new byte[1024 * 1024 * 5 + 5];
                    while (true)
                    {
                        readnumber = readstram.Read(bys, 4, bys.Length-5);
                        if (readnumber == 0)
                        {
                            break;
                        }
                        writestream.Write(bys, 0, readnumber);
                    }
                }
            }
        }

        public void Deciphering(string souce, string goal)
        {
            using (FileStream readstram = new FileStream(souce, FileMode.OpenOrCreate))
            {
                using (FileStream writestream = new FileStream(goal, FileMode.Create))
                {
                    int readnumber;
                    byte[] bys = new byte[1024 * 1024 * 5 + 5];
                    while (true)
                    {
                        readnumber = readstram.Read(bys, 0, bys.Length);
                        if (readnumber == 0)
                        {
                            break;
                        }
                        writestream.Write(bys, 4, readnumber-5);
                    }
                }
            }
        }

        
    }
}

StreamWriter(读取文本文件)

Stream把所有内容当成二进制来看待，如果是文本内容，则需要程序员来处理文本和二进制之间的转换。
用StreamWriter可以简化文本类型的Stream的处理
StreamWriter是辅助Stream进行处理的

StreamReader

和StreamWriter类似， StreamReader简化了文本类型的流的读取。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;

namespace _2.StreamWrite和StreamRead
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            using (StreamWriter streamwrite = new StreamWriter(@"c:writ.txt", true, Encoding.Default))
            {
                for (int i = 0; i < 50; i++)
                {
                    streamwrite.WriteLine("加油！多努力一点，以后生活美好一点+" + i);
                }
            }
            using (StreamReader streamreader = new StreamReader(@"c:writ.txt",Encoding.Default))
            {
                //第一种方式读入
                //while (!streamreader.EndOfStream)
                //{
                //    textBox1.Text = textBox1.Text + streamreader.ReadLine();
                //}
                //第二种方式读入
                string result;
                while ((result=streamreader.ReadLine())!=null)
                {
                    textBox1.Text = textBox1.Text + result+"/t /n";
                }

            }
        }
    }
}

 

对象序列化(二进制序列化)

对象序列化是将对象（比如Person对象）转换为二进制数据(字节流)，反序列化是将二进制数据还原为对象。对象是稍纵即逝的，不仅程序重启、操作系统重启会造成对象的消失，就是退出函数范围等都可能造成对象的消失，序列化/反序列化就是为了保持对象的持久化。就像用DV录像（序列化）和用播放器播放（反序列化）一样。
对象序列化，只能针对对象的字段进行序列化。
BinaryFormatter类有两个方法：
void Serialize(Stream stream, object graph)对象graph序列化到stream中
object Deserialize(Stream stream)将对象从stream中反序列化，返回值为反序列化得到的对象

不是所有对象都能序列化，只有可序列化的对象才能序列化，在类声明上添加[Serializable]，对象的属性、字段的类型也必须可序列化

关于二进制序列化需要注意的事项：
1.要序列化的类型必须标记为：[Serializable]
2.该类型的父类也必须标记为： [Serializable]
3.该类型中的所有成员的类型也必须标记为： [Serializable]
4.序列化只会对类中的字段序列化。(只能序列化一些状态信息。)
5.不建议使用自动属性。（每次生成的字段都可能不一样，影响反序列化）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;

namespace _3系列化文本对象
{
    class Program
    {
        static void Main(string[] args)
        {
            Person zhj = new Person();
            zhj.Name = "速度改变";
            zhj.Age = 21;
            zhj.Mycar = new Car();
            //对象序列化的步骤：
            //1.创建二进制对象序列化器
            BinaryFormatter bf = new BinaryFormatter();

            //2.创建文本流
            using (FileStream fs = new FileStream("person.bin", FileMode.Create))
            {
                bf.Serialize(fs, zhj);
            }

        }
    }
    //Person类型要想被序列化。
    //1.必须Person类型本身是可序列化的。
    //2.类中所有的字段属性的类型也必须标记为可序列化的。
    [Serializable]
    public class Person
    {
        //在使用序列化的时候尽量避免使用自动属性，因为自动属性，每次编译的时候自动生成的字段名可能不一样。
        //所以在反序列化的时候可能会造成问题。
        public string Name
        {
            set;
            get;
        }

        public int Age
        {
            get;
            set;
        }

        private Car mycar;

        public Car Mycar
        {
            get { return mycar; }
            set { mycar = value; }
        }
    }

    [Serializable]
    public class Car
    {
        private string carname;

        public string Carname
        {
            get { return carname; }
            set { carname = value; }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using _3系列化文本对象;

namespace _4反序列化
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.创建二进制序列化器
            BinaryFormatter bf = new BinaryFormatter();

            //2.创建流
            using (FileStream fs=new FileStream("Person.bin",FileMode.Open))
            {
                //开始执行反序列化
                //在执行反序列化的时候，必须引用Person的程序集
                //反序列化的时候。要返回一个对象。这个对象必须根
                //据原来Person所在的程序集才能创建。也就是说Person.bin中包含的仅仅一些数据，
                //根据这些数据是无法在内存中创建对象的。只能是根据原来的Person类型的程序集来创建
                //object obj = bf.Deserialize(fs);
                Person per = (Person)bf.Deserialize(fs);
                Console.WriteLine(per.Name);
                Console.ReadKey();
            }
        }
    }
}

为什么要序列化？
将一个复杂的对象转换流，方便我们的存储与信息交换

序列化的应用：
将对象持久化存储,磁盘、数据库
将对象复制到剪贴板
将对象通过网络传输
将对象备份（深拷贝。）

序列化的步骤：

1.创建一个二进制序列化器：
BinaryFormatter bf=…..;
1.5:创建一个文件流。
2.bf.Serialize(stream,对象);

反序列化的步骤

1.创建一个二进制序列化器：
BinaryFormatter bf;
2.创建文件流：
3.执行反序列化：
object obj=bf.Deserialize(stream);