c#学习笔记——4

什么是序列化，如何进行序列化

答：序列化就是把一个对象转化为二进制流

步骤1.在类上面标记[Serializable]

        2.创建FileStream对象
3.创建BinaryFormatter对象
4.使用BinaryFormatter对象的Serialize()方法

索引

索引器就是一个带有参数的属性

例子：

 class MyClass

    { 

        // 索引器就是一个带有参数的属性

        public int Num

        {

            get;

            set;

        }

        int[] nums = { 1, 11, 111, 2, 22, 222, 3, 33, 333 };

        public int this[int index]

        {

            get {return nums[index];}

            set { nums[index] = value; }

        }

        public string this[string key]

        {

            get { return "没有使用索引参数"; }

        }

        public string this[int i, string s, char c, double d]

        {

            get { return string.Format("{0}{1}{2}{3}", i, s, c, d); }

        }

        public int Length

        {

            get { return nums.Length; }

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            MyClass m = new MyClass();

            for(int i = 0; i < m.Length; i ++)

            {

                Console.WriteLine(m[i]);

                Console.WriteLine(m[""]);

                Console.WriteLine(m[10,"a123b",'男',10.123]);

            }

            Console.ReadKey();

        }

    }

什么是深度拷贝，什么是浅度拷贝

答：浅拷贝就是只针对对象的拷贝，没有拷贝对象中的引用成员。

深考就是将对象全部复制一份。

例子：

        //    MyClass2 m1 = new MyClass2();
        //初始化m1 

        //    m1.Num = 10;

        //    m1.C = new MyClass1();   

        //    m1.C.Num = 20;

        //    MyClass2 m2 = new MyClass2();

        //    m2.Num = m1.Num;

        //    m2.C = m1.C;
     //这是浅拷贝，因为引用类型C都是指向同一个对象

        //    // 只针对对象MyClass2，将其数据拷贝了一份，对其中引用类型直接复制过来

        //    // 没有考虑其引用类型的拷贝就是浅拷贝

分割线--------------------------------分割线--------------------分割线---------------------------------

        //    MyClass2 m3 = new MyClass2();

        //    m3.Num = m1.Num;

        //    m3.C = new MyClass1();

        //    m3.C.Num = m1.C.Num;
//这是深度拷贝，与上面例子不同的是，引用类型C指向自己的新对象，且Num值一样。

    class MyClone

    {

        public int Num;

        public string str;

        public double dNum;

        public MyClass1 C;

        public MyClone Clone()

        {

            // 由object提供的方法完成浅拷贝

            return (MyClone)base.MemberwiseClone();

        }

        public MyClone DeepoClone()

        {

            MyClone m = (MyClone)MemberwiseClone();

            m.C = new MyClass1();

            m.C.Num = this.C.Num;

            return m;

        }

    }

MemberwiseClone()浅拷贝     object提供的

序列化是把一个对象转化成二进制流

反序列化是把一个二进制流转化为原有对象

所以序列化与反序列化可以实现对象的深度拷贝

例子：实现m1深度拷贝给m3

 MyClone m1 = new MyClone();

            m1.Num = 10;

            m1.dNum = 20.1;

            m1.str = "字符串";

            m1.C = new MyClass1();

            m1.C.Num = 30;

            MyClone m3 = null;

            MemoryStream stream = new MemoryStream();   // MemoryStream  内存流，本例将二进制序列化到内存，然后从内存反序列化

            using (stream)

            {

                BinaryFormatter bin = new BinaryFormatter();

                bin.Serialize(stream, m1);

                stream.Position = 0;                                       //序列化后光标是指向对象最后的位置的，因此需要将光标位置移动到开头

                m3 = (MyClone)bin.Deserialize(stream);

            }

获取当前执行程序的路径

推荐用：

Assembly.GetExecutingAssembly.Location

此方法返回全路径（包括.exe）

不推荐用Directory.GetCurrentDirectory

因为如果前面有Directory.SetCurrentDirectory后，Directory.GetCurrentDirectory就与Set的值一样了

采用递归思想实现小说阅读器

 private void Form1_Load(object sender, EventArgs e)

        {

            TreeNode tn = tvContent.Nodes.Add("小说");

            string path = Path.GetFullPath(@"txt");

            Func(tn, path);   //在tn结点上添加path目录下的所有文件和文件夹

        }

public void Func(TreeNode tn, string path)       //在tn节点下添加path文件夹下的文件和文件夹

        { 

            // 获得Path下的子文件夹

            string[] dirs = Directory.GetDirectories(path);

            // 获得子文件

            string[] files = Directory.GetFiles(path, "*.txt");

            // 加到tn节点上

            for (int i = 0; i < dirs.Length; i++)

            {

                TreeNode tn1 = tn.Nodes.Add(Path.GetFileName(dirs[i]));

                // 调了一次自己

                Func(tn1, dirs[i]);

            }

            for (int i = 0; i < files.Length; i++)

            {

                TreeNode tn2 = tn.Nodes.Add(Path.GetFileName(files[i]));

                // Tag属性

                tn2.Tag = files[i];     //文件全
9ba7
路径记录下来，后面要用到

            }

        }
private void tvContent_AfterSelect(object sender, TreeViewEventArgs e)

        {

            if (e.Node.Tag != null)

            {

                // MessageBox.Show(e.Node.Tag.ToString());

                text.Text = File.ReadAllText(e.Node.Tag.ToString(), Encoding.Default);

            }

        }

递归方法思想

 // 如何自己调自己（递推表达式  Fn 与 Fn-1的关系）

 // 如何结束调用

例子：

// 用递归方法求出下列数列的通项

            // 1 1 2 3 5 8 13 21 34 ...

发现规律// Fn = Fn-1 + Fn-2

 static int Func1(int n)

        {

            if (n <= 0 || n <= 1)

            {

                return 1;

            }

            return Func1(n - 1) + Func1(n - 2);

        }