1. hello world

    //打印语句
    console.writeline("hello world");
    //暂停
    console.readkey();
   

2. 数据类型
   1.值类型 byte,char,short,int,long,bool,decimal,float,double,sbyte,uint,ulong,ushort
   2.引用类型: 储存的不是值实际数据而是一个内存地址 object、dynamic 和 string。
   3.对象类型:object 类型检查是在编译时发生的
   4.动态类型: 可以存储任何类型的值在动态数据类型变量中,类型检查在运行时
   5.字符串（string）类型
   6.指针类型（pointer types）

3. 类型转换

   1. 隐式转换
   2. 显式转换
   3. toxxx方法

4. 变量

5. 常量

   1. 整数常量
      • 整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0x 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。
      • 整数常量也可以带一个后缀，后缀是 u 和 l 的组合，u 表示无符号整数（unsigned），l 表示长整数（long）。后缀可以是大写，也可以是小写，u 和 l 的顺序任意。
   2. 浮点常量(小数必须包含整数)
   3. 字符常量
   4. 字符串常量
   5. 定义常量

6. 运算符

   1. 算数运算符
   2. 关系运算符
   3. 逻辑运算符
   4. 位运算符
   5. 赋值运算符
   6. 其他运算符
      1. sizeof():数据类型的大小
      2. typeof():返回 class的类型。
      3. &: 返回变量的地址
      4. *:变量的指针
      5. ?: :三元表达式
      6. is:判断对象是否为某一类型
      7. as: 强制转换,即使失败也不会抛出异常

7. 判断:

   1. if
   2. switch

8. 循环:

   1. while循环
   2. for/foreach
   3. do…while

9. 封装:

   1. public:允许一个类将其成员变量和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问
   2. private:允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。
   3. protected:该类内部和继承类中可以访问。
   4. internal:同一个程序集的对象可以访问。
   5. protected internal:3 和 4 的并集，符合任意一条都可以访问。

10. 可空类型

    • //默认值为0
      int a;
      //默认值为null
      int? b=123;
      //如果b为null就赋值2否则c=b
      int c=  b?? 2;
      console.writeline("c的值为{0}", c);
      console.readline();
      

11. 数组

    //初始化数组逐个赋值
    int[] arr = new int[10];
    arr[0] = 12312;
    //初始化数组并赋值
    int[] arr1 = { 321, 312, 12312, 12312312, 12312312 };
    //使用for循环赋值
    for (int i = 0; i < 10; i++)
    {
    arr[i] = i + 100;
    }
    //使用foreach取值
    foreach (int i in arr)
    {
    console.writeline("元素的值为{0}", i);
    }
    

12. 结构体

    struct books{
    public string id;
    public string name;
    public string price;
    }
    static void main()
    {
    books book1;
    book1.id = "123";
    book1.name = "aaa";
    book1.price = "23131";
    console.writeline("书信息:书id{0},书名{1},书价格{2}",book1.id,book1.name,book1.price);
    console.readline();
    }
    

    • 类与结构的不同点
      1. 类是引用类型,结构是值类型
      2. 结构不支持继承
      3. 结构不能声明默认的构造函数
      4. 结构体中无法实例属性或赋初始值
    • 类与结构的选择
      1. 当我们描述一个轻量级对象的时候，结构可提高效率，成本更低。数据保存在栈中,访问速度快
      2. 当堆栈的空间很有限，且有大量的逻辑对象或者表现抽象和多等级的对象层次时，创建类要比创建结构好一些；

13. 枚举

    //枚举列表中的每个符号代表一个整数值，一个比它前面的符号大的整数值,可自定义每个符号
    enum days { sun, mon, tue, wed, thu, fri, sat };
    static void enum()
    {
    int a = (int)days.wed;
    console.writeline(a);
    console.readline();
    }
    

14. 析构函数

    class test
    {
        string id;
        public test()
        {
            console.writeline("构造函数");
        }
        ~test()
        {
            console.writeline("析构函数");
        }
        static void main()
        {
            test test = new test { id = "123" };
            console.writeline("id为{0}", test.id);
            console.readline();
        }
    
    }
    

15. 多态性

    1. 通过在类定义前面放置关键字 sealed，可以将类声明为密封类。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。
    2. 当有一个定义在类中的函数需要在继承类中实现时，可以使用虚方法。虚方法是使用关键字 virtual 声明的。虚方法可以在不同的继承类中有不同的实现。

16. 运算符的重载

    class test2
        {
            public int length;
            //运算符重载  
            public static test2 operator +(test2 a, test2 b)
            {
                test2 test = new test2 { length = a.length - b.length };
                return test;
            }
            static void main(string[] args)
            {
                test2 test = new test2 { length = 12 };
                test2 test1 = new test2 { length = 213 };
                test2 t = test + test1;
                console.writeline("t的值{0}", t.length);
                console.readline();
            }
        }
    

17. 预处理器指令

    1. define 预处理器

    2. 条件指令

18. 异常处理

    1. try catch finally
    2. 常见异常:
       1. io异常
       2. 空对象
       3. 类型转换
       4. 除以0

19. 文件的输入与输出

     //字节流读取文件
     static void main(string[] args)
     {
     streamreader streamreader =new streamreader(@"d:\document\test.txt");
     string line;
     //读取文件内容
     while ((line = streamreader.readline()) != null)
     {
     //打印出来
     console.writeline(line);
     }
     console.readline();
     }
    

20. windows文件系统操作

     static void main(string[] args) {
            getfile(@"d:\programfiles");
            console.readline();
        }
        //获得某文件夹下的文件名与大小
        static void getfile(string path) {
            directoryinfo directoryinfo = new directoryinfo(path);
            directoryinfo[] directoryinfo1 = directoryinfo.getdirectories();
            fileinfo[] files = directoryinfo.getfiles();
            if(directoryinfo1!=null) {
                foreach(directoryinfo directoryinfo2 in directoryinfo1) {
                    if(directoryinfo2.name!="app") {
                        getfile(path+@"\"+directoryinfo2.name);
                    }
                }
            }
            if(files!=null) {
                foreach(fileinfo file in files) {
                    console.writeline("文件名:{0},文件大小{1}",file.name,file.length);
                }
            }
        }
    

21. 特性

    1. 预定义特性
       1.attributeusage
       2.conditional
       3.obsolete: [obsolete("过时了")]编译器会给出警告信息[obsolete("过时了",true)]编译器会给出错误信息

    2. 自定义特性

22. 委托

    delegate void consolewrite1();
    namespace consoleapp1 {
        class program {
    
            static void main(string[] args) {
                consolewrite1 consolewrite1 = new consolewrite1(consolewrite);
                consolewrite1();
                console.readline();
            }
            static void consolewrite() {
                console.writeline("测试");
            }
    

    • 委托的用途

               static filestream fs;
        static streamwriter sw;
        // 委托声明
        public delegate void printstring(string s);
      
        // 该方法打印到控制台
        public static void writetoscreen(string str) {
            console.writeline("the string is: {0}",str);
        }
        // 该方法打印到文件
        public static void writetofile(string s) {
            fs=new filestream(@"d:\document\test.txt",
            filemode.append,fileaccess.write);
            sw=new streamwriter(fs);
            sw.writeline(s);
            sw.flush();
            sw.close();
            fs.close();
        }
        // 该方法把委托作为参数，并使用它调用方法
        public static void sendstring(printstring ps) {
            ps("hello world");
        }
        static void main(string[] args) {
            printstring ps1 = new printstring(writetoscreen);
            printstring ps2 = new printstring(writetofile);
            sendstring(ps1);
            sendstring(ps2);
            console.readkey();
        }
      

23. 1. 指针变量

        static unsafe void test12() {
        int i = 0;
        int* p = &i;
        console.writeline("i的值为{0},内存地址为{1}",i,(int)p);
        console.writeline();
        }
       

    2. 传递指针作为方法的参数

            static unsafe void main() {
            int var1 = 10;
            int var2 = 20;
            console.writeline("var1:{0},var2:{1}",var1,var2);
            int* a = &var1;
            int* b = &var2;
            swap(a,b);
            console.writeline("var1:{0},var2:{1}",var1,var2);
            console.readline();
        }
        static unsafe void swap(int* a,int* b) {
            int temp =*a;
            *a=*b;
            *b=temp;
        }
       

    3. 使用指针访问数组元素

                 static unsafe void array() {
                        int[] list = { 10,100,200 };
                        fixed (int* ptr = list)
                          /* 显示指针中数组地址 */
                          for(int i = 0;i<3;i++) {
                              console.writeline("address of list[{0}]={1}",i,(int)(ptr+i));
                          console.writeline("value of list[{0}]={1}",i,*(ptr+i));
                }
                  console.readkey();
       

24. out参数:一个方法返回多个不同类型的参数

      static void main() {
           string s="asd";
           int i=test7(out s);
           console.writeline(s);
           console.writeline(i);
           console.readline();
    
       }
    
       public static int test7(out string a) {
           a="asddddddddddd";
           return 1;
       }
    

25. params参数

     static void main() {
            params(213,31231,12312,13231,123,1312,312,312,321,3,12,312,12);
        }
        static void params(params int[] array) {
            int max = array[0];
            for(int i = 0;i<array.length;i++) {
                if(array[i]>max) {
                    max=array[i];
                }
            }
            console.writeline("最大值为{0}",max);
            console.readline();
        }
    

26. ref参数

    static void main() {
            int i = 30;
            ref(ref i);
            console.writeline(i);
            console.readkey();
        }
        static void ref(ref int a) {
            a+=500;
        }
    

27. 连接数据库

        static void mysqlconnection() {
            //配置连接信息
            string connstr = "server=localhost;port=3306;user=root;password=123456;database=ztree";
            mysqlconnection mysqlconnection = new mysqlconnection(connstr);
            //打开连接
            mysqlconnection.open();
            //sql语句
            string sql = "select * from city";
            mysqlcommand mysqlcommand = new mysqlcommand(sql,mysqlconnection);
            //执行sql语句
            mysqldatareader mysqldatareader = mysqlcommand.executereader();
            while(mysqldatareader.read()) {
                if(mysqldatareader.hasrows) {
                    console.writeline("id:{0};name:{1};pid:{2}",mysqldatareader.getstring(0),mysqldatareader.getstring(1),mysqldatareader.getstring(2));
                }
            }
            mysqlconnection.close();
        }
    

​