09---Net基础加强

复习

Person类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _01人员信息作业
{
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }

        public override string ToString()
        {
            return this.Name;
        }
    }
}

主程序：

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

namespace _01人员信息作业
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //0.采集数据
            string name = txtName.Text.Trim();
            int age = Convert.ToInt32(txtAge.Text.Trim());

            //1.把采集到的数据保存到文本文件中
            //创建一个写入文本文件的文件流
            using (StreamWriter writer = new StreamWriter("renyuan.txt", true))
            {
            //执行追加
                writer.WriteLine(string.Format("{0},{1}",name,age));
            }

            ////2.把采集到的数据的姓名，显示到ListBox中
            //listBox1.Items.Add(name);
            Person p = new Person();
            p.Name = name;
            p.Age = age;
            listBox1.Items.Add(p);
        }

        //窗体加载的时候读取renyuan.txt文本文件，将其加载到ListBox中
        private void Form1_Load(object sender, EventArgs e)
        {
            //1.读取文件
            using(StreamReader reader=new StreamReader("renyuan.txt",Encoding.UTF8))
            {
            //循环读取每一行
                string line = null;
                while ((line=reader.ReadLine())!=null)
                {
                 string[] parts = line.Split(',');

                 ////只把人员的姓名增加到ListBox中
                 //listBox1.Items.Add(parts[0]);

                    //把每个人的对象（这个人的基本信息），增加到ListBox中的某个Item中
                    Person p =new Person();
                    p.Name = parts[];
                    p.Age = Convert.ToInt32(parts[]);
                    listBox1.Items.Add(p);

                }
            }
            //2.每读取一行就加载到ListBox中一行
        }

       //ListBox的Item选择项被改变的事件
        private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            Person p = listBox1.SelectedItem as Person;
            if (p!=null)
            {
                txtName.Text = p.Name;
                txtAge.Text = p.Age.ToString();
            }
        }
    }
}

压缩和解压：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.IO.Compression;

namespace _02压缩与解压
{
    class Program
    {

        static void Main(string[] args)
        {
            #region 压缩
            //string source = "1.txt";
            //string target = "yasuo";
            //Compress(source,target);
            #endregion

            #region 解压
            string source = "yasuo";
            string target = "2.txt";
            DeCompress(source, target);
            #endregion

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

        private static void Compress(string source, string target)
        {

            //1.读取源文件，读取的源文件是未经压缩的
            using(FileStream fsRead=File.OpenRead(source))
            {
            //2.要将读取到的内容压缩，就是要写入一个新的文件
                //所以要创建一个新的写入文件的文件流
                using(FileStream fsWrite=File.OpenWrite(target))
                {
                //3.因为在写入的时候要压缩后写入，所以在写入的时候，需要使用一个压缩流来写入
                    //所以要创建一个压缩流
                    using (GZipStream zip = new GZipStream(fsWrite,CompressionMode.Compress))
                    {
                    //循环读取，每次读取一部分，写入（压缩写入）一部分
                        byte[] buffers=new byte[*];
                        int bytecount=fsRead.Read(buffers,,buffers.Length);
                        while (bytecount>)
                        {
                            //写入，用压缩流来写入，这样写入的才是压缩后的
                            zip.Write(buffers,,bytecount);
                            bytecount = fsRead.Read(buffers, , buffers.Length);
                        }
                    }
                }
            }
        }

        private static void DeCompress(string source, string target)
        {
            //先调用FileStream读取，读取到的就是压缩后的文件
            using (FileStream fsRead = File.OpenRead(source))
            {

                //所以要创建一个压缩流，根据fsRead将内容解压
                //本来用fsRead读取到的内容是压缩文件，但是通过zip,再读取到的内容就是解压后的内容
                using (GZipStream zip = new GZipStream(fsRead, CompressionMode.Decompress))
                {

                //要解压写到一个新文件中，所以需要一个写入文件的文件流
                //创建一个写入文件的文件流
                        using (FileStream fsWrite = File.OpenWrite(target))
                {
                    //3.对于这个写入流fsWrite来说，只知道把拿到的内容直接写入磁盘，并不关心是什么内容

                        byte[] buffers = new byte[ * ];
                            //注意：读取的时候是通过压缩流来读取，这样读取到的才是解压后的内容
                        int bytecount = zip.Read(buffers, , buffers.Length);
                        while (bytecount > )
                        {
                            fsWrite.Write(buffers,,bytecount);
                            bytecount = zip.Read(buffers, , buffers.Length);
                        }
                    }
                }
            }
        }

    }
}

序列化1--就是把一个对象转化成一种格式的过程，转换成不同的格式就叫做不同的序列化，比如xml格式，叫做xml序列化。JavaScript 的json格式叫做JavaScript序列化，

二进制byte[]字节叫做二进制序列化。

序列化只序列化那些属性（或者说是序列化了对象中的状态信息，（字段，属性）），方法没有被序列化。

序列化后的目的，是为了把数据以另外一种格式来表示，方便存储与数据交换，所以序列化只序列化那些存储数据的成员，一般就是属性，不会序列化方法的。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web.Script.Serialization;
using System.IO;
using System.Xml.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace _03对象序列化
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 对象序列化
            //===============================================
            List<Person> list = new List<Person>();
            list.Add(new Person() { Name="叶长种",Age=,Email="826217795@qq.com"});
            list.Add(new Person() { Name = "科比", Age = , Email = "826217795@qq.com" });
            list.Add(new Person() { Name = "詹姆斯", Age = , Email = "826217795@qq.com" });

            ////使用JavaScript序列化。
            //JavaScriptSerializer jsSerializer = new JavaScriptSerializer();
            //string str=jsSerializer.Serialize(list);
            //File.WriteAllText("list.txt",str);
            //Console.WriteLine(str);
            //Console.ReadKey();

            ////使用xml序列化。
            ////XmlSerializer xmlSerializer = new XmlSerializer(list.GetType());
            //XmlSerializer xmlSerializer = new XmlSerializer(typeof(List<Person>));
            //using(FileStream fsWrite=File.OpenWrite("list.xml"))
            //{
            //    xmlSerializer.Serialize(fsWrite, list);
            //}
            //Console.WriteLine("OK");
            //Console.ReadKey();

            //二进制序列化。
            BinaryFormatter bf = new BinaryFormatter();
            using (FileStream fsWrite = File.OpenWrite("list.bin"))
            {
                bf.Serialize(fsWrite, list);
            }
            Console.WriteLine("OK");
            Console.ReadKey();

            #endregion

        }
    }

    //二进制序列化需要加入[Serializable]
    [Serializable]
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Email { get; set; }
        public void SayHi()
       {
          Console.WriteLine("大家好，我叫：{0}",Name);
        }
        public void SayHello()
        {
            Console.WriteLine("Hello");
        }
    }
}

二进制序列化：

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

namespace _04二进制序列化
{
    class Program
    {
        static void Main(string[] args)
        {

            Person person = new Person();
            person.Name = "叶长种";
            person.Age = ;
            person.Email = "826217795@qq.com";
            person.MyCar = new Car() {Brand="时风" };

            #region
            //二进制序列化步骤：
            //1.创建二进制序列化器
            BinaryFormatter bf = new BinaryFormatter();
          //我们希望将对象序列化到一个文件上，所以要创建一个文件流
            using (FileStream fsWrite = File.OpenWrite("person.bin"))
            {
                //2.开始执行序列化
                bf.Serialize(fsWrite, person);
            }
            Console.WriteLine("序列化完毕！");
            Console.ReadKey();

            #endregion
        }
    }

    [Serializable]
    class Amimal
    { 

    }
    [Serializable]
    class Car
    {
        private string _brand;

        public string Brand
        {
            get { return _brand; }
            set { _brand = value; }
        }
    }

    //二进制序列化需要加入[Serializable]
    //二进制序列化会把属性对应的字段序列化到文件中，所以最好类型不要使用自动属性（编译器自动生成字段）而要自己写属性和字段
    //当序列化一个对象的时候，这个对象的类以及所有父类都必须标记为可序列化的
    //类型中所有属性与字段的类型必须也标记为可序列化的。接口和方法有关的，不用标记。
    [Serializable]
    public class Person:Amimal
    {
        private Car _myCar;

        internal Car MyCar
        {
            get { return _myCar; }
            set { _myCar = value; }
        }
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        private int _age;

        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }
        private string _email;

        public string Email
        {
            get { return _email; }
            set { _email = value; }
        }

        private string _gender = "男";

        public int _height = ;
        public void SayHi()
        {
            Console.WriteLine("大家好，我叫：{0}", Name);
        }
        public void SayHello()
        {
            Console.WriteLine("Hello");
        }
    }
}

序列化2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.IO;
using _04二进制序列化;

namespace _05反序列化
{
    class Program
    {
        static void Main(string[] args)
        {

            #region

            BinaryFormatter bf = new BinaryFormatter();

            using (FileStream fsRead = File.OpenRead("person.bin"))
            {
                //反序列化的时候，需要创建原来被序列化的类型的对象，所以反序列化 的时候需要引用被序列化的类型的对象。
                //正因为如此，所以在二进制序列化的时候，那些属性名，方法等根本不需要序列化，只需要把那些状态信息（数据-字段）的值序列化就好了，
                //对于那些方法等信息，在反序列化时，创建对象的时候会自动创建，然后根据序列化文件中的字段的值进行赋值，这就是反序列化
               Object obj = bf.Deserialize(fsRead);
               Person p = obj as Person;
               Console.WriteLine(obj.ToString());
               Console.WriteLine(p._height + "    " + p.Name + "   " + p.Email + "   " + p.Age);
            }
            Console.WriteLine("OK！");
            Console.ReadKey();

            #endregion
        }
    }
}

效果图：

正则表达式元符号

. 表示除\n之外的任意的单个字符

a.b
a,b

b..g
baxg
baag
=========================================
[] 字符的筛选

a[axj]b

aab
axb
ajb
abb

axb

a[0123456789]b
a10b
a1b
a0b
axb

a[0123456789abcdfe....z]b
a[0-9]b
a[a-z]b

a[0-9a-zA-Z]b
a1b
axb
aAb

a[^0-9]b 表示a与b之间只能出现除了0123456789之外的任意单个字符。

a[^0-9a-z]b

x[aeiou]y

=====================================================
| 表示或的意思

z|food 由于| 的优先级非常低，所以这个表达式可以匹配 z 或 food

这个表达式不匹配zood

(z|f)ood 才表示zood或者food

z
food
zood

===========================================
()改变运算的优先级。

提取组。

=======================================
* 限定符，表示前面的表达式出现0次或多次。

zoo*

a.*b
ab
aaddddb
afjdsklf%$#@dsklfjdsklfjdsklfjb

a.b

axb
a_b
a.b

.
[]
|
()
*

zoo*
zoooooooooooooooooooooooooooooooooooooooo
zoo
zo
(zoo)*
zoozoo
================================================
+ 限定符，表示前边的表达式必须出现1次或者多次。至少得出现1次。

a.+b
a9dfjsakl3824urnj324239feb
==================================================
? 限定符，表示前边的表达式必须出现0次或者1次。

a.?b
ab
axb
agdsafdsafdab不匹配

? 的另外一个作用就是“终止贪婪模式”。正则表达式默认是贪婪模式。

======================================================================
a[0-9]+b
axb不匹配
ab不匹配
a0b
a00b
a09b
a99999999999999999999b

==========================其他限定符=====================
{n} 限定符，限定前边的表达式必须出现n次。
a[0-9]{10}b
a1234567899b
======================
{n,} 限定符，限定前边的表达式至少出现n次。

1[a-z]{3,}2
1axffdsafdsafdasfdsafdsafdsafdsfdsafsdfdsfdsfdsa2

========================================
{n,m} 限定符，限定前边的表达式至少出现n次，最多出现m次。

a[0-9]{3,7}b
a0000000b

===========================================
.
[]
[^]
|
()
*
+
?
{n}

{n,}
{n,m}

=================================================
^表示的是字符串的开头

$表示字符串的结尾。

^ 和 $ 就表示的是字符串的两个特征。一个表示开头的特征，一个表示结尾的特征

abcxyz

^abc.*xyz$

^abcdefg$

^abcdefg
acxbc

abcfdsafdsafdsafdasfdasfdasfds

fdsfdsfxyz
xyz$

===========================================
a[0-9]b
a\db

\d等价于[0-9]
digital

\D [^0-9]

\s 表示所有那些空白符，不可见字符
a\s*b
ab
a 　　

b

\S 就是除了\s以外的所有字符。

=================================================
\w [0-9a-zA-Z_]
word表示单词字符。

\W 就是除了\w之外的所有其他字符。

\b表示单词的边界。 （断言，只判断，不匹配。）

============================================

.

下面这几种方式就可以表示任意的单个字符出现在ab之间。
a[\s\S]b
a[\d\D]b
a[\w\W]b

正则表达式测试工具  http://tool.oschina.net/regex#

正则表达式练习：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace _06正则表达式
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.正则表达式是对字符串的操作

            //2.正则表达式是一个用来描述字符串特征的表达式。
            //特征：必须出现的内容，可能出现的内容，不能出现的内容

            //观察字符串规律，根据规律总结特征，然后根据特定字符串的特征来编写正则表达式。

            #region >10 and <=20的所有字符串

            //while (true)
            //{
            //    Console.WriteLine("请输入");
            //    int n = Convert.ToInt32(Console.ReadLine());
            //    if (n > 10 && n <=20)
            //    {
            //        Console.WriteLine("OK");
            //    }
            //    else
            //    {
            //        Console.WriteLine("输入不合法！！");
            //    }
            //}

            //Regex.IsMatch();//判断是否匹配
            //Regex.Match();//提取某个（一个）匹配
            //Regex.Matches();//提取所有的匹配
            //Regex.Replace();//替换
            //Regex.Split();//分割

            ////1.写正则表达式，观察字符串找规律，根据规律写正则
            //while (true)
            //{
            //    Console.WriteLine("请输入");
            //    string msg=Console.ReadLine();
            //    bool b = Regex.IsMatch(msg,"^(1[1-9]|20)$");
            //    Console.WriteLine(b);
            //}

            #endregion

            #region 正则案例

            //while (true)
            //{
            //    Console.WriteLine("请输入");
            //    string msg = Console.ReadLine();
            //    //IsMatch()这个函数验证指定的字符串是否匹配指定的正则表达式，但是注意；
            //    //默认情况下，如果在整个字符串中只要有一部分匹配给定的字符串则返回True
            //    //bool b = Regex.IsMatch(msg, "[1-9]{6}");

            //    //要想验证完全匹配6位数字，则必须在正则表达式两端加开始^和结束$
            //    bool b = Regex.IsMatch(msg, "^[1-9]{6}$");
            //    Console.WriteLine(b);
            //}

            //while (true)
            //{
            //    Console.WriteLine("请输入");
            //    string msg = Console.ReadLine();
            //    //1.这个表达式本身只匹配z或者food
            //    //2.但是由于正则表达式两端没有加开始^和结束$，
            //    //所以整个给定字符串只要任何一部分与字符串z或者food匹配，就返回true
            //    bool b = Regex.IsMatch(msg, "z|food");
            //    Console.WriteLine(b);
            //}

            //while (true)
            //{
            //    Console.WriteLine("请输入");
            //    string msg = Console.ReadLine();
            //    //因为这个正则表达式使用了 | 字符，所以该正则表达式的意思是：^z 或 food$
            //    //既：所有以z开头的字符串或以food结尾的字符串
            //    bool b = Regex.IsMatch(msg, "^z|food$");
            //    Console.WriteLine(b);
            //}

            //while (true)
            //{
            //    Console.WriteLine("请输入");
            //    string msg = Console.ReadLine();
            //    //这个只能匹配 字母z 或者 单词 food
            //    //bool b = Regex.IsMatch(msg, "^(z|food)$");
            //    bool b = Regex.IsMatch(msg, "(^z$)|(^food$)");
            //    Console.WriteLine(b);
            //}

            //while (true)
            //{
            //    Console.WriteLine("请输入邮政编码");
            //    string postcode = Console.ReadLine();
            //    //bool b = Regex.IsMatch(postcode, "^[0-9]{6}$");
            //    //bool b = Regex.IsMatch(postcode, "^\\d{6}$");
            //    //默认.net采用的是unicode字符匹配，所以中文的123456也是匹配的
            //    //bool b = Regex.IsMatch(postcode, @"^\d{6}$");

            //    //指定RegexOptions.ECMAScript选项后，\d就只表示普通的数字，不再包含全角的数字
            //    bool b = Regex.IsMatch(postcode, @"^\d{6}$",RegexOptions.ECMAScript);
            //    Console.WriteLine(b);
            //}

            //while (true)
            //{
            //    Console.WriteLine("请输入身份证号");
            //    string id = Console.ReadLine();
            //    bool b = Regex.IsMatch(id, "^([0-9]{15}|[0-9]{17}[0-9xX])$");
            //    Console.WriteLine(b);
            //}

            //while (true)
            //{
            //    Console.WriteLine("请输入电话号码");
            //    string phoneNumber = Console.ReadLine();
            //    bool b = Regex.IsMatch(phoneNumber, @"^((\d{3,4}\-?\d{7,8})|\d{5})$");
            //    Console.WriteLine(b);
            //}

            //while (true)
            //{
            //    Console.WriteLine("请输入邮件地址");
            //    string email = Console.ReadLine();
            //    //.出现在[]中，就表示一个普通的.可以不转义
            //    //-出现在[]中第一个位置的时候可以不转义
            //    bool b = Regex.IsMatch(email, @"^[-a-zA-Z0-9._]+@[-a-zA-Z0-9]+(\.[a-zA-Z0-9]+){1,}$");
            //    Console.WriteLine(b);
            //}

            #endregion

        }
    }
}