C#基础之基础语法（一）

总目录

---

---

前言

本文主要供自身复习使用，主要内容就是将C#基础知识进行大纲式针对性的梳理。

---

一、C#简述

1 C#是什么？

C# 是由微软（Microsoft）开发的一个简单的、现代的、通用的、面向对象的编程语言。

2 .Net平台

• 1 .Net框架（.Net Framework）
  说到C#，那就必须说说.Net， C# 是 .Net 框架的一部分，且用于编写 .Net 应用程序。
  .Net Framework是一个平台，主要可以开发Windows 桌面程序和Web应用。.Net 框架由一个巨大的代码库组成，用于 C# 等客户端语言。

我们常见的.Net 框架的组件：

• 公共语言运行库（Common Language Runtime - CLR）
• .Net 框架类库（.Net Framework Class Library）
• 公共语言规范（Common Language Specification）
• 通用类型系统（Common Type System）
• 元数据（Metadata）和组件（Assemblies）
• Windows 窗体（Windows Forms）
• ASP.Net 和 ASP.Net AJAX
• ADO.Net
• Windows 工作流基础（Windows Workflow Foundation - WF）
• Windows 显示基础（Windows Presentation Foundation）
• Windows 通信基础（Windows Communication Foundation - WCF）
• LINQ

• 2 .Net Core
  .Net Core是微软继.Net Framework之后推出的可以跨平台的平台，可以用来创建运行在mac、Linux上的应用程序

• 3 .Net
  完成了对.Net Framework和.Net Core的整合，是一个全新的强大的跨平台的平台

3. C# 和.Net的关系

.net就像是大舞台，C#就是其中的一个演员，演员可以使用平台提供的话筒（wpf）,用来唱歌（创建应用程序）；也可以使用平台提供的舞池（web）跳舞（创建web应用），C#只可以在这个大舞台上展示，但是这个舞台除了可以提供C#这个演员展示，还可以提供C++、Visual Basic、Jscript、COBOL 等演员展示

4. 集成开发环境（IDE）

目前主要使用的是Visual Studio 2022 (VS)

二、控制台应用程序

控制台应用程序是C# 入门时，学习基础语法的最佳应用程序。

1. 常用代码

控制台应用程序是入门级的应用程序，一般常用的代码如下：

//输出
Console.Write();
//换行输出
Console.WriteLine();
//以上代码主要用于在控制台输出信息

//读取输入
Console.Read();
//读取当前行输入
Console.ReadLine();
//读取字符
Console.ReadKey();
//以上代码主要用于在控制读取输入的信息

//接受用户输入的字符串，以换行结束
string s=Console.ReadLine();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.注意事项

• 控制台应用程序代码需要以Console.ReadLine()或Console.ReadKey()等结束，否则代码走完，控制台的窗体就会关闭

三、基础语法

1.编写C#代码注意事项

• C#代码是区分大小写的
• 所有的语句和表达式必须以分号（;）结尾。

2.C#注释

• //表示单行注释
• /* */ 表示多行注释

2. 变量&标识符&关键字

先看如下示例代码：

    class Rectangle
    {
        // 成员变量
        double length;
        double width;

        public double GetArea()
        {
            length = 3;
            width = 2;
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine($"Length: {length}");
            Console.WriteLine($"Width: {width}");
            Console.WriteLine($"Area: {GetArea()}");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 变量：变量是类的属性或数据成员，用于存储数据。如上面案例代码中， length 和 width 就是成员变量
• 标识符：标识符是用来识别类、变量、函数或任何其它用户定义的对象

标识符命名规则：

• 标识符必须以字母、下划线或 @ 开头，后面可以跟一系列的字母、数字（ 0 - 9 ）、下划线（ _ ）、@。
• 标识符中的第一个字符不能是数字。
• 标识符必须不包含任何嵌入的空格或符号，比如 ? - +! # % ^ & * ( ) [ ] { } . ; : " ’ / \。
• 标识符不能是 C# 关键字。除非它们有一个 @ 前缀。 例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
• 标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
• 不能与C#的类库名称相同。

如上面的length、width、GetArea、Display 等变量或函数的名称都是标识符

• 关键字：关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。‘
  

4. 变量，字段和属性的区别

首先我们写一个示例代码：

    class UserInfo
    {
        private string _id;
        private string _name;

        public string Id
        {
            get { return _id; }
            set { _id = value; }
        }

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上面的代码中：_id，_name 是字段，Id，Name 是属性，而_id，_name，Id，Name都是成员变量。

• 字段和属性都是变量，只不过是为了区分和数据安全做出了区分。
• 字段和属性是相对于类而言的，都是在类中定义的；而变量不局限在类中，可以定义在任何需要的地方
• 字段一般使用在类的内部，只可在当前类内部访问，属性一般供外部类访问；
• 字段一般来讲都是private，而属性则是对字段使用get和set 进行了封装，一般为public
• 字段值可以用作ref、out参数，而属性不能

5.数据类型

在C#中，有以下几种类型：

• 值类型
• 引用类型
• 指针类型（不常用）

1、值类型

值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。值类型直接包含数据。
值类型又可分为：

2、引用类型

引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的 引用类型有：object、dynamic 和 string。

• string相关的还有如下一个问题：\的使用与扩展

• @和\的使用

string path1 = "E:\\MyCode\\my-study";
string path2 = @"E:\MyCode\my-study";
Console.WriteLine($"path1:{path1}-------path2:{path2}");
1
2
3

由上可知，当前我们使用@进行字符串转义的话，我们可以避免使用“\”逐个的进行转移。

3、指针类型

指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。
声明指针类型的语法：type* identifier; 如：char* cptr; int* iptr;

6. 类型转换

类型转换就是将数据从一种类型转换为另一种类型，类型转换有两种形式：

1、隐式转换

这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。将类型较小的数据存放到较大的变量中

2、显式转换

显式转换需要强制转换运算符，而且强制转换会造成数据丢失。将类型较大的数据存放在较小的变量中

案例代码如下：

        static void Main(string[] args)
        {
            int num1 = 1;
            long num2 = num1;//隐式类型转换

            //强制类型转换：(数据类型)数据
            double num3 = 3.56;
            int num4 = (int)num3;
            int num5 = Convert.ToInt32(num3);

            //Convert 对象转换
            Console.WriteLine($"3.56强制转换后的结果：{num4}\n3.56使用Convert对象转换的结果：{num5}");
			//3.56强制转换后的结果：3
			//3.56使用Convert对象转换的结果：4
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

由上面的代码案例可以清晰的了解数据的转换，另外还可从上面的案例可知，显式转换存在两种形式，一种是强制类型转换，这种方式对于浮点型不会进行四舍五入，直接将小数点后面的数据舍弃；另一种是使用Convert对象进行转换，这种方式则会对浮点型数据进行四舍五入的计算，然后进行转换。

3、装箱与拆箱

• 装箱是将值类型转换为引用类型； 拆箱就是将引用类型转换为值类型

示例代码如下：

        static void Main(string[] args)
        {
            //装箱：值类型转换为引用类型
            int num = 111;
            object obj = num;
            Console.WriteLine($"obj = {obj}"); //obj = 111

            //拆箱：引用类型转换为值类型
            int nnum = 222;
            object oobj=nnum;
            int result = (int)oobj;
            Console.WriteLine($"result = {result}");//result = 222

            //【注意】：被装过箱的对象才能被拆箱
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

我们知道平常写代码的时候要尽量的避免装箱和拆箱，但是为什么要这样呢？要搞清白这些啊，那就必须知道，什么是堆和栈以及装箱和拆箱的过程

• 堆和栈

堆栈简单来说，就是计算机存储数据的一个数据模型。
模型分为堆和栈两部分，栈中主要存放一些简单结构的数据和复杂数据的索引，堆中存储复杂数据结构的数据内容。简单的数据结构就是值类型，复杂数据结构就是引用类型

• 装箱和拆箱的过程

装箱过程：
①先在堆上为新生成的引用对象分配内存，
②然后将值类型的数据copy到刚分配的内存中，
③最后返回内存的地址（引用对象在栈中会存储这个内存的地址，相当于数据的索引）。
在装箱的过程中分配内存和数据复制都是消耗效能的操作

拆箱过程：
①先检查当前的引用类型数据是否可以转换为目标值类型数据
（例如，string str="123"可以转换为Int ,而str="asd"不可以）
②复制堆中的数据的值并将复制的值放到目标数据所在的存储位置
拆箱过程有类型检查和复制数据两个操作，其中复制数据耗费性能

由此我们可知，装箱和拆箱比较影响程序运行的性能，所以我们需要尽量的避免此类操作！

7. 常量

常量是固定值，程序执行期间不会改变。常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。
常量可以被当作常规的变量，只是它们的值在定义后不能被修改。

详情可见：C#常量，这里重点说一下定义常量，常量是使用const关键字来定义的，示例如下：

 public const string URL = "www.xxxx.com";
 public const int num = 999;
1
2

常量扩展：
静态常量（编译时常量）const 和动态常量（运行时常量）readonly
静态常量在编译时就确定了值，必须在声明时就进行初始化且之后不能进行更改，可在类和方法中定义。定义方法如下：

const double a=3.14；// 正确声明常量的方法
const int b;         // 错误，没有初始化
1
2

动态常量在运行时确定值，只能在声明时或构造函数中初始化，只能在类中定义。定义方法如下：

class Program
{
    readonly int a=1;  // 声明时初始化
    readonly int b;    // 构造函数中初始化
    Program()
    {
        b=2;
    }
    static void Main()
    {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

8. 运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，分类如下：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其他运算符

1、算数运算符

注意：在char类型参与到算数运算时，会自动转化为ascii码10进制的值参与运算

class Program
    {
        static void Main(string[] args)
        {
            int a = 1;
            int b;

            // a++ 先赋值再进行自增运算
            b = a++;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();//结果a=2,b=1

            // ++a 先进行自增运算再赋值
            a = 1; // 重新初始化 a
            b = ++a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();//结果a=2,b=2

            // a-- 先赋值再进行自减运算
            a = 1;  // 重新初始化 a
            b= a--;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();//结果a=0,b=1

            // --a 先进行自减运算再赋值
            a = 1;  // 重新初始化 a
            b= --a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();//结果a=0,b=0
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

2、关系运算符

注：关系运算符的运算结果均是bool ，常运用于判断语句中

3、逻辑运算符

注：
① 逻辑运算符的短路效果，当运算符的左边的结果对整个表达式结果起了决定性的作用的时候，运算符右边的表达式就不会运行。

如：当&&运算符左边为false的时候，此时无论运算符右边是什么，结果都为false,那么右边表达式就不会运行。

② 当单独使用| 和& 就不会产生短路的效果，即使左边已经起了决定性作用，右边仍会运行。

4、位运算符

辅助理解的案例代码如下：

		static void Main(string[] args)
        {
            //60 和13 转换位二进制分别是111100 和 1101 ，不足8位【前面】使用0补足
            int a = 60;            /* 60 = 0011 1100 */
            int b = 13;            /* 13 = 0000 1101 */
            int c = 0;

            c = a & b;
            // a      0011 1100
            // b      0000 1101
            //-----------------   根据&运算符规则：只有均为1的时候，结果才为1，否则均为0
            // c      0000 1100===>转换为十进制 则是12
            Console.WriteLine("Line 1 - c 的值是 {0}", c);

            c = a | b;
            // a      0011 1100
            // b      0000 1101
            //-----------------   根据|运算符规则：只有均为0的时候，结果才为0，否则均为1
            // c      0011 1101===>转换为十进制 则是61
            Console.WriteLine("Line 2 - c 的值是 {0}", c);

            c = a ^ b;
            // a      0011 1100
            // b      0000 1101
            //-----------------   根据^运算符规则：只有均为0或1的时候，结果才为0，否则均为1
            // c      0011 0001===>转换为十进制 则是49
            Console.WriteLine("Line 3 - c 的值是 {0}", c);

            c = ~a;               /*-61 = 1100 0011 */
            // a      0011 1100
            //取反-----------------   根据~运算符规则：将0变1 ，1变0
            // c      1100 0011===>转换为十进制 则是-61
            Console.WriteLine("Line 4 - c 的值是 {0}", c);

            c = a << 2;   
            // a      0011 1100
            //左移-----------------  0011 1100 向左移动两位则将前面两位00 移掉了，然后后面补足两位00
            // c      1111 0000===>转换为十进制 则是240
            Console.WriteLine("Line 5 - c 的值是 {0}", c);

            c = a >> 2;
            // a      0011 1100
            //右移-----------------  0011 1100 向右移动两位则将后面两位00 移掉了，然后前面补足两位00
            // c      0000 1111===>转换为十进制 则是15
            Console.WriteLine("Line 6 - c 的值是 {0}", c);
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

5、赋值运算符

6、其他运算符

这里包括有 is ，as ，typeof 等运算符.

• is 运算符检查表达式的结果是否与给定的类型相匹配。

 	public class Base { }
    public class Derived : Base { }
    class Program
    {
        static void Main(string[] args)
        {
            // 基类和派生类 之间的is 类型检查
            var b = new Base();
            Console.WriteLine(b is Base);//True
            Console.WriteLine(b is Derived);//False

            var d = new Derived();
            Console.WriteLine(d is Base);//True
            Console.WriteLine(d is Derived);//True

            //派生类可以是基类类型，is 检查返回True 
            //基类不可以是派生类的类型；
            //这个道理就像：兔子，狮子，小狗都可以用动物称呼，但是说所有动物都是小狗那就不行了

            //is 运算符将考虑装箱和取消装箱转换，但不会考虑数值转换
            int i = 27;
            object iBoxed = i;
            Console.WriteLine(iBoxed is int);  // output: True
            Console.WriteLine(iBoxed is long);  // output: False

            object obj = 99.9;
            if (obj is string s)
            {
                Console.WriteLine("结果："+s);
            }
            if (obj is double score)
            {
                Console.WriteLine("结果：" + score);
            }
            //以上案例说明：is的本质是 检查类型,通过检查返回True,反之，False
            
            //检查是否为null
            if (obj is null)
            {
                Console.WriteLine("**********");
            }

            //检查是否为非null
            if (obj is not null)
            {
                Console.WriteLine("**********");
            }
            Console.ReadLine();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

• as运算符将表达式显式转换为给定类型（如果其运行时类型与该类型兼容）
  如果无法进行转换，则 as 运算符返回 null（as不能用于值类型，值类型不能为null）。
  与强制转换表达式（形如(int)12） 不同，as 运算符永远不会引发异常。

			object obj1 = "121212";
            int le1 = (obj1 as string).Length;//可以转换

            object obj2 = null;
            int le2 = (obj2 as string).Length;//可以转换，但是由于转换后值为null,因此运行时会报错

            object obj3 = new object();
            string sr = obj as string;
            if (sr == null)
            {
                Console.WriteLine("转换失败");
            }
            else
            { 
                Console.WriteLine("转换成功");
            }
            //使用 as 转换的时候需要注意，转为结果为null的情况

            //is 对比 as 
            if (obj3 is string str3)
            {
                Console.WriteLine($"转换成功{str3}");
            }
            else
            {
                Console.WriteLine($"转换失败");
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

• typeof运算符获取某个类型的 System.Type 实例。

public class Animal { }

public class Giraffe : Animal { }

public static class TypeOfExample
{
    public static void Main()
    {
        object b = new Giraffe();
        Console.WriteLine(b is Animal);  // output: True
        Console.WriteLine(b.GetType() == typeof(Animal));  // output: False

        Console.WriteLine(b is Giraffe);  // output: True
        Console.WriteLine(b.GetType() == typeof(Giraffe));  // output: True
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7、运算符优先级

• 优先级大体上是：算数运算符> 关系运算符>逻辑运算符>赋值运算符
• 算数运算中：当有括号时，先计算括号内的，然后前运算符，再乘除模，再加减，最后后运算符
• 逻辑运算符中：当同时出现或运算符和与运算符，先计算与 运算符，然后计算或运算符

辅助理解的案例代码如下：

//算术运算符和赋值运算符的优先级：
int a = 10, b = 5, c = 2;
a += b * c;               // 先计算乘法，再执行加法赋值
Console.WriteLine(a);       // 输出20

//逻辑运算符的优先级：
bool a = true, b = false, c = true;
bool result = a || b && c;  // 先计算与运算，再计算或运算
Console.WriteLine(result);  // 输出true

//条件运算符的优先级：
int a = 10, b = 5;
string result = a > b ? "a大于b" : "a不大于b";  // 先判断大小关系，再执行条件语句
Console.WriteLine(result);  // 输出"a大于b"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

9. 流程控制语句

1、选择结构

• if else

            //第一种：只有if,没有else
            if (num>15)
            {
                //...
            }

            //第二种：有if else
            if (num > 15)
            {
                //...
            }
            else
            {
                //...
            }
            //第三种：多种判断if  else if ...else
            if (num>15)
            {
                //...
            }
            else if (num>0)
            {
                //...
            }
            else
            {
                //...
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

• switch

一个 switch 语句允许测试一个变量等于多个值时的情况，算是if else 在某一层面上的进阶版。

switch 语句中的表达式 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型

运用switch的典型案例：输入年月，得出该月的天数

        static void Main(string[] args)
        {
            Console.WriteLine("请输入年份：");
            int year = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("请输入月份：");
            int month = Convert.ToInt32(Console.ReadLine());
            int day = 0;//定义天数
            switch (month)
            {
                //大月
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10: 
                case 12: day = 31; break;
                //小月
                case 4: 
                case 6: 
                case 9: 
                case 11: day = 30; break;
                case 2:
                	//主要是需要对二月进行判断，是否是闰月
                    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
                    {
                        //满足条件，则为闰年中的闰月，输出29天
                        day = 29;
                        break;
                    }
                    else
                    {
                        day = 28;
                        break;
                    }
                default:
                    Console.WriteLine("请输入正确的月份数字！");
                    break;
            }
            Console.WriteLine($"{year}年{month}月有{day}天");
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

• 三元运算符?:

x?y:z 表示如果表达式 x 为 true，则返回 y；如果 x 为 false，则返回 z，是 if{}else{} 的简单形式。

		static void Main(string[] args)
        {
            int a=11; 
            int b=22;
            int c = a > b ? a : b;
            Console.WriteLine($"c={c}");
            Console.ReadLine();//结果: c=22
        }
1
2
3
4
5
6
7
8

2、循环(loop)结构

循环语句允许我们多次执行一个语句或语句组。

• for

简单使用案例：

			for (int i = 0; i < 10; i++)
            {
                Console.WriteLine($"i={i}");
            }
            Console.ReadLine();
1
2
3
4
5

当我们需要无限循环的时候，只需要如下使用：

			//将各项条件均省略，程序会默认为true,一直运行
			for (; ;)
            {
                Console.WriteLine("我是无限循环");
            }
1
2
3
4
5

常见题目：百钱百鸡，兔子生小兔子（斐波拉且数列）,猜价格（价格截半法）

        static void Main(string[] args)
        {
            //某人有100元钱，要买100只鸡。
            //公鸡5元钱一只，母鸡3元钱一只，小鸡一元钱3只。
            //编程计算可买到公鸡，母鸡，小鸡各为多少只？
            
            //首先从循环次数上将，从公鸡开始循环次数最少
            //首先100元最多买20只公鸡,
            for (int i = 0; i < 20; i++)//i为公鸡数 
            {
                //j为母鸡数
                for (int j = 0; j < 33; j++)
                {
                    if ((100-i-j)%3==0&&i*5+j*3+(100-i-j)/3==100)
                    {
                        Console.WriteLine($"公鸡={i},母鸡={j},小鸡={100-i-j}");
                    }
                }
            }          
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

		static void Main(string[] args)
        {
            //程序循环猜商品价格
            //首先定义价格范围
            int max = 1000;
            int min = 1;

            //定义随机数
            Random rnd = new Random();

			//定义一个标记，一会使用goto重新从标记位执行代码，方便测试使用
            Flag:
            
            //随机一个正确价格
            int correctPrice = rnd.Next(min,max+1);
            Console.WriteLine($"正确价格是：{correctPrice}");
            
            //开始猜价格
            for (int i = 1;; i++)
            {
                int price = (min + max) / 2;
                if (correctPrice > price)
                {
                    Console.WriteLine($"第{i}次猜测的价格：{price}，低了");
                    min = price + 1;
                }
                else if (correctPrice < price)
                {
                    Console.WriteLine($"第{i}次猜测的价格：{price}，高了");
                    max = price - 1;
                }
                else
                {
                    Console.WriteLine($"恭喜你，第{i}次猜测的价格：{price}，正确");
                    break;
                }
            }
            if (Console.ReadKey().KeyChar=='A')
            {
                min = 1;
                max = 1000;
                goto Flag;
            }
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

注意：理解案例中的for循环的运用以及价格截半的精髓（二分查找），另外案例中有个goto关键字的运行和使用

• foreach

使用foreach可以迭代数组或者一个集合对象。

        static void Main(string[] args)
        {
            string[] arrStr = new string[] { "ab", "cd", "ef" };
            foreach (var item in arrStr)
            {
                Console.WriteLine($"遍历数组-当前项{item}");
            }
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9

foreach 迭代遍历只能是正向的，不可逆的，逐个的遍历数组中的每一个元素；迭代遍历时，被迭代的数组的元素不能更改；迭代遍历的速度远快于for循环。

• while 和do…while

简单使用案例：

 		static void Main(string[] args)
        {
            /* 局部变量定义 */
            int a = 10;

            /* while 循环执行 */
            while (a < 20)//只要条件为true,也可无限循环下去
            {
                Console.WriteLine("a 的值： {0}", a);
                a++;
            }
            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13

		static void Main(string[] args)
        {
            /* 局部变量定义 */
            int a = 10;

            /* do 循环执行 */
            do
            {
               Console.WriteLine("a 的值： {0}", a);
                a++;
            } while (a < 20);

            Console.ReadLine();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

先执行do，然后判断while的条件，当条件为true的时候才进入循环；相较于while循环，do…while无论是否满足循环条件，都会先执行一次业务代码。

• 循环控制语句

循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围中创建的自动对象都会被销毁

10. 数组&字符串&结构体&枚举

1、数组
数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合。
数组中重要的三个组成部分就是：元素（数组中的每一项都是一个元素），长度（数组的长度），索引（从0开始）

使用案例：

			//声明数组
            int[] nums;
            //初始化数组
            double[] scores=new double[10];
            //赋值给数组--逐个元素赋值
            double[] doubles=new double[10];
            doubles[0] = 10.1;
            doubles[1] = 10.2;
            //初始化并赋值给数组,可省略数组长度
            double[] doubles1 = new double[]{10.1,10.2 };
            //简化赋值过程
            double[] doubles2 = { 10.1, 10.2, 10.3 };

            //访问数据元素,通过索引
            double num = doubles2[0];

            //不过大多时候，都是使用for 和foreach 来操作数据
            for (int i = 0; i < doubles2.Length; i++)
            {
                Console.WriteLine($"元素doules[{i}]={doubles2[i]}");
            }
            Console.ReadLine();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

数组扩展内容见：C#数组详解

2、字符串
在 C# 中，您可以使用字符数组来表示字符串，但是，更常见的做法是使用 string 关键字来声明一个字符串变量。string 关键字是 System.String 类的别名。
关于字符串的详细内容可见：C#字符串使用详解

3、结构体
在 C# 中，结构体是值类型数据结构。它使得一个单一变量可以存储各种数据类型的相关数据。struct 关键字用于创建结构体。

结构体特点如下：

• 结构可带有方法、字段、索引、属性、运算符方法和事件。
• 结构可定义构造函数，但不能定义析构函数。但是，您不能为结构定义无参构造函数。无参构造函数(默认)是自动定义的，且不能被改变。
• 与类不同，结构不能继承其他的结构或类。
• 结构不能作为其他结构或类的基础结构。
• 结构可实现一个或多个接口。
• 结构成员不能指定为 abstract、virtual 或 protected。
• 当您使用 New 操作符创建一个结构对象时，会调用适当的构造函数来创建结构。与类不同，结构可以不使用 New 操作符即可被实例化。
• 如果不使用 New 操作符，只有在所有的字段都被初始化之后，字段才被赋值，对象才被使用。

另外结构体与类的区别

• 类是引用类型，结构是值类型。
• 结构不支持继承。
• 结构不能声明默认的构造函数。
• 结构体中声明的字段无法赋予初值，类可以:
• 结构体的构造函数中，必须为结构体所有字段赋值，类的构造函数无此限制:

代码如下：

using System;
using System.Text;
     
struct Books
{
   private string title;//结构体中声明的字段无法赋予初值，类可以:
   private string author;
   private string subject;
   private int book_id;
   public void setValues(string t, string a, string s, int id)
   {
      title = t;
      author = a;
      subject = s;
      book_id =id;
   }
   public void display()
   {
      Console.WriteLine("Title : {0}", title);
      Console.WriteLine("Author : {0}", author);
      Console.WriteLine("Subject : {0}", subject);
      Console.WriteLine("Book_id :{0}", book_id);
   }

};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1 = new Books(); /* 声明 Book1，类型为 Books */
      Books Book2 = new Books(); /* 声明 Book2，类型为 Books */

      /* book 1 详述 */
      Book1.setValues("C Programming",
      "Nuha Ali", "C Programming Tutorial",6495407);

      /* book 2 详述 */
      Book2.setValues("Telecom Billing",
      "Zara Ali", "Telecom Billing Tutorial", 6495700);

      /* 打印 Book1 信息 */
      Book1.display();

      /* 打印 Book2 信息 */
      Book2.display();

      Console.ReadKey();

   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

4、枚举
枚举是一组命名整型常量。枚举类型是使用 enum 关键字声明的。
C# 枚举是值类型。换句话说，枚举包含自己的值，且不能继承或传递继承。

• 枚举是值类型的数据，只能定义值类型的内容，枚举是将值进行包装
• enum 默认自带public static ,无需实例化
• enum和int的值是相互参照的，enum中的值与int转换的时候，默认按照0，1，2的顺序排序，也可以自行定义enum中每一项枚举的值

使用案例如下：

    //声明enum变量,不定义各项的值，默认
    enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat };
    //声明enum变量,自定义各项的值
    enum Day
    {
        Sun = 10,Mon = 20, Tue = 30, Wed = 40, Thu = 50, Fri = 60, Sat = 70,
    }
    //混合情况,第 n 个符号值与第 n-1 个有关，如：此时Mon为  11
    enum WeekDay
    {
        Sun = 10, Mon, Tue, Wed = 40, Thu, Fri, Sat,
    }

    class Program
    {
        static void Main(string[] args)
        {
            //默认情况下，枚举中的值与int相互转换，从0开始依次增加
            int x = (int)Days.Sun;
            int y = (int)Days.Fri;
            Console.WriteLine("Sun = {0}", x);//Sun = 0
            Console.WriteLine("Fri = {0}", y);//Sun = 5

            Day day = (Day)20;//将int值转化为枚举
            Console.WriteLine(day.ToString());//将枚举转换成字符串，结果：Mon
            //将字符串转化为枚举
            Day day1 = (Day)Enum.Parse(typeof(Day), "Mon");//如果Mon在不在枚举内，这种情况下会报错

            //混合情况,第 n 个符号值与第 n-1 个有关。
            int dy = (int)WeekDay.Mon;
            int dx= (int)WeekDay.Tue;
            int dz= (int)WeekDay.Sat;
            Console.WriteLine("WeekDay\tMon = {0}", dy);//WeekDay Mon = 11
            Console.WriteLine("WeekDay\tTue = {0}", dx);//WeekDay Tue = 12
            Console.WriteLine("WeekDay\tSat = {0}", dz);//WeekDay Sat = 43
            Console.ReadLine();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

关于枚举的进阶用法，详情可见：C#枚举进阶用法

11. C#关键字之修饰符

C#中的修饰符都是关键字

1、访问修饰符

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。
一个 访问修饰符 定义了一个类成员的范围和可见性。

• protected internal 是 protected 和 internal 的并集，满足任何一个即可
• 可访问性排序：public > internal > protected > private

2、其他修饰符

常用修饰符还有：

static、abstract、virtual、override、sealed、readonly、extern、event、const、async、in、new、out

不常用的修饰符有：unsafe、volatile

这里会对部分修饰符的使用进行整理汇总，其余部分如果在后续深入的过程中涉及到也会逐步整理出来

• static 静态的

• • 使用 static 修饰符可声明属于类型本身而不是属于特定对象的静态成员。 static 修饰符可用于声明 static 类。 在类、接口和结构中，可以将 static 修饰符添加到字段、方法、属性、运算符、事件和构造函数。 static 修饰符不能用于索引器或终结器。
• • 如果 static 关键字应用于类，则类的所有成员都必须为 static。
• • 程序默认就创建实例，因此static对象无需实例化，直接使用；
• • 类中静态变量，它只是定义在当前类中，但是本身不属于类，它早已经实例化，因此调用的时候直接使用类名 + 点（.）运算符进行调用
• • 使用过多的静态对象，会比较消耗内存，因为它默认就实例化了，已经占好了内存

使用案例如下：

    class UserInfo
    {
        private string _id;
        //静态变量
        public static string Info;
        //普通变量
        public string Id
        {
            get { return _id; }
            set { _id = value; }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //使用静态变量，无需实例化，直接通过类名.
            string info = UserInfo.Info;

            //使用普通变量,需要先实例化才可以
            string id = new UserInfo().Id;
            Console.ReadLine();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

• abstract 抽象的
  abstract 修饰符可用于类、方法、属性、索引和事件

抽象方法

• • 抽象方法是隐式的虚拟方法，abstract方法默认自带virtual属性
• • 只有抽象类中才允许抽象方法声明。
• • 由于抽象方法声明不提供实际的实现，因此没有方法主体；方法声明仅以分号结尾，且签名后没有大括号 ({ })。
• • 在抽象方法声明中使用 static 或 virtual 修饰符是错误的。

抽象方法如下：

public abstract void  GetInfo();

//实现由方法 override 提供，它是非抽象类的成员。

1
2
3
4

抽象类

• • 抽象类不能实例化。
• • 必须有子类继承
• • 派生自抽象类的非抽象类，必须包含全部已继承的抽象方法和访问器的实际实现。
    （简单说：子类必须实现抽象父类的所有抽象方法）
• • 在抽象方法声明中使用 static 或 virtual 修饰符是错误的。

• sealed 封闭的
  通常用于实现第三方类库时不想被客户端继承，或用于没有必要再继承的类以防止滥用继承造成层次结构体系混乱。恰当的使用sealed修饰符也可以在一定程度上提高运行效率，因为不用考虑继承类会重写该成员。

sealed的作用

• • 在类声明中使用sealed可防止其它类继承此类；
• • 在方法声明中使用sealed修饰符可防止子类重写此方法。
• • sealed修饰符主要用于防止非有意的派生，但是它还能促使某些运行时优化
• • 密封类中永远不可能有任何派生类。如果密封类实例中存在虚拟成员函数，该成员函数可以转化为非虚的，函数修饰符virtual 不再生效。

11. 方法

首先在C#中对于函数和方法并没有明确的定义区分，本质上是一样的，只是叫法不同；某些情况下，如我们会更习惯叫构造函数，而不叫构造方法。

熟悉方法无非两点：定义方法和调用方法。
定义方法：

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

访问修饰符 方法修饰符 返回类型 函数名( 参数列表 )
{
     函数体;
}

//实例如下：
public void GetInfo(string id)
{
	//....
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

调用方法：
调用：通过方法名调用方法，如

Rectangle rectangle = new Rectangle();
//Display即是矩形对象中的方法，通过方法名调用即可
rectangle.Display();
1
2
3

12. 类

1、类的基本内容

• 当你定义一个类时，你定义了一个数据类型的蓝图。
• 构成类的方法和变量称为类的成员。
• 访问标识符 指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员的默认访问标识符是 private。
• 如果要访问类的成员，你要使用点（.）运算符。点运算符链接了对象的名称和成员的名称。

2、构造函数

• 类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。
• 构造函数提供了一种对象的多种创建方式。
• 构造函数的名称与类的名称完全相同，它没有任何返回类型。

认识一下构造函数，代码如下：

    class Student
    {
        public string Name { get; set; }
        public double Score { get; set; }
        //构造函数，没有任何返回类型
        public Student()
        {

        }
    }
1
2
3
4
5
6
7
8
9
10

构造函数分为：默认/隐式构造函数 和参数化构造函数

• 默认构造函数，没有参数列表，没有代码，默认隐藏不显示，有且仅有一个
• 参数化构造函数，手工定义，只要参数列表不同，可以有N个
• 如果类中定义了一个参数化的构造函数，默认会把隐式的构造函数替换掉
• 如果需要支持或者用到 无参数的构造函数，就需要定义起来

    class Student
    {
        public string Name { get; set; }
        public double Score { get; set; }
        //默认构造函数，没有任何返回类型
        public Student()
        {

        }
		//参数化构造函数
        public Student(string name)
        {

        }
        //参数化构造函数
        public Student(string name, double score)
        {
            
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3、析构函数（终结器）

终结器（以前称为析构函数）用于在垃圾回收器收集类实例时执行任何必要的最终清理操作。 在大多数情况下，通过使用 System.Runtime.InteropServices.SafeHandle 或派生类包装任何非托管句柄，可以免去编写终结器的过程。

• 无法在结构中定义终结器。 它们仅用于类。
• 一个类只能有一个终结器。
• 不能继承或重载终结器。
• 不能手动调用终结器。 可以自动调用它们。
• 终结器不使用修饰符或参数。

class Car
{
    ~Car()  // finalizer
    {
        // cleanup statements...
    }
}

public class Destroyer
{
   public override string ToString() => GetType().Name;

   ~Destroyer() => Console.WriteLine($"The {ToString()} finalizer is executing.");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

不应使用空终结器。 如果类包含终结器，会在 Finalize 队列中创建一个条目。 此队列由垃圾回收器处理。 当 GC 处理队列时，它会调用每个终结器。 不必要的终结器（包括空的终结器、仅调用基类终结器的终结器，或者仅调用条件性发出的方法的终结器）会导致不必要的性能损失。

程序员无法控制何时调用终结器，因为这由垃圾回收器决定。 垃圾回收器检查应用程序不再使用的对象。 如果它认为某个对象符合终止条件，则调用终结器（如果有），并回收用来存储此对象的内存。 可以通过调用 Collect 强制进行垃圾回收，但多数情况下应避免此调用，因为它可能会造成性能问题。

4、内部类

顾名思义就是类中定义的类。
内部类的目的 是为了隐藏一个类中的类 ，保护内部的类

13. 接口

接口本身并不实现任何功能，它只是和声明实现该接口的对象订立一个必须实现哪些行为的契约。接口更像是抽象方法的一个集合

    interface IDataLink
    {
        void Contect();
        void DisContect();
    }
1
2
3
4
5

• 1 抽象类是类，可以定义变量，有构造函数，使用abstract 是禁止实例
• 2 接口不是类，里面可以定义变量，但是必须赋值，因为他只是抽象方法集合，所以必须自己赋初始值 实例化
• 3 接口中方法默认都是public abstract

14. 接口和抽象类

相同点：

• 1、 都不能实例化
• 2、 实现类 都必须实现所有抽象方法

不同点：

• 1 接口是多重继承，抽象类是单一继承
• 2 一个类只能继承一个父类，但是可以实现n个接口
• 3 抽象类是类，接口不是类（抽象方法的集合）

其余涉及到面向对象编程的内容，如：封装，继承，多态等将在下一篇博客中进行展开~

---

结语

以上就是本文的内容，希望以上内容可以帮助到您，如文中有不对之处，还请批评指正。

---

参考资料：
C# 语言介绍
C#教程
装箱与拆箱