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];     //文件全路径记录下来，后面要用到
            }
        }
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);
        }