基础加强

一  面向对象
-->概念：
   01，面向对象的编程是基于现实世界而产生的，是运用编程技术来解释现实世界。现实世界中对象比比皆是。可以说“一切皆对象”。而每个对象都归属于某个类，如桌子、椅子归属为家具，汽车归属为交通工具等。
　　02，对象是不能脱离类存在的。类是一组拥有共同特性的对象的描述，由对象归纳为类，对象是类的具体体现。如汽车属于一个类，而具体到你的车，我的车就都是对象。
　　03，在不同的情况下，我们思考的角度不同，分类的标准不同，对象也是不同的。在编程中，针对不同的需求，对象也是变化的。
　　04，C#中，所有的东西都可以看成是对象。
       面向对象是一种思考方式，面向过程是解决问题的步骤，面向对象是解决方案。
-->面向对象的好处：
   01，良好的可复用性，开发同类项目的次数与开发新项目的时间成反比，减少重复劳动
   02，易维护，基本上不用花太大的精力跟维护人员讲解，他们可以自己读懂源程序并修改，否则开发的系统越多，负担就越重。
   03，良好的可扩充性，以前，在向一个用结构化思想设计的庞大系统中加一个功能则必须考虑兼容前面的数据结构，理顺原来的设计思路。即使客户愿意花钱修改，作为开发人员多少都有点儿恐惧。
      在向一个用面向对象思想设计的系统中加入新功能，不外乎是加入一些新的类，基本上不用修改原来的东西。
-->三大特征：
      封装：属性，构造方法->隐藏内部实现，稳定外部接口，隐藏代码实现，代码复用，修改方便。
      继承：子类继承父类成员，实现代码复用，单根性，传递性，object基类
      多态：不同子类对同一个消息做出不同的反应
-->类与对象：
       类是模型，对象是产品
       类的成员：字段，属性和方法（事件，委托等）
       C#中的继承是单一继承，继承的目的是代码的复用
-->面向对象的实现：
       现实中都是具体到抽象的过程；
       创造是从抽象到具体：首先是有图纸->再有具体的对象；
       面向对象或者可以说是找一个人帮你做事。
二 流程控制
判断 if if-else if-else-if 特点：逐级判断
switch case特点：直接匹配，每一个条件后面都必须有一个break，
后面直接跟return语句这两句情况下不需要加break
例子：
switch(oper)
{
    case "+":result=num1+num2;break;
    case "-":result=num1-num2;break;
    case "*":result=num1*num2;break;
    case "/":result=bum1/num2;break;
}
循环：
注：跟下标无关的循环 多半使用while或do-while循环，跟下标有关的
while循环
语法：
while（循环条件）
{
     循环体
}
do-while循环
语法：
do
{
     循环体
}
while(条件);
for循环
语法：
for(int i=0;i<范围;i++)
{
     直接使用i
}
froeach循环
跳转语句：
break跳出，不再执行后面的循环
continue跳出本次循环，继续下一次循环只是这一次结束了
goto(普遍禁用)
return结束整个方法
例子：
static void Test()
{
     for(int i=0;i<10;i++)
     {
         for(int j=0;j<10;j++)
         {
             break;//退出当前循环
             continue;//退出本次循环
             Console.WriteLine("如果遇到continue就不执行了");
         }
     }
}
三 三元表达式
    //凡是if-else结构中为同一个变量赋值时可以使用三元表达式
    //语法：bool表达式?bool表达式为true:boo表达式为false
    class Program
    {
        static void Main(string[] args)
        {
            //打印出较大的数
            int maxNum = GetMax(50, 20);
            Console.WriteLine(maxNum);
            Console.ReadKey();
        }
 
        private static int GetMax(int p1, int p2)
        {
            int maxNum = 0;
            maxNum = p1 > p2 ? p1 : p2;
            return maxNum;
        }
    }
四 反射
namespace _01反射
{
    /*定义：有些东西在运行的时候，需要使用一些程序集，但是在没有在编译的时候添加。事先
     * 没有定好的，动态的加载进来，这样的一种技术叫反射
     * 通俗的定义，反射就是在指定的时候将dll文件当做“二进制”文件来读取（当然，读
     * 二进制会乱码，只是打个比方），得到里面的类型信息，然后动态的创建对象，并执行方法
     */
 
    #region 01用对象来得到类型的信息
    class MyClass
    {
        public void Func()
        {
 
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass m = new MyClass();
            Type type = typeof(MyClass);
            MethodInfo[] methods = type.GetMethods();
            for (int i = 0; i < methods.Length; i++)
            {
                Console.WriteLine(methods[i].Name);
            }
            Console.ReadKey();
        }
    }
    #endregion
 
    #region 02动态调用已知类型信息
    class MyClass
    {
        public void Func()
        {
            Console.WriteLine("调用了");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass m = new MyClass();
            Type t = typeof(MyClass);
            MethodInfo method = t.GetMethod("Func");
            method.Invoke(m, null);
            Console.ReadKey();
        }
    }
    #endregion
 
    #region 03调用已知类型的信息+
    class MyClass
    {
        public void Func(int num)
        {
            Console.WriteLine(num);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Type t = typeof(MyClass);
            object o = Activator.CreateInstance(t);
            MethodInfo m = t.GetMethod("Func", new Type[] { typeof(int) });
            m.Invoke(o, new object[] { 100 });
            Console.ReadKey();
        }
    }
    #endregion
 
    #region 03在三层中通过泛型和反射将数据库中获得的信息转换为需要的类型
    class Common
    {
        public static T GetFromReader<T>(SQLiteDataReader reader)
        {
            Type t = typeof(T);
            object o = Activator.CreateInstance(t);
            for (int i = 0; i < reader.FieldCount; i++)
            {
                string name = reader.GetName(i);
                PropertyInfo p = t.GetProperty(name, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public);
                if (!reader.IsDBNull(i))
                {
                    p.SetValue(o, reader[i], null);
                }
            }
            return (T)o;
        }
    }
    #endregion
}
 五 泛型
namespace _02泛型
{
    /*泛型使得设计如下类和方法称为可能：这些类和方法将一个或多个类型的指定推迟到客户端代码声明
     * 并实例化该类或方法的时候。例如，通过使用泛型类型参数T，可以编写其他客户端代码能够使用的
     * 单个类，而不至引入运行时轻质转换或装箱操作的成本风险。
     * 使用泛型类型可以最大限度的重用代码，保护类型的安全以及提高性能。
     * 泛型最常见的用途是创建集合类。
     * 可以创建 泛型接口，泛型类，泛型方法，泛型事件和泛型委托
     * 关于泛型数据类型中使用的类型的信息可以在运行时通过反射获取。
     */
    #region 01泛型约束
    class Test<T>
    {
        public void T1(T t)
        { }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Test<string> t = new Test<string>();
            t.T1("555");//里面的参数就变成了string类型--泛型用来约束类型
        }
    }
    #endregion
 
    #region 02泛型委托一
    delegate int DelCompare<T>(T t1, T t2);
    class Program
    {
        static void Main(string[] args)
        {
            string[] array = { "af", "ds", "gh", "hj" };
            string max = GetMax<string>(array, CompareString);
            Console.WriteLine(max);
            Console.Read();
        }
        static int CompareString(string s1, string s2)
        {
            return s1.Length - s2.Length;
        }
        static T GetMax<T>(T[] arry, DelCompare<T> del)
        {
            T max = arry[0];
            for (int i = 0; i < arry.Length; i++)
            {
                if (del(max, arry[i]) < 0)
                {
                    max = arry[i];
                }
            }
            return max;
        }
    }
    #endregion
 
    #region 03泛型委托二
    delegate int DelCompare<T>(T t1, T t2);
    class Program
    {
        static void Main(string[] args)
        {
            Person[] persons ={
                             new Person(){Name="jk",Age=18},
                             new Person(){Name="df",Age=15},
                             new Person(){Name="er",Age=20},
                             new Person(){Name="ge",Age=19},
                             };
            Person max = GetMax<Person>(persons, ComparePerson);
            Console.WriteLine(max.Name);
            Console.Read();
        }
        static int ComparePerson(Person p1, Person p2)
        {
            return p1.Age - p2.Age;
        }
        static T GetMax<T>(T[] arry, DelCompare<T> del)
        {
            T max = arry[0];
            for (int i = 0; i < arry.Length; i++)
            {
                if (del(max, arry[i]) < 0)
                {
                    max = arry[i];
                }
            }
            return max;
        }
    }
    class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    #endregion
}

五 扩展方法
namespace _03扩展方法
{
    /*扩展方法：
     * 方法中带有向下小箭头的方法
     * 语法
     * 静态类与静态方法
     * 方法第一个蚕食为对象参数
     * 写方法记住一个例子就不会忘记咯==但是少用扩展方法
     */
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入Email");
            string str = Console.ReadLine();
            try
            {
                if (str.IsEmail().IsQQEmail().IsRange(6, 8))
                {
                    Console.WriteLine("OK");
                }
                else
                {
                    Console.WriteLine("error");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.ReadKey();
            Console.ReadKey();
        }
        /// <summary>
        /// 一般方法实现Email校验
        /// </summary>
        static void TestEmail1()
        {
            Console.WriteLine("请输入Email;");
            string str = Console.ReadLine();
            string regex = @"^\w+@\w+(\.\w+)+$";
            if (Regex.IsMatch(str, regex))
            {
                Console.WriteLine("输入正确");
            }
            else
            {
                Console.WriteLine("不是Email");
            }
        }
    }
 
    /// <summary>
    /// 一个为了扩展方法校验邮箱写的静态类
    /// </summary>
    static class DJTest
    {
           /*扩展方法：
            * 写一个静态类
            * 提供一个静态方法作为扩展方法
            * 方法的第一个参数要求是调用该方法的类型
            * 参数前加上this关键字
            * 其余参数随意，和定义其他方法一样
            */
 
        public static string IsEmail(this string t)
        {
            if (Regex.IsMatch(t, @"\w+@\w+(\.\w+)+"))
            {
                return t;
            }
            else
            {
                throw new Exception("不是Email");
            }
        }
 
        public static string IsQQEmail(this string t)
        {
            if (Regex.IsMatch(t, @"qq.com$"))
            {
                return t;
            }
            else
            {
                throw new Exception("不是QQEmail");
            }
        }
 
        public static bool IsRange(this string t, int min, int max)
        {
            if (Regex.IsMatch(t, string.Format(@"^\d{{{0},{1}}}@", min, max)))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
}
六 类型推断与匿名类型_var
    /*var可以代表任意的类型
     * var还可以是一种匿名类型
     * 匿名类型在执行的时候，用神器可以看出来，系统内部还是自动创建了一个Person类的文件
     */
    class Program
    {
        static void Main(string[] args)
        {
            #region 01例子一
            int num = 10;
            string str = "10";
 
            var isTrue = false;
            var dNum = 10.01;
            var ch = ‘c‘;
 
            Console.WriteLine("" + isTrue + dNum + ch);
 
            foreach (var item in new int[] { 1, 2, 4, 512, 5 })
            {
                Console.WriteLine(item + 1);
            }
            Console.ReadKey();
            #endregion
            //匿名类型的定义语法：var 变量名= new {罗列字段=值};
            //申明一个匿名类型：
            var p1 = new { Name = temp[0], Age = Convert.ToInt32(temp[1]), Gender = temp[2] }
 
            #region 用匿名类型读取数据的例子
            string[] lines = File.ReadAllLines("data.txt", Encoding.Default);
            string[] temp = lines[0].Split(‘|‘);
            var p1 = new { Name = temp[0], Age = Convert.ToInt32(temp[1]), Gender = temp[2] };
            Console.WriteLine("我叫{0}，今年{1}岁，我是{2}生", p1.Name, p1.Age, p1.Gender);
            Console.ReadKey();
            #endregion
        }
    }
 
七 匿名方法与Lambda表达式
#region 01例子一
    delegate void MyDelegate();
    class Program
    {
        static void Main(string[] args)
        {
            //匿名方法的概念
            MyDelegate MyFunc = delegate ()
            {
                Console.WriteLine("我是一个没有参数的方法");
            };
            MyFunc();
        }
    }
    #endregion
 
    #region 02例子二
    delegate void MyDelegate(int n, int m);
    class Program
    {
        static void Main(string[] args)
        {
            MyDelegate MyFunc = delegate (int x, int y)
            {
                Console.WriteLine("{0}+{1}={2}", x, y, x + y);
            };
            MyFunc(100, 20);
            Console.ReadKey();
        }
    }
    #endregion
 
    #region Lambda表达式
    delegate void MyDelegate(int n, int m);
    class Program
    {
        static void Main(string[] args)
        {
            //匿名方法的概念
            MyDelegate MyFunc = delegate (int x, int y)
            {
                Console.WriteLine("{0}+{1}+{2}", x, y, x + y);
            };
 
            //Lambda表达式
            //语法（goes to）
            //()=>语句
            MyDelegate MyFunc = (x, y) =>
            {
                Console.WriteLine("{0}+{1}={2}", x, y, x + y);
                Console.WriteLine("你好");
                Console.WriteLine("我好");
                Console.WriteLine("大家好");
            };
            MyFunc(100, 20);
            Console.ReadKey();
        }
    }
    #endregion
八 冒泡排序
    class Program
    {
        static void Main(string[] args)
        {
            #region 01
            int[] nums = { 1, 23, 4, 5, 6, 8, 5, 2, 2, 6 };
            for (int i = 0; i < nums.Length - 1; i++)
            {
                for (int j = 0; j < nums.Length - 1 - i; j++)
                {
                    if (nums[j] > nums[j + 1])
                    {
                        int temp = nums[j];
                        nums[j] = nums[j + 1];
                        nums[j + 1] = temp;
                    }
                }
            }
            #endregion
 
            string[] strs ={
                          "jkajfkjall",
                          "ajakjfkljaklafjkajklf;jal",
                          "jkjaj",
                          "545",
                          "aijjak"
                          };
        }
        public static void SortWithLength(string[] array)
        {
            for (int i = 0; i < array.Length - 1; i++)
            {
                for (int j = 0; j < array.Length - 1 - i; j++)
                {
                    if (array[j].Length > array[j + 1].Length)
                    {
                        string temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
 
        public static void SortWithDic(string[] array)
        {
            for (int i = 0; i < array.Length - 1; i++)
            {
                for (int j = 0; j < array.Length - 1 - i; j++)
                {
                    if (string.Compare(array[j], array[j + 1]) > 0)
                    {
                        string temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
        }
    }
九 File和Directory
    /*File和Directory对文件与目录操作做了一个封装
     * 增 创建文件或文件夹 Create
     * 删 删除文件或文件夹 Delete
     * 改 改名字           ？
     * 查 获取             Get。。。
     * 盘存                Exsit
     * 移动                Move
     * 复制                Copy
     */
    class Program
    {
        static void Main(string[] args)
        {
            if (!File.Exists("mps.mp3"))
            {
                File.Create("mp3.mp3").Dispose();
            }
            File.Delete("mp3.mp3");
            File.Move("1.txt", @"2\1.txt");
            File.Move("1.txt", "JK.txt");
            File.Copy("1.txt", "a.txt");
            //File有的方法，Directory都有
            //Directory的增与删的例子
            Directory.CreateDirectory("JK\\kj");
            Directory.Delete("JK", true);
            //一个创建文件夹的例子：
            if (!Directory.Exists("Source"))
            {
                Directory.CreateDirectory("Source");
            }
            string date = DateTime.Now.ToString("yyyyMMdd");
            if (!File.Exists(date + ".txt"))
            {
                File.Create(date + ".txt").Dispose();
            }
            //例子：用Directory得到文件夹下的子文件与子文件夹
            if (!Directory.Exists(@"D:\dir"))
            {
                Console.WriteLine("不存在文件夹");
                Console.ReadKey();
                return;
            }
            string[] dirs = Directory.GetDirectories(@"D:\dir");
            string[] files = Directory.GetFiles(@"D:\dir");
            for (int i = 0; i < dirs.Length; i++)
            {
                Console.WriteLine(dirs[i]);
            }
            foreach (string item in files)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
            //用Directory得到文件夹下的子文件与子文件夹，关于文件权限文件安全问题的处理
            string path = @"D:\System Volume Infomation";
            if (!Directory.Exists(path))
            {
                Console.WriteLine("不存在文件夹");
                Console.ReadKey();
                return;
            }
            try
            {
                string[] dirs1 = Directory.GetDirectories(path);
                string[] diles = Directory.GetFiles(path, "*.txt");
                for (int i = 0; i < dirs1.Length; i++)
                {
                    Console.WriteLine(dirs[i]);
                }
                foreach (string item in files)
                {
                    Console.WriteLine(item);
                }
            }
            catch
            {
           
            }
            //用Directory递归遍历文件夹中的所有成员
            string dir="";
            string[] dires2 = Directory.GetDirectories(dir);
            string[] files1 = Directory.GetFiles(dir);
            for (int i = 0; i < dires2.Length; i++)
            {
                Console.WriteLine(dires2[i]);
            }
            foreach (string item in files)
            {
                Console.WriteLine(item);
            }
        }
    }