C#学习

C#

项目一 欢迎进入C#世界

• C#语言的特点：语法简洁，彻底的面向对象设计，与web紧密结合，强大的安全机制，兼容性，灵活的版本处理技术，完善的错误、异常处理机制。
• 控制台应用程序、Windows窗体应用程序与WPF应用程序 控制台应用程序通常没有图形界面，只有字符界面 Windows窗体应用程序有图形界面，是对Windows API的封装 WPF应用程序也是用来做图形界面的，但WPF不是对Windows API的直接封装，而是对DirectX的封装，更能利用显卡，所以可以较容易地做出酷炫界面效果。

任务实施1——创建控制台应用程序

创建一个控制台应用程序，输出文字“欢迎进入C#世界！”

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;//导入命名空间
namespace ConsoleApplication1 //自定义ConsoleApplication1命名空间
{             // ConsoleApplication1命名空间的开始大括号
    class Program          //自定义Program类
    {   //Program类的开始大括号
        static void Main(string[] args) //入口方法Main
        {//Main的开始大括号
            Console.WriteLine("欢迎进入C#世界！");  //向屏幕输出信息
        }//Main的结束大括号
    }// Program类的结束大括号
} //ConsoleApplication1命名空间的结束大括号

如果程序需要调试则可以按【F5】键，或执行“调试”→“启动调 试”菜单命令。若程序有错误系统将提示错误（例如可将WriteLine中的L删除），如图1-20所示；若程序没有错误将正常运行，此时窗口一闪之后就关闭，用户看不到运行结果，因此可以在Main方法的最后一行加上如下代码： Console.ReadLine();会自动打开dos指令界面

任务实施2——创建窗体应用程序

创建一个Windows窗体应用程序，内容为用户的登录界面。

1.单击“工具箱”按钮，将工具箱中的2个label、2个button、2个 textBox控件拖拽到Form1窗体中，并适当调整各控件的位置、大小。lable是文字，textBox是文本框，button是按键，在属性里可以改名字。

2.双击“确定”按钮，系统将自动切换到Form1.cs代码编辑窗口，在 button1的Click事件方法中输入用以显示相关信息的代码；在button2的Click事件方法中输入用以清空文本框值的代码。

private void button1_Click(object sender， EventArgs e)
{
   MessageBox.Show(textBox1.Text+textBox2.Text+"，口令正确！欢迎您进入C#世界！");   //弹出提示框
 }
 private void button2_Click(object sender,EventArgs e)
 {
   textBox1.Text="";   //清空用户名
   textBox2.Text =""; //清空密码
  }

注：在Windows窗体程序中，除了窗体及其对应的代码外，还有一个包含主 方法Main的入口类Programe。可双击Programe.cs查看其全部代码，其 主要代码含义如下：

static void Main()
  {
           Application.EnableVisualStyles();
 //此方法为应用程序启用可视样式，需在应用程序中创建任何控件之前调用
            Application.SetCompatibleTextRenderingDefault(false);
 //在应用程序范围内设置控件显示文本的默认方式，true表示以GDI+方式
//显示文本，false表示以GDI方式显示文本
           Application.Run(new Form1());
 //程序启动时首先加载Form1窗体
 }

3.按【F5】键调试程序，在弹出的登录页面中输入用户名和密码，单 击“确定”按钮后会出现一个信息提示框，效果如图1-24所示。若想重新输 入内容，则单击“取消”按钮，文本框中的内容将被清空。至此，我们创建 了一个简单的Windows窗体应用程序。

项目二 C#语法基础

任务1——熟悉C#中的基础语言元素

标识符和保留字

在计算机语言中，对于常量、变量、类、方法等也要定义名字，这些名称统称为标识符。

• 在c#语言中，标识符是以字母、下划线、@开始的一个字符序列，后面可以跟字母、数字、下划线。 注：C#语言注意区分大小写，一般情况下变量名首字母小写，后面各单词首字母大写。（常量、类名、方法、属性等首字母需要大写)

书写规则

• 每条语句以分号“；”结尾（注意需要在英文状态下输入）。
• 尽量每行只放置一条语句。
• 编写语句块时垂直对齐左括号和右括号，或者使用倾斜格式，即左括号出现在行尾，右括号出现在行尾。
• 对同一级别的语句建立标准缩进大小（如四个空格），并在整个文件中一致地使用此标准。
• 为语句添加必要的注释，增加代码的可读性

注释的表达方法

• 注释一行：//
• 多行注释：/* */
• XML注释：/// （不常用，///要加在方法前面）

常量和变量

常量是指在程序执行过程中值保持不变的量，变量是指在程序过程中值可以改变的量。

常量

常量分为字面常量和符号常量。 常量类型：

• 整数常量：整数常量表示通常意义上的整数，可以用十进制、八进制和十六进制表示。
• 实型常量：实型常量是指通常意义上的实数，也称浮点数。实型常量有两种表现形式：十进制小数形式和指数形式（科学计数法，如0.47173e2=0.47173×10²）。
• 字符常量:字符型常量分为普通字符常量和转义字符常量。 普通字符常量是用单引号括起来的一个字符，例如：'A'，'g' 注:普通字符常量只能包括一个字符，而且包括大小写。 转义字符常量是由反斜杠开头的一个或多个字符的序列，用于表示一些无法显示的字符。

• 字符串常量：字符串常量是由一对双引号括起来的零个或多个字符序列。若想要再字符串中间显示双引号和单引号需要使用反斜杠，例：

"The char is \'a\',\"YES\"or\"No\"?"  //表示"The char is 'a',"YES"or"No"?"

• 布尔值常量：布尔型（bool）常量只有两个值，即true和false。

符号常量声明：const 数据类型 常量名=数值/表达式；

变量

变量又叫变量标识符，由字母、数字和下划线组成，且第一个字符必须是字母或下划线，变量名不允许使用C#关键字、系统函数名和系统类名。

程序员对变量命名的约束： 1.标识符采用英文单词或其组合。保证直观且用词准确，可望文知意。 2.遵循最小化长度与最大化信息量原则。在保证一个标识符意思明确的同时，应当尽量缩短其长度。 3.避免标识符过于相似。不要出现仅靠大小写区分的相似标识符，例如“i”与“I”，“function”与“Function”等。 4.用正确的反义词组命名具有互斥意义的标识符。例如“nMinValue”和“nMaxValue”“GetName)”和“SetName)”等。 5.除非逻辑上的确需要编号，否则尽量避免名字中出现数字编号。例如Valuel,Value2等，以防产生无意义的名字。 6.保持在整个模块中命名风格的统一性。例如，在编写一个派生类或模块的时候，要道循其基米或整体模块的命名风格。

变量的定义：数据类型 变量名1，变量名2，……，变量名n；

int a=b=c    //错误，需要分别赋值
int a=3，b=3，c=3;

变量的分类：变量分为静态变量、非静态变量、数组元素、值参数、引用参数、局部变量。

• 静态变量与非静态变量：带有static修饰符声明的变量称为静态变量，不带有static修饰符声明的变量称为非静态变量或实例变量。

数据类型

• 内置类型和构造类型 内置类型：object（对象类型）；string（字符串）；byte，sbyte，int，uint，short，ushort，long，ulong（整数类型）；char，bool（字符类型）；float，double，decimal（浮点类型） 构造类型：枚举，数组，结构，集合，类，接口，委托

• 值类型和引用类型：

  

值类型：1.整数数据类型：整型数据类型是指变量的值为整数的值类型。

​ 整数:int（有符号）和uint（无符号） ​ 短整型：short和ushort ​ 长整型：long和ulong ​ byte型：byte和sbyte 注：变量默认为int类型，后缀字符不区分大小写。例：long I =1234L

​ 2.浮点数类型：float（单精度类型），double（双精度类型），decimal（此类型适用于金融货币方面的计算） 注：浮点数类型默认是double类型，float类型后缀字符为F，decimal后缀字符为M

​ 3.布尔类型：true和false

​ 4.字符类型：数字字符、英文字母、特殊符号

• 枚举类型和结构类型 枚举类型和结构类型都是自定义数据类型，枚举类型是一种独特的值类型，用于声明一组命名的常数；结构类型可以定义C#的任何基本数据类型的组合，在结构类型中还可以定义另一个结构类型。
• 引用类型 C#中的引用类型包括类类型、接口类型、数组类型和委托类型。

运算符和表达式

用来表示运算的符号称为运算符，用运算符把运算对象连接起来的有意义的式子称为表达式。

• 单目运算符：用于单个操作数，可出现在前面可出现在操作数后面或者前面。
• 双目运算符：用于两个操作数，并始终出现在两个操作数中间。
• 三目运算符：用于三个操作数，C#中只有一个三目运算符“？:”，用于条件计算。

算术运算符

运算符	名称	描述
+	加法运算符	将两数相加获得相加的和
-	减法运算符	将两数相减获得差值
*	乘法运算符	将两数相乘获得积
/	除法运算符	将两数相除获得商
%	取余运算符（模运算符）	将两数相除后取得余数
++	自增运算符（单目）	数值加1
--	自减运算符（单目）	数值减1

注：++i：在使用i之前，先使i加1，--i在使用i之前，先使i减1，i++：在使用i之后，再使i加1，i-- 在使用i之后，再使i减1，

关系运算符

【>（大于）,<（小于）, >=（大于等于）, <=（小于等于） , ==（等于） , !=(不等于)】

逻辑运算符

逻辑非"！"（真输出假，假输出真），逻辑与"&"（有一个为假输出假），逻辑异或"^"（相同输出假，不同输出真），逻辑或"|"（只要一个为真就输出真），条件逻辑与"&&"，条件逻辑或"||"

位运算符

赋值运算符

格式：变量名=数值/表达式 复合赋值运算符：+=，-=， *=，/=、<<=、>>=、&=、^=、|= 注：最后都会给原变量赋值

条件运算符

C#唯一三目运算符：“？：”

一些特殊的运算符

• 点运算符（“.”）：点运算符用于指定类型或命名空间的成员。
• 索引运算符（“[]”）:索引运算符用于数组、索引器，表示按[]内指定的索引去访问数组或索引器中的相应元素的内容。
• 转换运算符（“（）”）圆括号除了用于指定表达式中的运算顺序外，还用于指定强制转换或类型转换。
• checked和unchecked运算符：对整数进行操作时，其值可能超出该数据类型的范围。
• is运算符：is运算符用于检查对象是否与给定类型兼容。
• as运算符；as运算符用于执行引用类型的显式类型转换，若不成功则返回null。
• new：new运算符用于创建对象和调用构造函数。
• typeof：typeof运算符用于获得系统原型对象的类型，即返回表示特定类型的System.Type对象。

运算符优先级

任务实施：计算两数之和

float a, b, s;//声明三个float变量
            Console.Write("请输入两个数字：\n");//提示
            Console.Write("a=");//提示
            //readline代表获取用户输入，结果是字符串类型
            //由于类型要一致，所以需要float.parse转换类型
            a = float.Parse(Console.ReadLine());
            Console.Write("b=");
            b = float.Parse(Console.ReadLine());
            s = a + b;//把a+b的值赋给s
            Console.WriteLine("两个数的和为{0}+{1}={2}\n",a,b,s);//"两个数的和为{0}\n",s也可以换成 "两个数的和为"+s
            //{0}代表一个数，后面的s是把值赋给这个数的。

任务二 掌握数据类型间的转换

隐式转换

隐式转换是系统默认的不必加以说明就可以进行的转换。

• 字符的类型可以隐式转换为整数或浮点型，但其他类型不能隐式转换为字符类型。
• 低精度的类型可以隐式转换成高精度的类型，反之则不行。
• 浮点型和decimal类型之间不能进行隐式转换，而只能进行显示转换。

显式转换

如果希望将高精度转换为低精度数据，必须使用强制转换表达式将源类型转化为目标类型，这种数据转换方式称为显式转换，又叫强制转换。

    1、sbyte 类型可以显式转换为 byte, ushort, uint, ulong, char.
    2、byte 类型可以显式转换为 sbyte, char.
    3、short 类型可以显式转换为 sbyte, byte, ushort, uint, ulong, char.
    4、ushort 类型可以显式转换为 sbyte, byte, short, or char.
    5、int 类型可以显式转换为 sbyte, byte, short, ushort, uint, ulong, char.
    6、uint 类型可以显式转换为 sbyte, byte, short, ushort, int, char.
    7、long 类型可以显式转换为 sbyte, byte, short, ushort, int, uint, ulong, char.
    8、ulong 类型可以显式转换为 sbyte, byte, short, ushort, int, uint, long, char.
    9、char 类型可以显式转换为 sbyte, byte, or short.
    10、float 类型可以显式转换为 sbyte, byte, short, ushort, int, uint, long, ulong, char, decimal.
    11、double 类型可以显式转换为 sbyte, byte, short, ushort, int, uint, long, ulong, char, float, decimal.
    12、decimal 类型可以显式转换为 sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double.

C#的三种显示转换方式：

• 通过圆括号“()”，格式：

(目标类型)<表达式>  例：
float a=2.4f
int b=(int)a

float a=2.8f
int b=(int)a
//浮点数类型没有四舍五入，多余全去掉。

• 通过Convert类

可以通过“Convert.方法名（参数）”来使用

例：string a = 6;
    b = Convert.ToInt32(a);
    //把字符串转换成int类型

• 通过数据类型自身的Parse方法

例：string a = 4;
    b = float.Parse(a);
    //把字符串转换成float类型

• 在C#中，所有数据类型都有Tostring()方法。

int i =100;
string str=i.Tostring;

i.Tostring和Convert.ToString区别：一般情况下这两种方法都可以通用，但是当返回的数据类型中有可能出现null值时，若调用Tostring方法，会返回NullReferenceException异常，若使用Convert.ToString()方法，不会抛出异常而是返回空字符串。

注：C#程序的基本单位是语句。

   小数类型比浮点数类型精度高。

简易贷款计算器装置：
static void Main(string[] args)
        {
            double a,b,c,d;
            a = 0.65 / 12;

            Console.WriteLine("请输入贷款金额：");
            Console.Write("贷款金额=");
            b = double.Parse(Console.ReadLine());
            
            Console.WriteLine("请输入还款月数：");
            Console.Write("还款月数=");
            c = double.Parse(Console.ReadLine());

            d = (b * a * Math.Pow((1 + a), c)/(Math.Pow((1 + a), c) - 1));
            Console.WriteLine("每月需还款"+d);
        }

注：Math类中Pow（double x，double y）方法用于返回指定数字（x）的指定幂（y）。

项目三 方法

任务一 掌握方法的声明与调用方法

方法的声明

一、方法声明的格式

方法的使用原则是先声明后使用，一次声明可多次无限次的调用。**方法必须放在类中声明。**格式：

修饰符/*可不写*/ 返回类型 方法名 (参数列表)/*可不写*/
{
方法体
}

• 修饰符：访问权限修饰符是最常用的方法修饰符，用于声明方法访问级别。此参数为可选参数，默认值为私有访问private*（内调外可以，外调内不可以）*。

  

注：C#语言中，程序集是指类被组合后的逻辑单位和物理单位，其编译后的文件扩展名通常为“.dll”、“.exe”。

• 返回类型：返回类型有int、double和string等数据类型，方法的返回值一般由方法体中的return语句给出。没有返回值的方法，其返回类型为void，表示空值。
• 方法名称：方法名通常用一个能反映方法功能的字符串表示，它需要符合c++标识符命名规则。方法名后面必须跟一对括号，以区分于其他标识符。
• 参数列表：参数列表由0个或多个参数组成写在方法名后面的圆括号内，用于向方法传送数值。参数列表内给出的每一个参数都要指出其类型和参数名。当参数个数多于1个时，参数之间用逗号隔开。
• 方法体：方法体是实现方法功能的主体部分，用花括号括起来，中间可以是一条或若干条语句。如果方法需要返回一个值，则方法中必须有一条return语句，语句中的表达式就是要返回的值，如果缺少该语句，就会报错。

public int A()
{
  int a; //声明一个整形变量a
  a=10*20;
  renturn a; //返回值 必须写
}

二、变量的作用域

• 局部变量的作用域（只能在函数内部使用）：方法的参数列表及方法体内所声明的变量。其作用域从变量声明开始，到方法体结束为止。
• 类成员变量的作用域（全局变量，在这个类里面哪里都能用）：作为类的成员所声明的变量称为“字段”。它具有类的作用域（类的作用域界定为类主体的一对开、闭大括号内）。

在方法中，局部变量必须先声明、后使用；但作为类成员的变量字段可以放在使用它的方法后面。

方法的调用

一、方法调用格式

• 若调用类内部声明的方法，无需加前缀，通过“参数名（实参）”的格式调用即可。

 private void apple(string s)//形参：形式参数
        {
            //局部变量:在函数内部声明，包括参数列表
            //只能在声明的函数内部使用
            float f = 1.2f;
            i = 2;
        }
  public void main()
        {
            //类的内部访问函数
            apple("");//实参：实际参数
        }

• 若要调用外部类中的方法，一般分为以下两个部分

1.实例化方法所在的类，创建对象。格式：

类名 对象名 = new 类名（）
例：
//类的外部访问（调用）函数
Accept zhangsan = new Accept();//第一步，创建对象

2.调用方法

格式为 对象名.方法名（参数）

zhangsan.banana();//第二步，通过对象.函数名()的方式调用
zhangsan.orange('a');

调用方法时，有以下几点需要注意： (1)调用方法时的参数是实际参数，简称“实参”。实参个数和类型必须与方法声明时的形参一致，如果方法声明时没有参数，则调用时也不用给参数，实参可以是常量，有的变量或能求值的表达式。 (2)方法名后必须包含一对圆括号，调用无参方法也不例外。 (3)调用方法后有返回值可直接输出，成能给来一变量，或参与另一个表达式的运算。

• 类
  • 类外部
    • 静态变量
      • 类名.方法
    • 非静态变量
      • 对象.方法
  • 类内部
    • 静态变量
      • 不能调用动态
    • 非静态变量
      • 直接调用

二、方法参数

在C#中方法的参数有四种类型，值参数类型（不加任何修饰符，是 默认的类型），引用型参数（以ref修饰符声明），输出型参数（以out修饰符声明），数组型参数（以params修饰符声明）。

• 值参数: 值类型是方法默认的参数类型，采用的是值拷贝的方式。也就是说，如果使用的是值类型，则可以在方法中更改该值，但当控制传递回调用过程时，不会保留更改的值。
• 引用型参数： ref 关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。

若要使用 ref 参数，则方法定义和调用方法都必须显式使用 ref 关键字。

传递到 ref 参数的参数必须最先初始化。这与 out 不同，out 的参数在传递之前不需要显式初始化。

如果一个方法采用 ref 或 out 参数，而另一个方法不采用这两类参数，则可以进行重载。

• 输出型参数(out类型)： out 关键字会导致参数通过引用来传递。这与 ref 关键字类似。 与 ref 的不同之处：
• ref 要求变量必须在传递之前进行初始化，out 参数传递的变量不需要在传递之前进行初始化。 尽管作为 out 参数传递的变量不需要在传递之前进行初始化，但需要在调用方法初始化以便在方法返回之前赋值。
• 数组型参数类型(params类型)： params 关键字可以指定在参数数目可变处采用参数的方法参数。也就是说。使用params可以自动把你传入的值按照规则转换为一个新建的数组。 在方法声明中的 params 关键字之后不允许任何其他参数，并且在方法声明中只允许一个 params 关键字。 ———————————————— 版权声明：本文为CSDN博主「叶落q」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_53516639/article/details/121011502

静态方法

使用了static修饰符的方法为静态函数，反之为非静态方法。

静态方法是一种特殊的成员方法，他不属于类的某个具体的实例，而属于类本身（用类点名不用实例名）。格式：

<类名>.<静态方法>

任务二：掌握方法与运算符重载

方法重载

通过不同的参数类型、参数个数或者参数类型的顺序来区分，这种方式叫做方法的重载。

 class Program
    {
        static void Main(string[] args)
        {
            UseAbs m = new UseAbs();
            int x = 10;
            long y = -123;
            double z = -23.98d;
            x = m.abs(x);
            y = m.abs(y);


            z = m.abs(z);
            Console.WriteLine("x={0},y={1},z={2}",x,y,z);
        }
    }
    public class UseAbs
    {
        public int abs(int x)
        {
            return (x < 0 ? -x : x);
        }
        public double abs(double x)
        {
            return (x < 0 ? -x : x);
        }
        public long abs(long x)
        {
            return (x < 0 ? -x : x);
        }
    } 

运算符重载

操作费重载是指将C#中已有的操作符赋予新的功能，但与该操作符本来的含义不冲突，使用时系统会根据操作数类型来判断具体执行哪一种运算。

操作符重载实际是定义了一个操作符方法。操作符方法声明的格式：

static public 函数返回类型 operator 重新定义的操作符（形参表）

项目四 逻辑值与分支语句

任务一 掌握常用运算符与if分支语句

定义逻辑变量

逻辑变量也称作布尔变量，其定义方法为：

bool <变量名>;

逻辑变量的值有true和false（默认为false）两个值，分别表示真和假。

bool值可以转换成字符串，另外，在C#中bool值不能和整数值进行互换，若用0表示false，用非零表示true则程序会报错。

关系运算符与表达式

 

 

表中前四种优先级相同，后两种优先级相同，且前者级别高于后者，关系运算符的运算结果为逻辑值true或false。

逻辑运算符与表达式

 

 

用逻辑运算符可以把不同类型的表达式连接起来组成逻辑表达式，逻辑表达式的值只能是true和false。

&&和||在C#的性能称为“快速求值”，可减少程序的运行时间。

程序的基本控制结构

(1)顺序结构 顺序结构就是按照程序代码先后顺序自上而下地执行，直到程序结束，中间没有任何判断和跳转。 (2)选择结构 选择结构(又称分支结构)用于判断给定的条件，根据判断的结果来控制程序的流程。C#中，选择语句包括if语句和switch语句，用来解决实际应用中按不同情况进行不同处理的问题。本项目中我们就要学习这种结构。 (3)循环结构 循环结构用来描述重复执行某段算法的问题，可以减少重复书写程序代码的工作量，是程序设计中最能发挥计算机运算速度快这一特长的程序结构。我们将在项目五中学习这种程序结构。

if…else分支结构

（一）if语句的基本结构

• 单分支语句：如果表达式为真，则执行if后面的语句；否则，跳过该语句直接执行后面的语句。

if(表达式)
{
  语句;
}

• 双分支语句：如果表达式的值为真，则执行语句1；否则执行语句2。

if(表达式)
{
  语句1;
}
else
{
  语句2;
}

• 多分支语句：

该语句的功能是：首先判断表达式1的值，如果值为真，则执行语句1，否则判断表达式2的值；如果表达式2的值为真，则执行语句2，否则判断表达式3的值；依此类推，若所有表达式的值为假，则执行语句n+1。

if(表达式1)
{
  语句1;
}
else if(表达式2)
{
  语句2;
}
else if(表达式n)
{
  语句n;
}
else
{
  语句n+1;
}

（二）if语句的嵌套

if(表达式1)
 if(表达式2)语句1；//内嵌if语句
 else 语句2； //内嵌if语句
else
 if（表达式3）语句3； //内嵌if语句
 else 语句4;//内嵌if语句

（三）if语句的注意事项

else必须与if配套使用，它总是与它上面最近的且未配对的if配对。

任务二 掌握条件运算符switch分支语句

条件运算符

条件?第一个表达式:第二个表达式;

swith分支语句

swith语句的一般表达形式如下：

switch (表达式){
  case常量表达式1:
    语句组1;break;
  case常量表达式2:
    语句组2;break;
  case常量表达式3:
    语句组3;break;
  case常量表达式n:
    语句组n;break;
  default:
    语句组n+1；break;
}

• 该语句的功能是：首先计算switch语句中表达式的值(表达式一般为整型、字符或字符串类型)，当表达式的值与某一个case后面常量表达式的值匹配时，就执行该case后面的语句，执行完后退出switch语句；若表达式的值与所有case后面的常量表达式的值都不匹配，则执行default后面的语句。
• 使用switch语句时应注意以下几点： 1每个case后面的常量表达式必须各不相同，否则会出现矛盾，即一个值有多种选择。 2各个case语句和default语句出现的顺序对执行结果没有影响。 3在每一个case后面，都必须有一个跳转语句(如break、gote等)。C#中不支持C或C++中的“贯穿原则”(即某若case语句后面没有break，则执行完case语句后不再进行判断，程序将转到下一个case语句继续执行)，如果要在执行一个case语句后继续执行另一个case语句，则必须使用显式的goto case或goto default语句。

项目五 循环语句

任务一 掌握while和do…while循环语句

while循环语句

格式：

while(条件表达式)
{
  循环体语句;
}

while语句实现的循环是“当型循环”，即先测试循环条件再执行循环体。当条件表达式成立时才执行后面的循环语句，否则不执行。执行完循环体代码块后，while语句返回来再判断条件表达式的否成立，若成立则继续下一轮循环，如此循环往复，直到条件表达式为假，才退出整个while语句。

do…while语句

格式：

do
{
  循环体语句
}
while(条件表达式);

与while循环语句不同，do循环语句属于“直到型循环”，即首先执行代码块循环体，再判断条件表达式。若条件表达式成立，继续执行循环体，否则结束循环。因此，do语句的循环体至少会执行一次。

任务二 掌握for和foreach语句

for语句

格式：

for(变量初始化;条件表达式;控制变量更新表达式)
{
  循环体语句
}

for语句中变量初始化部分只在开始时执行一次，然后判断条件表达式，若为true，则执行代码块循环体，然后执行控制变量更新表达式，再回头来判断条件表达式是否成立，以决定下一次循环；若条件表达式为false，则结束整个循环语句。

因此，for语句与while语句一样，当第一次判断条件表达式不成立时，则循环体一次都不执行。

使用 for循环语句时要注意以下事项：

(1)需要让一个循环控制变量递增或递减1时，既可使用复合赋值运算符，也可使用自增自减运算符，后者因为更简练所以常被采用，例如i++相当于i+=1。

(2) for语句圆括号内的3个部分都可以省略，但分隔用的分号不能省略。如果省略了条件表达式，那么默认为true。

(3)可在一个for循环语句中提供用逗号分隔的多个变量初始化表达式和多个控制变量更新表达式，但条件表达式只能有一个。

(4) for语句变量初始化部分声明的变量，其作用域只局限于for语句内部。

任务三 掌握break和continue语句

break语句

语句格式：

break;

用于终止对循环的执行，流程直接跳转到当前循环语句的下一语句执行。

continue语句

语句格式：

continue;

用于结束本次循环，即跳过本次循环体中余下的尚未执行的语句，接着再一次进行循环条件判断，以便执行下一次循环。

continue语句只能用于循环语句内部，用来结束本次循环，继续下一次循环条件的判断。

项目六 程序调试与异常处理

任务一 掌握VS中调试程序的方法

语法错误

语法错误是指由于用户没有按编程语言规则编写代码而引起的错误，也称为编译错误。例如输入了不正确的关键字、缺少表达式、遗漏了某个必需的标点符号等等，是最明显和最容易改正的错误。 在编写代码时，VS会自动对程序进行语法检查，并提醒程序开发人员。

语义错误

语义错误是指因应用程序在运行期间执行了非法操作或某些操作失败而引起的错误，也称运行错误，例如，打开的文件未找到、磁盘空间不足、网络连接断开、除法中除数为零等等。

逻辑错误

逻辑错误是指应用程序未按照程序员预期的方式运行所产生的错误。例如设置的条件不合适、循环次数不当等，此时程序不会崩溃，但是执行的逻辑是错误的，用户不能得到想要的结果。

项目十 数组与集合

任务一 学习数组

数组的使用

一维数组是指只有一个下标的数组。数组在使用前必须先定义（或声明）和分配空间，定义一维数组的语法格式为：

数组类型[] 数组名;
int[] arrA;

在定义数组后，必须对其进行初始化才能使用。初始化数组有两种方法：动态初始化和静态初始化。

(一)动态初始化

动态初始化需要借助new运算符，为数组元素分配内存空间并为数组元素赋初值，格式如下：

数组类型[] 数组名=new 数据类型[n] {元素值0，元素值1，……，元素值n-1);
int[] myArrA = new int [5] {1,2,3,4,5}

n为“数组长度”，可以是整型符号常量或已具有值的整型变量，后面一层大括号里为初始值部分。数组定义后，将占用连续的存储空间，其占用存储空间大小为“长度数据类型所占用的字节数*”。

1.不给定初始值的情况

如果不给出初始值部分，各元素取默认值，数值类型初始化为0或0.0，布尔类型初始化为false，字符串类型初始化为null。例：

int[] a = new int[10];
//也可以写成：
int [] a; //定义数组
a = new int[10];//给数组分配存储空间

在程序运行时，系统将数组a分配一个连续的40字节的存储单元，该数组在内存中各数组元素均取默认值0。

C#中的数组的大小可以动态确定，例如下面语句：

int AL =6;
int []a = new int[AL]; //定义了一个长度为6的数组a

2.给定初始值的情况

给出初始值时部分，可在大括号中列出数组中各元素相应的初值，且可以省略“数组长度”。例如：

int[] a = new int[10](1,2,3,4,5,6,7,8,9,10];
int[] a = new int[](1,2,3,4,5,6,7,8,9,10];

在这种情况下，不允许“数组长度”为变量。

int n = 5; //定义变量n
int[] myarr = new int[n] (1,2,3,4,5);//错误

如果给出“数组长度”，则初始值的个数应与“数组长度”相等，否则出错。

int[] mya = new int[2] {1,2}; //正确
int[] Dmya = new int[2] {1,2,3}; //错误
int[] mya = new int[2] {1}; //错误

(二)静态初始化

静态初始化数组的语法格式如下：

数组类型[] 数组名={元素值0，元素值1……元素值(n-1)};

用这种方法对数组进行初始化时，无需说明数组元素的个数，只需按顺序列出数组中的全部元素即可，系统会自动计算并分配数组所需的内存空间。

例如，静态初始化整型数组 myarr:

int[] myarr=(1,2,3,4,5);

在这种情况下，不能将数组定义和静态初始化分开。

(三)数组元素的引用

在C#中通常并不把数组作为一个整体进行处理，参与运算和数据处理的一般都是数组元素。引用一维数组元素的格式如下：

数组名[下标];

数组元素的下标从0开始，因此具有N个元素的数组，其下标范围为0～N-1。例如：

int[] a=new int[5];

那么，数组a具有元素a[0]，a[1]，a[2]，a[3]和a[4]。 在程序中数组元素可以像同类的普通变量一样参加赋值、运算、输入和输出等操作。例如，以下语句用于输出数组 myarr的所有元素值：

for(i=0;i<5;i++)
Console.Write("{0} ",a[i]);
Console.WriteLine();

需要注意的是，在C#中不允许下标越界，即C#在运行时将对下标越界进行检查。在上面定义的数组a，数组元素a[5]和a[6]均是不可用的。

二维数组的使用

二维数组是有两个下标的数组，它适合处理如成绩报告表、矩阵等具有行列结构的数据。与C和C++不同的是，C#的二维数组的每一行的数组元素个数可以相等，也可以不相等。每行数组元素个数相同的二维数组称为方形二维数组，不同的称参差数组。

(一)方形二维数组

(1)动态初始化

语法格式为：

数组类型[ , ]数组名=new 数据类型符[长度1.长度2]；

二维数组数组的元素个数为“长度1×长度2”个。

例如：int[ , ]a=new int[3.4];定义了一个数组a，该数组的数据类型是int，具有12个元素上述语句可以写成两条，如：

int[,] a; //定义数组
a =new [3.4] ; //给数组分配存储空间

从逻辑上看，方形二维数组是一种“行列”结构，由若干行和若干列组成，如上例中是义的数组a有3行，每行有4列，逻辑结构如下：

     第1列  第2列  第3列  第4列

第1行 a[0.0] a[0.1] a[0,2] a[0,3]

第2行 a[1,0] a[1,1] a[1,2] a[1,3]

第3行 a[2,0] a[2,1] a[2.2] a[2,3]

动态初始化时，也可以为数组赋值，例如：

int[,]a=new int[3,4]{{5,6,7,8},{9,10,11,12}};

(2)静态初始化

语法格式为：

数据类型符[ ，]数组名={{初值列表1}，{初值列表2}，{初值列表n}}；

上述语句中定义的二维数组，同时给它的各行赋初值。如果各初值列表中的初值个数相等，则创建的是方形二维数组。二维数组的行数由分组的个数确定。例如：

int[,]b={{1,2,3,4}，{5,6,7,8}，{9,10,11,12}};

该语句定义了具有12个元素的二维数组b，并依次赋初值，初值情况为：

b[0.0]=1，b[0.1]=2，b[0.2]=3，b[0，3]=4， b[1，0]=5，b[1，1]=6，

b[1.2]-7，b[1,3]=8，b[2,0]=9，b[2,1]=10，

b[2.2]=11，b[2,3]=12。

(3)元素引用

引用二维数组元素的一般格式为：

数组名[下标1.下标 2]

(二)参差数组

参差数组的定义一般分为两步：首先定义二维数组占有的行数，然后定义每行的列数并分配空间。

(1)分配行 语法格式为：

数据类型符[］[]数组名=new数组类型符[行数][］；

例如：

int [][ ] b =new int [3] [ ]; //该语句定义了一个参差数组b，数组的行数为3

(2)分配各行数组元素个数

分配了参差数组占有的行后，应为每一行(可看作一维数组)分配数组元素个数，语句格式为：

数组名[i]=new 数据类型符[长度]；

上述语句为参差数组的i行分配数组元素个数，元素个数由“长度”指定。例如：

int [][] b=new int[3][ ]; //定义具有3行的参差数组b
b[0] = new int [2]; //首行具有2个元素
b[1] = new int [3]; //第二行具有3个元素
b[2]=new int [4]; //第三行具有4个元素

给各行分配数组元素时，可以给元素赋初值，赋初值和引用参差二维数组元素的方法同方形数组.

Array类