C# 全总结

using System;
using System.Collections.Generic;
//using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;
using static System.Console;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        [DllImport("dltest.dll", EntryPoint ="Print")]
        static extern void xPrint(int x);
        #region old-test

        //////////////////////////////////////////////////////////////////
        static void TestStreamReadWrite()
        {//一个流不能兼备读写两种操作，不知道为什么，这不合理
            string s1 = "你好啊ABC";

            var t = "你好啊ABC".Length;
            //关于编码注意几点：
            //1，sizeof(char) 等于 2
            //2，str.Length 是以元素个数算的，不是按字节算的，如 "你好啊ABC” length = 6
            //3，c#在VS的默认编码为 Encoding.Default, 该编码下汉字占两字节，非汉字占1字节，通过查看ms中的字节数据可知
            //4，string 类型写入任何buffer时都是先写长度，一般为1字节，再写字节数据，如下
            var sz = sizeof(char); //2, 注意char占2字节
            var szb = sizeof(bool); //1

            var ms = new MemoryStream();
            var writer = new BinaryWriter(ms, Encoding.UTF7);
            writer.Write(s1);
            ms.Close();
            writer.Close();

            var ms2 = new MemoryStream(ms.GetBuffer());
            var reader = new BinaryReader(ms2, Encoding.UTF8);
            var s2 = reader.ReadString();

        }

        //////////////////////////////////////////////////////////////////
        static void TestEncoding()
        {
            string s1 = "你好啊ABC";

            //汉字乱码问题，汉字必须使用2个以上字节才能表示
            //编码方式
            //1，ASCII码，只有一个字节，不能正确表示汉字，出现乱码，可以正确表示数字和字母符号
            //2，UNICODE，任何符号都用2个字节表示，因此可以表示汉字和任意符号
            //3，UTF8，变字节的编码，可以正确表示任何字符和汉字，各国语言
            //4，GB2312编码，国标码，主要是为汉字服务的中国编码，汉字占两字节，字母数字占1字节
            //5，default编码，在国内， 般就是GB2312
            Encoding.Default.GetBytes(s1);
            var bytes = Encoding.GetEncoding("GB2312").GetBytes(s1);
            var len = bytes.Length;
            var bts = new byte[10 + len];
            Array.ConstrainedCopy(bytes, 0, bts, 0, len);

            var s2 = Encoding.GetEncoding("GB2312").GetString(bts).TrimEnd('');
            string s3 = "hello/0/0dddddd".TrimStart('');//!!!!!!!!!!!!!!!!!!!!!!!!!!!!    

        }

        #region 计算机中数据的存储
        //////////////////////////////////////////////////////////////////
        static void TestTypeConvert()
        {//把一个有符号数转为无符号后再转回来值保持不变，以下以1字节为例
            //原理：计算机中符点数都是有符号的，不存在这种转变，只剩下整数，
            //真值：绝对值的二进制值，如-1的真值为 00000001
            //整数是以补码形式存放的，计算机规定了正数的补码是本身，负数的补码是：符号位不变，真值按位取反再加1
            //强制转换做的事就是把一个补码看成是有符号还是无符号
            //有符号数，在计算时：符号位不变，真值按位取反再加1。无符号数直接计算，举例如下：
            //1，-1 的真值为00000001，补码为 1 111 1111，强转时就是把补码值看作是一个无符数，因此它=255
            //，再次强转时把它看成有符号数，符号位不管，其余位按位取反加1后是1，因此再次转回了-1
            //2，-2 的真值为00000010，补码为 1 111 1110，强转时把补码看作无符号数，因此它=254
            //3，-128真值有点特殊，128的二进制码为1000 0000，第8位是符号位，舍弃，取后面的0，即-128的真值为0
            //补码经按位取反加1后还是 1 000 0000，强转时看成无符号数即为128
            //-------------------------------------------
            //1字节数据和2字节数据进行加法运算时，要进行位扩展，将1字节扩展为2字节
            //正数扩展时高位补0，负数扩展时高位补1
            //C#中小于4字节的数据进行运算时会先扩展成int再进行
            sbyte sb = -127;
            var b = (byte)(sb);
            var sb1 = (sbyte)(b);
            object dx = 10.0f;
            double dx2 = 33;
            byte ix = (byte)dx2;

            var t = dx.GetType();
            Type T = System.Type.GetType(t.FullName, true);


        }
        #endregion

        //////////////////////////////////////////////////////////////////
        void TestUncheck()
        {
            unchecked
            {//不被编译系统做编译时安全检查

            }
        }

        static void TestBoxing()
        {
            int i = 10;
            object o = 1;
            int i2 = (int)o;
        }

        static void TestReadBytes()
        {
            byte[] bts = new byte[4] { 23, 0, 16, 0 };
            var ms = new MemoryStream(bts);
            var br = new BinaryReader(ms);
            var p1 = ms.Position;
            var ix = br.ReadUInt32();
            var p2 = ms.Position;
            Console.WriteLine("num=" + ix);
            br.Dispose();
            br.Close();
            ms.Dispose();
            ms.Close();
        }

        static void TestStrEnd()
        {
            string str = "abcde";
            var br = new BinaryReader(new MemoryStream(Encoding.ASCII.GetBytes(str)));
            var b = br.ReadByte();
            while (b != 0)
            {
                Console.WriteLine(b);
                try
                {
                    b = br.ReadByte();
                }
                catch (System.Exception ex)
                {
                    Console.WriteLine("未发现字符串结束符");
                    break;
                }
            }
        }

        static void TestBigEndia()
        {
            var br = new BinaryWriter(File.Create("f:/testx.dt"), Encoding.ASCII);
            br.Write((Int16)9);
            string str = "Stand";
            br.Write(str);
            br.Write((Int16)10);
            br.Write((Int16)70);
            br.Dispose();

        }

        static void TestChar0()
        {//注意字符串中0和的区别，如 s1="h0ello", s2 = "hello"
            //s2中的是字符串结尾符，除了C#不把它作为结束符外，其它语言都把它作为结束符，如U3D，LUA,C/C++等
            //而s1中的0仅是一个字符0而已，字符0的ASCII值是0X31=49,''的ASCII值是0
            //注意这两种0在C#和U3D的API之间切换时容易造成BUG,如：
            //1, debug.log(s1): "h0ello"
            //2，debug.log(s2): "h"
            var s = "hello";
            s += 0 + ",world";
            var s1 = "hello";
            s1 += (char)0 + ",world";
            var s2 = "hello";
            s2 += '' + ",world";
        }
        static void MemTest()
        {

        }
        static void ReflectionTest()
        {//测试两种反射的效率问题
            //Type.GetType()只能在同一个程序集中使用，typeof则可以跨程序集(assembly)
            //通过下面的实测，发现typeof是比GetType快40多倍
            var timer = Stopwatch.StartNew();
            timer.Start();

            Type tx = Type.GetType("string");
            var tx1 = Type.GetType("float");
            timer.Stop();

            Console.WriteLine("T1= " + timer.Elapsed);//0.0000471

            timer.Restart();

            tx = typeof(string);
            tx1 = typeof(float);

            timer.Stop();
            Console.WriteLine("T2= " + timer.Elapsed);//0.0000011
        }

        static void TestDelegate()
        {

            //类C++11风格：指定初始化容量20，使用初始化列表给部分成员赋值
            var lst = new List<float>(20) { 1, 3, 4, 20, -2, 9, 0 };
            for (var i = 0; i < lst.Count; ++i)
            {
                //使用下标进行随机访问，说明list不是一个真正的链表，而是类似STL的Vector
                Console.WriteLine(lst[i]);
            }

            //public void Sort (Comparison<T> comparison)      
            //public delegate int Comparison<T>(T x, T y);


            //这是对调用List<int>.Sort进行排序的写法，其中sort的定义及Comparison委托的定义如上
            lst.Sort(new Comparison<float>(delegate (float m1, float m2) //委托
            {
                return 1;
            }));
            lst.Sort(delegate (float m1, float m2) //委托
            {
                return 1;
            });
            lst.Sort((float m1, float m2) =>//Linq表达式
            {
                return 1;
            });
            lst.Sort((m1, m2) => //Linq表达式
            {
                return 1;
            });

        }

        static string TestRetStr()
        {//测试返回字符串是否会复制
            return "helloworld";
        }

        static void TestStrRet()
        {//h1 = h2 = h3说明它们返回的是同一个字符串的引用
            var s1 = TestRetStr();
            var s2 = TestRetStr();
            var s3 = TestRetStr();
            var h1 = s1.GetHashCode();
            var h2 = s1.GetHashCode();
            var h3 = s1.GetHashCode();
        }
        static void TestVirtualFuncCall()
        {
            var otx = new CTestChildX();

            otx.Update();//输出结果:child,如果注释1处函数不加override，输出结果为:base
            var oty = new CTestY();
            oty.Update();
            oty.OnUpdate();

        }
        static void TestStrModify()
        {
            var s1 = "hello";
            var s2 = s1;
            s1 += "world";
            Console.WriteLine(s2);

            var uns1 = s2.GetHashCode();
            Console.WriteLine(uns1);
        }

        static void Tests1()
        {
            var s1 = "hello";
            var uns1 = s1.GetHashCode();
            Console.WriteLine(uns1);

        }

        #endregion

        #region 2018.3.30
        #region ref out and template
        class myTemp<T1, T2>//类入口
        {
            public T1 Add(T1 a, T1 b)
            {//模板类型不能直接相加，必须先转为动态类型，避开编译检查，运行时动态决定类型
                dynamic da = a;
                dynamic db = b;
                return da + db;
            }

            public void tint<T3>()//注意C++不能这么写，所有模板参数必须由类入口传入
            {
                Type t = typeof(T3);
                WriteLine(t);
            }
        }

        delegate void refOutFunc(ref double t1, out double t2);
        delegate T TemplateDelegate<T, U>(T a, U b);
        static void TestRefAndOut()
        {
            //ref, out 本质上都是引用
            //fef就为了传给函数使用，必须先初始化，但也可以传出数据，out是为了从函数中传出数据使用，不用初始化
            refOutFunc rof = delegate (ref double ax, out double bx) {
                ax = 1; bx = 2;//ref out两种类型的变量都被更改了
            };

            double x1 = 0, x2;
            rof(ref x1, out x2);
        }
        static void TestTemplate()
        {
            var otp = new myTemp<int, int>();
            otp.tint<object>();
        }
        static T TempFunc<T, U>(T a, U b)
        {
            return a;
        }
        static void TestBufAligin()
        {//自定义字节BUF的对齐测试
            int x = 9;
            int y = (x + 7) & ~7;
            WriteLine(y);
        }
        #endregion

        #endregion

        #region 2018.4.9

        //BUG??????
        //使用StopWatch测试运行时间
        //两段测试A和B
        //测试结果受测试顺序影响，后测要比先测耗时长了许多

        static void TestKeyIntStr()
        {//
            var idict = new Dictionary<int, string>();
            var sdict = new Dictionary<string, string>();

            for (int i = 0; i < 1000000; i++)
            {
                var key = i * 2 + 1;
                var v = i * i + "";
                idict.Add(key, v);
                sdict.Add(key + "", v);
            }

            //测试 A
            var t1 = 100000 * Test1(idict);

            //测试 B
            var t2 = 100000 * Test2(sdict);

            Console.WriteLine("t1: {0},t2: {1}", t1, t2);
            //Console.WriteLine("dt1: {0},dt2: {1}", dt1, dt2);
        }
        static float Test1(Dictionary<int, string> dict)
        {
            var timer = new Stopwatch();
            timer.Start();
            var it = dict[2001];
            var t1 = timer.ElapsedTicks;
            timer.Stop();
            return (float)((float)t1 / Stopwatch.Frequency);
        }

        static double Test2(Dictionary<string, string> dict)
        {
            var timer = new Stopwatch();
            timer.Start();
            var it = dict["2001"];
            var t1 = timer.ElapsedTicks;
            timer.Stop();
            return (float)((float)t1 / Stopwatch.Frequency);
        }
        #endregion

        #region 2018.7.7
        #region 数组的数组，二维数组
        static int[] returnArray()
        {
            //数组是引用类型，分配在堆上
            int[] arr = { 1, 2, 3, 4 }; //虽然这样写，其实等价于int[] arr = new int[]{1,2,3,4};
            return arr; //返回一个数组对象
        }
        static void TestArray() {

            //1，一维数组
            char[] arr = new char[2] { 'a', 'b' }; //必须全部初始化，或不初始化
            int[] iarr = new int[2] { 0, 1 };
            char[] sarr = new char[3];

            //2，数组的数组，锯齿数组
            char[][] d2arr = new char[2][];
            d2arr[0] = new char[30];
            d2arr[1] = new char[2] { 'a', 'b' };
            d2arr[0][1] = 'x';

            //3，二维数组，矩阵
            int[,] i2arr = new int[2, 3];
            for (var i = 0; i < 2; ++i)
            {
                for (var j = 0; j < 3; ++j)
                {
                    i2arr[i, j] = i * 3 + j;
                }
            }
        }
        #endregion
        #region 字段初始化无法使用非静态（字段、方法、属性）
        delegate int mydelegate(int x);
        //-------------------------------------------------------------------------
        //字段初始化无法使用非静态（字段、方法、属性）
        //-------------------------------------------------------------------------
        float fxs;
        static float sfxs;
        //float fxs2 = fxs; //error
        float fxs3 = sfxs; //right，可用静态字段初始化
        float fxs4 = TestStaticInit(); //right，调用静态函数初始化
        static int TestStaticInit() { return 10; }
        mydelegate _mydel = (x) =>//LINQ为什么可以？，从下面可知，LINQ语句只相当于一堆初始化语句的集合
        {
            //int fx = fxs; //error
            return 20;
        };

        #endregion
        #region 默认访问修饰符
        //1，名字空间中，最外层类及接口的默认修饰符为internal，也就是本程序集可访问
        //2，类中，变量，成员，类中类的默认修饰符为private
        //3，结构中，同类
        //4，接口中，所有方法和属性都为public，接口中只能有方法，不能有变量
        interface IMyinterface
        {//接口中可以有方法，抽象属性，不可以有变量
            int Id { get; } //抽象属性，公有
            void Fly();  //方法，公有
        }
        #endregion
        #region 类模板继承
        class CTClass<t1, t2, t3> //多个where的写法
            where t1 : struct //必须是值类型
            where t2 : class //必须是引用类型
            where t3 : new() //必须有无参构造函数
        {
            float fx, fy;
            public static t1 Add(t1 a, t1 b)
            {
                return (dynamic)a + (dynamic)b;
            }
        }

        //模板继承的几种方式
        //1，全特化
        class CDTClass : CTClass<int, CCmpBase, CCmpBase> { }

        //2，原样继承，注意基类的所有约束都要重写一遍
        class CDTX<t1, t2, t3, t4> : CTClass<t1, t2, t3>
            where t1 : struct //必须是值类型
            where t2 : class //必须是引用类型
            where t3 : new() //必须有无参构造函数
        { }
        //3，偏特化，介于二者之间的形态
        #endregion
        #region 运算符重载
        class CCmpBase
        {//带有默认构造函数
            float _x;
        }
        class CComplex : CCmpBase
        {
            float real, image;
            public CComplex(float real, float image = 0)
            {
                this.real = real;
                this.image = image;
            }

            //一，类型转换 ：数值转对象
            //CComplex cp = 2.1f 或 CComplex cp; cp = 2.1f;
            //C#从不调用类型转换构造函数进行类型转换
            public static implicit operator CComplex(float real)
            {
                return new CComplex(real);
            }

            //二，类型转换：对象转bool
            public static explicit operator bool(CComplex cp)
            {
                return cp.real != 0 && cp.image != 0;
            }

            //三，类型转换：对象转数值
            public static implicit operator float(CComplex cp)
            {
                return cp.real;
            }

            //四，算术运算符重载 : +,-,*,/,%等
            //c#的运算符重载全部为静态函数，因此没有隐含参数
            //而C++运算符重载时可以重载为友元，绝大多数重载为类的成员函数，因此基本都有一个隐含参数（对象本身）
            public static CComplex operator +(CComplex a, CComplex b)
            {
                return new CComplex(a.real + b.real, a.image + b.image);
            }
            public static CComplex operator ++(CComplex cp)
            {
                cp.real++;
                cp.image++;
                return cp;
            }

            //五，不支持的运算符重载
            //1，不允许重载=运算符, C++可以，都不允许重载+=之类的
            //2，不允许重载括号()运算符
            //3，不允许重载[]运算符，因为它是索引器
            //public static implicit operator () (CComplex cp)
            //{
            //    return a;
            //}

            void TestPrivate()
            {
                var cp = new CComplex(1, 3);
                cp.real = 20;
                cp.image = 30.0f;
            }
            public void PrintInfo()
            {
                WriteLine("real:{0},image:{1}", real, image);
            }
        }
        static void TestOperatorOverload()
        {
            CComplex cp = new CComplex(1, 1);

            //1，同时支持前后向++，【不同于C++】
            cp++;
            ++cp;

            //2，但不允许连++， 【不同于C++】
            //cp++++或 ++++cp

            cp.PrintInfo();

            //3，支持连续+，【同于C++】
            CComplex cp1 = new CComplex(1, 1);
            var cpadd = cp + cp1 + cp1 + cp1;
            cpadd.PrintInfo();
            //类型转换运算符
            cp = 2.1f;

            //类型转换运算符
            //C++中是调用类型转换构造函数，而不是运算符重载
            CComplex cp2 = 1.0f;

        }
        #endregion
        #endregion

        #region 2018.7.11
        #region 两数相加函数模板实现
        static T MaxNum<T>(T a, T b)
        {
            return ((dynamic)a > (dynamic)b) ? a : b;
        }
        #endregion
        #region thread lock
        //thread test
        class Account
        {
            private object thisLock = new object();
            int balance;
            Random r = new Random();

            public Account(int initial)
            {
                balance = initial;
            }

            int Withdraw(int amount)
            {
                if (balance < 0)
                {
                    throw new Exception("Negative Balance");
                }

                lock (thisLock)
                {
                    if (balance > amount)
                    {
                        WriteLine("before-withdraw: " + balance);
                        WriteLine("amount to withdraw: " + amount);
                        balance -= amount;
                        WriteLine("after withdraw: " + balance);
                        return amount;
                    }
                    else
                        return 0; //transaction rejected
                }
            }

            public void DoTransactions()
            {
                for (int i = 0; i < 100; ++i)
                {
                    Withdraw(r.Next(1, 100));
                }
            }

        }

        static void TestObjectLock()
        {
            Account acc = new Account(1000);
            Thread[] threads = new Thread[10];
            for (int i = 0; i < 10; ++i)
            {
                threads[i] = new Thread(acc.DoTransactions);
            }
            for (int i = 0; i < 10; ++i)
            {
                threads[i].Start();
                //threads[i].Join();
            }


        }
        #endregion
        #region derive protected
        class A
        {
            float fxPrivate;
            protected int nProtected;
            protected A(int x) { }
        }

        class B : A     //c++的公有继承
        {
            B(String name, int x) : base(x) { }

            protected int nProtected;
            void TestDerive()
            {//这里的规则与C++完全一样:
                //1，子类不能访问基类的私有成员，可以访问基类的保护和公有成员
                //2，保护成员可以在本类中访问（不一定是本对象中）
                nProtected = 20;
                base.nProtected = 10;
                var ob = new B("b", 1);
                ob.nProtected = 30; //类中访问类的保护成员，但不是本对象的成员

            }
        }
        #endregion
        #endregion

        #region 2018.7.12
        #region 常量和静态变量静态类readonly
        //----------------------------------------------------------------------
        //常量和静态变量，静态类
        //----------------------------------------------------------------------
        //类的静态变量和常量，都属于类而不属于对象，不能用对象来调用，只能用类名调用
        //这不同于C++，是更合理的设计
        //常量的值在类定义时就确定了，不因对象而不同，因此存放在类中更合理
        class CNormclass
        {
            class CInclass
            {
                public float fx = 20;
            }
            public int _id;
            public const string cname = "CNormalclass";

            //1，常量仅能修饰 ：数字，bool，字符串，null引用
            //不能像C++那样定义一个常量对象，这真是太悲哀了，因为很多时候这可以加速数据传递，增加安全性
            //由于这个原因，C#的List.ToArray每次都只能返回一个内部数组的拷贝，因此使用list存储数量较大较复杂的数据时
            //不要轻易使用ToArray，直接用List就行了，它也支持下标索引方式取数组元素
            const CInclass lst = null;

            //2，readonly也不能实现常量对象的效果
            //readonly仅表示变量本身不能被赋值，但不阻止通过对象变量更改对象内的字段
            //onc.readonlyobj.fx = 20
            public float fx = 20;

            private readonly CInclass readonlyobj = new CInclass();
  
            public static void Test()
            {
                //1，不能调用非静态字段或方法
                //this._id = 20; //error，没有this指针

                //2，可以调用常量字段
                var lname = cname;

                var onc = new CNormclass();

                //私有变量在类的静态方法也可以访问
                //2，虽然不能更改readonlyobj本身的值，却可以更改其内部成员的值，这就是readonly的作用
                onc.readonlyobj.fx = 20; 
            }
        }
        static class C712//类中类，默认为私有
        {//静态类不能实例化，且只能声明：常量，静态常量，静态属性，静态方法
            public const int constX = 20; //1，常量
            public static int staticX = 0; //2，静态常量
            public static int ix { set; get; } //3，静态属性

            //一，【静态类中不能定义实例化字段】
            //public int _id; 

            //二，【静态类中不能定义实例化字段】
            //void Ctest(){ //【error： 静态类中不能定义实例化方法】
            //    this._id = 20;
            //}

            static void Test()//4，静态方法
            {
                //三，【静态方法中不能调用非静态变量或方法，因为没有this指针】
                //_id = 20;  //error 

                //四，【可以调用常量字段，这与C++不同】
                var c = constX;
            }

        }
        public const int ixd = 20;
        public static float fx = 20;
        public void Testff()
        {
            fx = 30; //等价于Program.fx = 30,而不是 this.fx = 30;
            Program.fx = 30;
            var tx = C712.constX;
            C712.staticX = 30;
            var ix = Program.ixd;

            //var oc7 = new C712(); //error 静态类不能创建实例
        }
        #endregion
        #region 事件和委托
        //--------------------------------------------------------------
        //event -test
        //--------------------------------------------------------------
        //使用event的好处，与delegate的区别：
        //event 本质上是一个委托，是做了一些安全措施的委托
        //1，event 定义的委托只允许 +=操作，不允许=赋值，这样防止事件被误清空，delegate则没有这些限制
        //2，event 定义的委托只能在本类中调用，可以防止外部触发，delegate没有这些限制
        //3，不使用事件，delegate方式完全可以实现类似限制，通过私有变量和公有函数结合方式
        class EventTest
        {
            public delegate void Delx(string s = "");
            Delx _delegate; // 私有委托，防止外部调用
            public event Delx _event; //公有事件，给外部通过+=注册使用，但_event()函数只能在本类调用，不能在类外调用

            //-------------------------------------------------------------
            //1 ，委托方式
            //-------------------------------------------------------------
            //（1）外部调用eventTest.AddListener(func)方式注册事件
            public void AddListener(Delx callback)
            {
                _delegate += callback;
            }
            //（2）本类对象调用此函数触发事件
            void DelegateBrocast()
            {
                _delegate("delegate"); //回调，触发事件
            }

            //-------------------------------------------------------------
            //2，事件方式
            //-------------------------------------------------------------
            //（1）外部使用 _event += 方式注册回调函数
            //（2）本类对象调用此函数触发事件
            void EventBrocast()
            {
                _event("event");//回调，触发事件
            }
        }
        class Listener
        {
            public void OnEvent(string s)
            {
                WriteLine("on-event---------------" + s);
            }
        }
        static void TestEventAndDelegate()
        {
            Listener l1 = new Listener();
            EventTest test = new EventTest();

            //1，事件方式
            test._event += l1.OnEvent; //注册事件
            //test._event = l1.OnEvent; //编译错误，事件只能使用+=，防止事件被清空
            //test._event("event"); //编译错误，事件不能在类外调用，事件只能由其所在类调用

            //2，委托方式
            test.AddListener(l1.OnEvent); //注册委托，通过函数对委托进行注册，因委托是私有的，可防止直接操作 test._delegate()
        }

        #endregion
        #region 文件和目录
        static void FileAndDirectory()
        {
            //-------------------------------------------------------------------------
            //文件对象的相关操作
            //-------------------------------------------------------------------------
            //方式一，使用工具类：File类，不需生成对象
            var file = File.Open("f:/test.txt", FileMode.Create, FileAccess.ReadWrite);
            //方式二，通过FileStream的对象
            var filestream = new FileStream("f:/test._txt", FileMode.Create, FileAccess.ReadWrite);

            //-------------------------------------------------------------------------
            //目录文件相关操作
            //-------------------------------------------------------------------------
            //方式一，实例化DirectoryInfo类
            var dir = new DirectoryInfo("f:/tolua");
            //（1）获取目录
            foreach (var d in dir.GetDirectories("*.*", SearchOption.AllDirectories))
            {
                WriteLine(d.FullName);
            }
            //（2）获取文件
            foreach (var fileinfo in dir.GetFiles("*.*", SearchOption.AllDirectories))
            {
                WriteLine(fileinfo.FullName);
            }

            //方式二，使用工具类: Directory类，不需生成对象
            //（1）获取目录
            var dirs = Directory.GetDirectories("f:/tolua", "*.*", SearchOption.AllDirectories);
            //（2）获取文件
            dirs = Directory.GetFiles("f:/tolua", "*.*", SearchOption.AllDirectories);

            for (int i = 0; i < dirs.Length; ++i)
            {//打印输出
                WriteLine(dirs[i]);
            }

        }
        #endregion
        #endregion

        #region 2018.7.17
        #region 计算机中浮点数的存储
        static void TestFloat()
        {
            using (var ms = new MemoryStream())
            {

                using (var br = new BinaryWriter(ms))
                {
                    br.Write(125.5f);
                    var bytes = ms.GetBuffer();
                }
            }
            unsafe
            {
                float fx = 125.5f;
                int* pfx = (int*)(&fx);
            }

        }

        #endregion
        #region 位移运算
        static void TestBitShift()
        {   //----------------------------------------------------------------------------
            //十进制数转二进制：
            //1，原理：将数X右移1位，最低位被移出，再左移，得到了数X0，则x-x0即为最低位的值
            //2，手工算法：根据1的原理，不断的对一个数整除2得余数，了终得到余数序列即是二进制的反向序列
            //3，左移等价于乘2，右移等价于除2，原理是乘法的竖式算法,
            //  101
            //x 010
            //-------           竖式算法适用于任何进制的加减法和乘法运算
            //  000
            //+101
            //-------
            // 1010
            //----------------------------------------------------------------------------

            int x = 7;
            List<Byte> bits = new List<Byte>(4);
            while (x != 0)
            {
                var left = x - ((x >> 1) << 1);//<=> x - x/2*2
                bits.Add((byte)left);
                x = x >> 1;
            }
        }
        #endregion
        #region IEnumerableAndLinQ
        class Product
        {
            public int cateId;
            public string name;
        }
        class Category
        {
            public int id;
            public string name;
        }
        public static void TestIEnumerableAndLinq()
        {
            Category[] cates = new Category[]
            {
                new Category{id = 1, name = "水果"},
                new Category{id = 2, name = "饮料"},
                new Category{id = 3, name = "糕点"},
            };

            Product[] products = new Product[]
            {
                new Product{cateId=1, name = "apple"},
                new Product{cateId=1, name = "banana"},
                new Product{cateId=1, name = "pear/梨"},
                new Product{cateId=1, name = "grape/葡萄"},
                new Product{cateId=1, name = "pineapple/菠萝"},
                new Product{cateId=1, name = "watermelon/西瓜"},
                new Product{cateId=1, name = "lemon/柠檬"},
                new Product{cateId=1, name = "mango/芒果"},
                new Product{cateId=1, name = "strawberry/草莓"},
                new Product{cateId=2, name = "bear/啤酒"},
                new Product{cateId=2, name = "wine"},
                new Product{cateId=3, name = "cake"},
                new Product{cateId=3, name = "basicuit/饼干"},

            };
            var rets = cates.Where((x) => { return x.id > 1 && x.id < 5; });
            var iter = rets.GetEnumerator();

            while (iter.MoveNext())
            {
                //WriteLine(iter.Current);
            }

            var set = from c in cates

                          //这里只能写一个条件，就是equals，用来关联两个表
                          //并且 c相关的条件只能写在equals左边，p相关条件只能写equals右边
                      join p in products on c.id equals p.cateId

                      //这里存放的是 products中的元素合集，而不是cates中的元素合集
                      //如果 from p in products join c in cates on c.id equals p.id into xgroups
                      //则xgroups中放的是cates中的元素集合

                      //这里是说将products中cateId等于c.id的所有元素放入一个组xgroups中
                      into xgroups
                      orderby c.id descending //对set中的结果进行降序排列

                      //where m > 4 && m < 10 //这里就可以写多个条件了

                      //from in 相当于外层循环，join in 相当于内层循环
                      //select在双层循环体中，每执行一次循环，【如果符合条件】，则执行一次结果选择
                      //双层循环完成后，最终将很多条选择提交给set
                      //【注意，如果不符合条件 select不会执行】
                      select new { cate = c.name, grp = xgroups }; //可以生成一个新的对象

            foreach (var p in set)
            {
                WriteLine("分组:" + p.cate);
                foreach (var g in p.grp)
                {
                    WriteLine(g.cateId + "," + g.name);
                }
            }
        }

        #endregion
        #region 类和继承
        class CTestX
        {
            public virtual void OnUpdate()
            {
                Console.WriteLine("base-on-update");
            }
            public virtual void OnUpdate2()
            {
                Console.WriteLine("base-on-update2");
            }
            public void Update()
            {
                this.OnUpdate(); //注释1，如果子类有overide则调用子类的，否则调用自己的
            }

            public CTestX()
            {

            }
            protected CTestX(float fx)
            {
                WriteLine("CTestX");
            }

            ~CTestX()
            {
                WriteLine("~Ctestx");
            }
            public float fx;
            string name;
        }

        //子类不能访问基类任何私有的东西，包括方法，字段，属性，但它们都被继承了，属于子类，从实例内存可证
        //方法包括构造函数，即当基类是私有构造函数时，子类无法在初始化列表中调用base()来初始化
        class CTestChildX : CTestX
        {
            CTestX otestx;

            public CTestChildX() : base(1)//当基类为私有构造时，这里base无法调用
            {//当基类没有无参构造函数时，必须在初始化列表中初始化所有成员对象，如otestx
                WriteLine("CTestChildX");
            }

            //注意overide与virtual的区别：
            //1，overide : 表明【函数是对基类的重写】 且 【本身是虚函数可被子类重写】
            //【函数会与基类、子类发生虚函数机制】
            //2，virtual : 仅表明函数是个虚函数，不会与基类发生虚函数机制
            //如果子类overide了该函数，则会与子类发生虚函数机制
            //3，多级继承中只要有一级没override，虚函数机制就会打断在此层级,见

            //override在编译层的机制是重写虚函数表中的函数地址
            //即将继承而来的虚函数表中的虚函数地址替换成本类的虚函数地址
            public static void TestDerive()
            {
                //                 CTestX ox = new CTestChildX();
                //                 ox.OnUpdate(); //base-on-update，无虚函数机制发生
                //                 ox.OnUpdate2(); //child-on-update2，虚函数机制发生
                //                 ox = new CTestY();
                //                 ox.OnUpdate(); //base-on-update，无虚函数机制发生
                CTestChildX ocx = new CTestZ();
                ocx.OnUpdate(); //grand-child-on-update
            }

            public override void OnUpdate()
            {
                Console.WriteLine("child-on-update");
            }
            public override void OnUpdate2()
            {
                Console.WriteLine("child-on-update2");
            }

            ~CTestChildX() //不支持virtual
            {
                WriteLine("~CTestChildX");
            }
        }

        class CTestY : CTestChildX
        {
            public override void OnUpdate()
            {
                Console.WriteLine("grand-child-on-update");

            }
        }
        class CTestZ : CTestY
        {
            //因为这里的Update不是虚函数，因此
            public void OnUpdate()
            {
                Console.WriteLine("grand-grand-child-on-update");

            }
        }


        struct CTX
        {
            void Test() {//不支持C++的const语法
            }
        }

        //1，不能继承结构，可以实现接口，
        //2，不能有虚函数
        struct CCTX //: CTX 
        {
            public void Test()
            {

            }
        }

        #endregion
        #region 字符串格式化
        static void TestStrFormat()
        {
            var str = Console.ReadLine();
            while (str != "exit")
            {
                int ix;
                Int32.TryParse(str, out ix); //ix = 120
                var f1 = string.Format("{0 :d5}", ix); //"00120"
                var f2 = string.Format("{0,-10:d5}", ix);//"00120     "
                var f3 = string.Format("{0:x}", ix); //16进制输出到字符串
                var f4 = string.Format("{0:0.000}", ix);//浮点数 120.000
                Console.WriteLine("-----------begin-------------");
                Console.WriteLine(f1);
                Console.WriteLine(f2);
                Console.WriteLine(f3);
                Console.WriteLine(f4);
                Console.WriteLine("------------end-------------");

                str = Console.ReadLine();
            }
        }
        #endregion
        #endregion

        #region 2018.7.25
        #region 引用返回值（不是右值引用）
        static int[] _bookNum = new int[] { 1, 2, 3, 4, 5, 6 };
        static ref int GetBookNumber(int i)
        {
            int x = 10;
            return ref _bookNum[i];
        }
        static void TestRefReturn()
        {
            ref int rfn = ref GetBookNumber(1);
            rfn = 10101; //_bookNum[1]变成了 10101
            int vn = GetBookNumber(2);
            vn = 202; //_bookNum[2]未变，仍为3

            ref int x = ref vn;
        }
        #endregion
        #region 索引器
        class mylist<T>
        {
            const int defaultCap = 4;
            T[] items;
            int count;
            int cap = defaultCap;
            public mylist(int cap = defaultCap)
            {
                if (cap != defaultCap)
                    this.cap = cap;
                items = new T[cap];
            }
            public T this[int idx] {
                set {
                    items[idx] = value;
                }
                get {
                    return items[idx];
                }
            }

        }
        enum Color
        {
            red,
            green,
            blue,
            yellow,
            cyan,
            purple,
            black,
            white,
        }

        static void TestIndexer(Color clr = Color.black)
        {
            mylist<string> lst = new mylist<string>();
            lst[1] = "hello";
        }
        #endregion
        #region 部分类
        //部分类的作用是可以把一个庞大的类拆分到多个文件，每个文件实现一部分
        //而不是实现像C++那样将声明与实现分开
        //若要实现声明（接口）与实现分开，应该使用抽象类或接口
        partial class CPartclass
        {
            public void ShowName() {
                WriteLine("show name");
            }
        }

        partial class CPartclass
        {
            public void ShowAge(){
                WriteLine("show age");
            }
        }
        static void TestPartclass()
        {
            CPartclass opc = new CPartclass();
            opc.ShowName();
            opc.ShowAge();
        }
        #endregion
        #region 动态分配对象数组C#与C++的区别
        struct xobject 
        {
            public float fx, fy, fz; //全是public的
        }
        static void TestDynamicAllocInCSharpCpp()
        {
            //1，对于引用类型数组，需要两步才能完成，因为数组中存放的是对象的引用
            //1.1 c#中
            xobject[] arr = new xobject[2];//这时候，只是分配了一个引用数组,arr[0],arr[1]均为null
            for (int i = 0; i < 2 ; i++)
            {
                arr[i] = new xobject(); //为数组中每个引用申请对象
            }

            //1.2 c++中
            //xobject** pp = new xobject*[2];
            //pp[0] = new xobject();
            //pp[1] = new xobject();

            //2 对于值类型数组，则只需一步，因为数组中放的就是值，这在C#与CPP中都一样
            //2.1 C#中
            int[] iarr = new int[2];
            var a0 = iarr[0]; //0
            var a1 = iarr[1]; //0

            xobject[] varr = new xobject[3];
            varr[0].fx = 0.1f;
            varr[1].fy = 2.5f;
            varr[2].fz = 12;

            //2.2，在C++中
            //xobject* pobjs = new xobject[2]; //每个数组元素都是一个值类型对象
            //pobjs[0].fx = 20;
        }
        #endregion
        #region Object?语法
        static void TestobjAsk()
        {
            object obj = "hello";
            WriteLine(obj?.ToString());//如果obj不为null则调用tostring
        }
        #endregion
        #region C#默认字符编码及系统默认编码
        //默认编码为unicode，字符串本身的编码并不重要，字节读写时指定的编码才重要，如下面的BinaryWriter
        //Encoding.Default是当前系统的默认编码，并不是c#字符串的默认编码
        //Encoding.Default规则：汉字2字节，其它1字节
        static void TestDefaultStrEncoding()
        {
            string str = "hdd好";
            
            using (var ms = new MemoryStream())
            {
                using (var br = new BinaryWriter(ms, Encoding.Default))
                {
                    br.Write(str);
                    var len = ms.Length-1;
                    WriteLine(len);

                }
            }
        }
        #endregion
        #region 属性attribute和反射
        class ReflectableClass
        {
            public float fx;
            public string str;
            //static const int x = 20; //这在C++中是可以的
            public void Printstr(string str, int idx)
            {
                WriteLine(str + ":" + idx);
            }
        }
        static void TestReflect()
        {
            
            ReflectableClass ox = new ReflectableClass();
            Type t = typeof(ReflectableClass);//Type.GetType("ConsoleApplication1.Program.ReflectableClass");//ox.GetType();
            var tname = t.GetField("name");
            var tfx = t.GetField("fx");
            var func = t.GetMethod("Printstr", new Type[] {typeof(string),typeof(int) });
            func.Invoke(ox, new object[] { "helloworld", 1 });

            
            Type Ts = Type.GetType("System.String");
            var fs = Ts.GetMethod("Substring", new Type[] { typeof(int), typeof(int) });
            var subs = fs.Invoke("hello world", new object[] { 1, 5 });
            WriteLine(subs);
        }

        static void TestAttribute()
        {

        }

        #endregion
        #endregion
        #region JSON
        void TestJson()
        {

        }

        #endregion
        #region CPP与CS间数据传递转换

        #endregion
        #region 线程
        #endregion
        #region 线程池
        #endregion
        #region 任务
        #endregion
        #region 程序集
        #endregion
        #region 多线程调试
        #endregion
#region 扩展方法测试
        static void TestExtMethod()
        {
            ExtTargetCls oet = new ExtTargetCls();
            oet.methodExt(100);
            WriteLine(oet.sum);
        }
        #endregion
        class CMyList
        {
            //readonly仅表示变量本身不能被赋值，但不阻止通过对象变量更改对象内的字段
            //on._id = 100 //ok
            //on = new CNormclass() //error

            public readonly int[] rarr = { 1, 2, 3, 4 };
            public readonly int rix = 30; //可在初始化时赋值
            public readonly CNormclass on = new CNormclass();
            public CMyList()
            {
                rix = 1; //可在构造函数中赋值
            }
            public int[] toArray()
            {
                return rarr;
            }

            public void Clear()
            {
                for(var i=0; i < rarr.Length; ++i)
                {
                    rarr[i] = 0;
                }
            }
            public static implicit operator CMyList(int ix)
            {
                return new CMyList();
            }

        }

        // ctrl + w, t 可以察看所有待做任务
        static void Main(string[] args)
        {
            TestExtMethod();
            //TestReflect();
            //TestDefaultStrEncoding();
            //TestDynamicAllocInCSharpCpp();
            //TestPartclass();
            //TestRefReturn();
            //TestOperatorOverload();
            //    CTestChildX.TestDerive();
            //TestFloat();

            //var arr = returnArray();
 
        }

    }
    #region 扩展方法
    sealed class ExtTargetCls
    {
        public float sum = 10;
    }
    //扩展方法必须在顶级静态类中定义，不能是内部类
    //能不能通过扩展方法来修改类库以达到不法目的？ 不能，因为扩展方法只能修改类的公有成员
    static class ExtentMethod
    {
        public static void methodExt(this ExtTargetCls target, float add)
        {
            target.sum += add;
        }
    }
    #endregion
}