C#_01_基础语法
2018-01-29 13:47
429 查看
C# 编程_第01章_基础语法
C# 是一个现代的、通用的、面向对象的编程语言，它是由微软（Microsoft）开发的，由 Ecma 和 ISO 核准认可的。
ECMA是“European
Computer Manufactures Association”的缩写，即:欧洲计算机制造联合会。
C# 是由 Anders Hejlsberg(安德斯-海森博格,代表作:Delphi,C#,TypeScript) 和他的团队在 .Net 框架开发期间开发的。
C# 是专为公共语言基础结构（CLI,common Language Infrastructure）设计的。CLI 由可执行代码和运行时环境组成，允许在不同的计算机平台和体系结构上使用各种高级语言。
下面列出了 C# 成为一种广泛应用的专业语言的原因：
现代的、通用的编程语言。
面向对象。
面向组件。
容易学习。
结构化语言。
它产生高效率的程序。
它可以在多种计算机平台上编译。
.Net 框架的一部分。
虽然 C# 的构想十分接近于传统高级语言 C 和 C++，是一门面向对象的编程语言，但是它与 Java 非常相似，有许多强大的编程功能，因此得到广大程序员的亲睐。
下面列出 C# 一些重要的功能：
布尔条件（Boolean Conditions）
自动垃圾回收（Automatic Garbage Collection）
标准库（Standard Library）
组件版本（Assembly Versioning）
属性（Properties）和事件（Events）
委托（Delegates）和事件管理（Events Management）
易于使用的泛型（Generics）
索引器（Indexers）
条件编译（Conditional Compilation）
简单的多线程（Multithreading）
LINQ (Language Integrated Query,以查询数据库相同的方式操作内存数据)和Lambda (λ匿名函数)表达式
集成 Windows
在这一章中，我们将讨论创建 C# 编程所需的工具。我们已经提到 C# 是 .Net 框架的一部分，且用于编写 .Net 应用程序。
因此，在讨论运行 C# 程序的可用工具之前，让我们先了解一下 C# 与 .Net 框架之间的关系。
.Net 框架是一个创新的平台，能帮您编写出下面类型的应用程序：
Windows 应用程序
Web 应用程序
Web 服务
.Net 框架应用程序是多平台的应用程序。框架的设计方式使它适用于下列各种语言：C#、C++、Visual Basic、Jscript、COBOL 等等。所有这些语言可以访问框架，彼此之间也可以互相交互。
.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 (Language
Integrated Query)以查询数据库相同的方式操作内存数据
微软（Microsoft）提供了下列用于 C# 编程的开发工具：
Visual Studio 2010 (VS)
Visual C# 2010 Express (VCE)
Visual Web Developer
后面两个是免费使用的，可从微软官方网址下载。
使用这些工具，您可以编写各种 C# 程序，从简单的命令行应用程序到更复杂的应用程序。
您也可以使用基本的文本编辑器（比如 Notepad）编写 C# 源代码文件，并使用命令行编译器（.NET 框架的一部分）编译代码为组件。
Visual C# Express 和 Visual Web Developer Express 版本是 Visual Studio 的定制版本，且具有相同的外观和感观。它们保留 Visual Studio 的大部分功能。
在本教程中，我们使用的是 Visual C# 2010 Express。
您可以从 Microsoft Visual Studio 上进行下载。它会自动安装在您的机器上。请注意，您需要一个可用的网络连接来完成速成版的安装。
虽然 .NET 框架是运行在 Windows 操作系统上，但是也有一些运行于其它操作系统上的版本可供选择。
Mono是 .NET 框架的一个开源版本，它包含了一个 C# 编译器，且可运行于多种操作系统上，比如各种版本的 Linux 和 Mac OS。如需了解更多详情，请访问 Go
Mono。
Mono 的目的不仅仅是跨平台地运行微软 .NET 应用程序，而且也为 Linux 开发者提供了更好的开发工具。
Mono 可运行在多种操作系统上，包括 Android、BSD、iOS、Linux、OS X、Windows、Solaris 和 UNIX。
在我们学习 C# 编程语言的基础构件块之前，让我们先看一下 C# 的最小的程序结构，以便作为接下来章节的参考。
一个 C# 程序主要包括以下部分：
命名空间声明（Namespace declaration）
一个 class
Class 方法
Class 属性
一个 Main 方法
语句（Statements）& 表达式（Expressions）
注释
让我们看一个可以打印出 "Hello World" 的简单的代码：
当上面的代码被编译和执行时，它会产生下列结果：
让我们看一下上面程序的各个部分：
程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。
下一行是 namespace 声明。一个 namespace 是一系列的类。BeyondApplication 命名空间包含了类 Girl。
下一行是 class 声明。类 Girl 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，Girl 类只有一个 Main 方法。
下一行定义了 Main 方法，是所有 C# 程序的 入口点。Main 方法说明当执行时 类将做什么动作。
下一行 /*...*/ 将会被编译器忽略，且它会在程序中添加额外的 注释。
Main 方法通过语句 Console.WriteLine("Hello Beyond"); 指定了它的行为。
WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 "Hello, Beyond!"。
最后一行 Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。
以下几点值得注意：
C# 是大小写敏感的。
所有的语句和表达式必须以分号（;）结尾。
程序的执行从 Main 方法开始。
与 Java 不同的是，文件名可以不同于类的名称。
如果您使用 Visual Studio.Net 编译和执行 C# 程序，请按下面的步骤进行：
启动 Visual Studio。
在菜单栏上，选择 File -> New -> Project。
从模板中选择 Visual C#，然后选择 Windows。
选择 Console Application。
为您的项目制定一个名称，然后点击 OK 按钮。
新项目会出现在解决方案资源管理器（Solution Explorer）中。
在代码编辑器（Code Editor）中编写代码。
点击 Run 按钮或者按下 F5 键来运行程序。会出现一个命令提示符窗口（Command Prompt window），显示 Hello World。
您也可以使用命令行代替 Visual Studio IDE 来编译 C# 程序：
打开一个文本编辑器，添加上面提到的代码。
保存文件为 c#_01.cs
打开命令提示符工具，定位到文件所保存的目录。
键入 csc c#_01.cs 并按下 enter 键来编译代码。(前提是:已经安装了.net framework,并将其添加到环境变量path栏中,如图所示)
如果代码没有错误，命令提示符会进入下一行，并生成c#_01.exe 可执行文件。
接下来，键入 c#_01 来执行程序。
您将看到 "Hello Beyond" 打印在屏幕上。
如图所示:
C# 是一种面向对象的编程语言。在面向对象的程序设计方法中，程序由各种相互交互的对象组成。
相同种类的对象通常具有相同的类型，或者说，是在相同的 class 中。
例如，以 Rectangle（矩形）对象为例。它具有 length 和 width 属性。
根据设计，它可能需要接受这些属性值、计算面积和显示细节。
让我们来看看一个 Rectangle（矩形）类的实现，并借此讨论 C# 的基本语法：
当上面的代码被编译和执行时，它会产生下列结果：
运行效果如下:
在任何 C# 程序中的第一条语句都是：
using 关键字用于在程序中包含命名空间。一个程序可以包含多个 using 语句。
class 关键字用于声明一个类。
注释是用于解释代码。编译器会忽略注释的条目。在 C# 程序中，多行注释以 /* 开始，并以字符 */ 终止，如下所示：
单行注释是用 '//' 符号表示。例如：
变量是类的属性或数据成员，用于存储数据。在上面的程序中，Rectangle 类有两个成员变量，名为 length 和 width。
函数是一系列执行指定任务的语句。类的成员函数是在类内声明的。我们举例的类 Rectangle 包含了三个成员函数： AcceptDetails、GetArea 和 Display。
在上面的程序中，类 ExecuteRectangle 是一个包含 Main() 方法和实例化 Rectangle 类的类。
标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：
标识符必须以字母开头，后面可以跟一系列的字母、数字（ 0 - 9 ）或下划线（ _ ）。标识符中的第一个字符不能是数字。
标识符必须不包含任何嵌入的空格或符号，比如 ? - +! @ # % ^ & * ( ) [ ] { } . ; : " ' / \。但是，可以使用下划线（ _ ）。
标识符不能是 C# 关键字。
关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，
但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。
在 C# 中，有些标识符在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字（contextual keywords）。
下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：
在 C# 中，变量分为以下几种类型：
值 类型（Value types）
引用 类型（Reference types）
指针 类型（Pointer types）
值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。
值类型直接包含数据。比如 int、char、float，它们分别存储数字、字母、浮点数。
当您声明一个 int 类型时，系统分配内存来存储值。
下表列出了 C# 2010 中可用的值类型：
如需得到一个类型或一个变量在特定平台上的准确尺寸，可以使用 sizeof 方法。
表达式 sizeof(type) 产生以字节为单位存储对象或类型的存储尺寸。
下面举例获取任何机器上 int 类型的存储尺寸：
当上面的代码被编译和执行时，它会产生下列结果：
运行效果如下:
引用类型 不包含存储在变量中的实际数据，但它们包含对变量的引用。
换句话说，它们指的是一个内存位置。
?????使用多个变量时，引用类型可以指向一个内存位置。???Excuse Me???
引用位置保存在栈中，数据存储在堆中???Excuse Me???
换句话说，它们指的是一个内存位置。
?????使用多个变量（栈引用）时，引用类型可以指向一个内存位置（堆）。?????
如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。
内置的 引用类型有：object、dynamic 和 string。
对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。
Object 是 System.Object 类的别名。
对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。
但是，在分配值之前，需先进行类型转换。
当一个值类型转换为对象类型时，则被称为 装箱；
另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。 注:与Java类同
您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。
声明动态类型的语法：
例如：
动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。
字符串（String）类型 允许您给变量分配任何字符串值。
字符串（String）类型是 System.String 类的别名。它是从对象（Object）类型派生的。
字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。
例如：
一个 @引号字符串： 形似Objective-C
C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待，比如：
等价于：
@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。
用户自定义引用类型有：class、interface 或 delegate。后续会再细讲
指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。
声明指针类型的语法：
例如：
后续会再细讲
类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型。
在 C# 中，类型铸造有两种形式：
隐式类型转换 - 这些转换是 C# 默认的以安全方式进行的转换。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
显式类型转换 - 这些转换是通过用户使用预定义的函数显式完成的。显式转换需要强制转换运算符。
下面的实例显示了一个显式的类型转换：
当上面的代码被编译和执行时，它会产生下列结果：
C# 提供了下列内置的类型转换方法：
下面的实例把不同值的类型转换为字符串类型：
当上面的代码被编译和执行时，它会产生下列结果：
一个变量只不过是一个供程序操作的存储区的名字。
在 C# 中，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。
C# 中提供的基本的值类型大致可以分为以下几类：
C# 允许定义其他值类型的变量，比如 enum，也允许定义引用类型变量，比如 class。
C# 中变量定义的语法：
在这里，data_type 必须是一个有效的 C# 数据类型，可以是 char、int、float、double 或其他用户自定义的数据类型。variable_list 可以由一个或多个用逗号分隔的标识符名称组成。
一些有效的变量定义如下所示：
您可以在变量定义时进行初始化：
变量通过在等号后跟一个常量表达式进行初始化（赋值）。初始化的一般形式为：
变量可以在声明时被初始化（指定一个初始值）。
初始化由一个等号后跟一个常量表达式组成，如下所示：
一些实例：
正确地初始化变量是一个良好的编程习惯，否则有时程序会产生意想不到的结果。
请看下面的实例，使用了各种类型的变量：
当上面的代码被编译和执行时，它会产生下列结果：
System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。
例如：
函数 Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，因为 Console.ReadLine() 返回值是System.String类型。
C# 中的两种表达式：
lvalue：lvalue 表达式可以出现在赋值语句的左边或右边。
rvalue：rvalue 表达式只能出现在赋值语句的右边，不能出现在赋值语句的左边。
变量是 lvalue 的，所以可以出现在赋值语句的左边。
数值是 rvalue 的，因此不能被赋值，不能出现在赋值语句的左边。
下面是一个有效的语句：
下面是一个无效的语句，会产生编译时错误：
常量是固定值，程序执行期间不会改变。
常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。
常量可以被当作常规的变量，只是它们的值在定义后不能被修改。
整数常量可以是十进制、八进制或十六进制的常量。
前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，没有前缀则表示十进制。
整数常量也可以有后缀，可以是 U 和 L 的组合，
其中，U 和 L 分别表示 unsigned 和 long。后缀可以是大写或者小写，多个后缀以任意顺序进行组合。
这里有一些整数常量的实例：
以下是各种类型的整数常量的实例：
一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。
您可以使用小数形式或者指数形式来表示浮点常量。
这里有一些浮点常量的实例：
使用小数形式表示时，必须包含小数点、指数或同时包含两者。
使用指数形式表示时，必须包含整数部分、小数部分或同时包含两者。
有符号的指数是用 e 或 E 表示的。
字符常量是括在单引号里，例如，'x'，且可存储在一个简单的字符类型变量中。
一个字符常量可以是一个普通字符（例如 'x'）、一个转义序列（例如 '\t'）或者一个通用字符（例如 '\u02C0'）。
在 C# 中有一些特定的字符，当它们的前面带有反斜杠时有特殊的意义，可用于表示换行符（\n）或制表符 tab（\t）等。
在这里，列出一些转义序列码：
以下是一些转义序列字符的实例：
当上面的代码被编译和执行时，它会产生下列结果：
字符常量是括在双引号 "" 里，或者是括在 @"" 里。
字符串常量包含的字符与字符常量相似，可以是：普通字符、转义序列和通用字符
使用字符串常量时，可以把一个很长的行拆成多个行，可以使用空格分隔各个部分。
这里是一些字符串常量的实例。下面所列的各种形式表示相同的字符串。
常量是使用 const 关键字来定义的 。定义一个常量的语法如下：
下面的代码演示了如何在程序中定义和使用常量：
当上面的代码被编译和执行时，它会产生下列结果：
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。
C# 有丰富的内置运算符，分类如下：
算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
杂项运算符
本教程将逐一讲解算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符及其他运算符。
下表显示了 C# 支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
请看下面的实例，了解 C# 中所有可用的算术运算符：
当上面的代码被编译和执行时，它会产生下列结果：
下表显示了 C# 支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
请看下面的实例，了解 C# 中所有可用的关系运算符：
当上面的代码被编译和执行时，它会产生下列结果：
下表显示了 C# 支持的所有逻辑运算符。假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：
请看下面的实例，了解 C# 中所有可用的逻辑运算符：
当上面的代码被编译和执行时，它会产生下列结果：
位运算符作用于位，并逐位执行操作。&、 | 和 ^ (异或)的真值表如下所示：
假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
下表列出了 C# 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：
请看下面的实例，了解 C# 中所有可用的位运算符：
当上面的代码被编译和执行时，它会产生下列结果：
下表列出了 C# 支持的赋值运算符：
请看下面的实例，了解 C# 中所有可用的赋值运算符：
当上面的代码被编译和执行时，它会产生下列结果：
下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和
三目运算符 a?b:c
运算符描述实例
sizeof()返回数据类型的大小。sizeof(int)，将返回 4.
typeof()返回 class 的类型。typeof(StreamReader);
&返回变量的地址。&a; 将得到变量的实际地址。
*变量的指针。*a; 将指向一个变量。
? :条件表达式 如果条件为真 ? 则为 X : 否则为 Y
is判断对象是否为某一类型。
If( PingPong is Sport) // 检查 乒乓 是否是 Sport 类的一个对象。
as强制转换，即使转换失败也不会抛出异常。
Object obj = new StringReader("Hello");
StringReader r = obj as StringReader;
当上面的代码被编译和执行时，它会产生下列结果：
运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。
例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。
下表将按运算符优先级从高到低列出各个运算符，
具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。
在表达式中，较高优先级的运算符会优先被计算。
当上面的代码被编译和执行时，它会产生下列结果：
判断结构要求程序员指定一个或多个要评估或测试的条件，以及条件为真时要执行的if语句（必需的）和条件为假时要执行的else语句（可选的）。
C# 提供了以下类型的判断语句。点击链接查看每个语句的细节。
我们已经在前面的章节中讲解了 条件运算符 ? :，可以用来替代 if...else 语句。它的一般形式如下：
其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和位置。
? 表达式的值是由 Exp1 决定的。
如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。
如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。
一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。
C# 中 if 语句的语法：
如果布尔表达式为 true，则 if 语句内的代码块将被执行。如果布尔表达式为 false，则 if 语句结束后的第一组代码（闭括号后）将被执行。
当上面的代码被编译和执行时，它会产生下列结果：
一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
C# 中 if...else 语句的语法：
如果布尔表达式为 true，则执行 if 块内的代码。如果布尔表达式为 false，则执行 else 块内的代码。
当上面的代码被编译和执行时，它会产生下列结果：
一个 if 语句后可跟一个可选的 else if...else 语句，这可用于测试多种条件。
当使用 if...else if...else 语句时，以下几点需要注意：
一个 if 后可跟零个或一个 else，它必须在任何一个 else if 之后。
一个 if 后可跟零个或多个 else if，它们必须在 else 之前。
一旦某个 else if 匹配成功，其他的 else if 或 else 将不会被测试。
C# 中的 if...else if...else 语句的语法：
当上面的代码被编译和执行时，它会产生下列结果：-_-! 没有匹配的值,还要我打这么多代码?!
在 C# 中，嵌套 if-else 语句是合法的，这意味着您可以在一个 if 或 else if 语句内使用另一个 if 或 else
if语句。
C# 中 嵌套 if 语句的语法：
您可以嵌套 else if...else，方式与嵌套 if 语句相似。
当上面的代码被编译和执行时，它会产生下列结果：
一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。
C# 中 switch 语句的语法：
switch 语句必须遵循下面的规则：
switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个
class 类型，其中 class 有一个单一的转换函数???将其转换为整型或枚举类型。
在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值 和 一个冒号。
case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量。
当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
不是每一个 case 都需要包含 break。如果 case 语句为空，则可以不包含 break，控制流将会 继续 后续的
case，直到遇到 break 为止。
C# 不允许从一个开关部分 继续执行到 下一个开关部分。如果 case 语句中有处理语句，则必须包含 break或其他跳转语句。
一个 switch 语句可以有一个可选的 default case，出现在
switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句同样是必需加的。
C# 不支持从一个 case 标签显式贯穿到另一个 case 标签。
如果要使 C# 支持从一个 case 标签显式贯穿到另一个 case 标签，可以使用goto 一个 switch-case 或 goto default
当上面的代码被编译和执行时，它会产生下列结果：
您可以把一个 switch 作为一个外部 switch 的语句序列的一部分，即可以在一个 switch 语句内使用另一个 switch 语句。即使内部和外部
switch 的 case 常量包含共同的值，也没有矛盾。
C# 中 嵌套 switch 语句的语法：
当上面的代码被编译和执行时，它会产生下列结果：
有的时候，可能需要多次执行同一块代码。一般情况下，语句是顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。
编程语言提供了允许更为复杂的执行路径的多种控制结构。
循环语句允许我们多次执行一个语句或语句组
C# 提供了以下几种循环类型。点击链接查看每个类型的细节。
循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围中创建的自动对象都会被销毁。
C# 提供了下列的控制语句。点击链接查看每个语句的细节。
如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。
当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，程序员偏向于使用 for(;;) 结构来表示一个无限循环。
只要给定的条件为真，C# 中的 while 循环语句会重复执行一个目标语句。
C# 中 while 循环的语法：
在这里，statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。
condition 可以是任意的表达式，当为任意非零值时都为真。当条件为真时执行循环。
当条件为假时，程序流将继续执行紧接着循环的下一条语句。
当上面的代码被编译和执行时，它会产生下列结果：
一个 for 循环是一个允许您编写一个执行特定次数的循环的重复控制结构。
C# 中 for 循环的语法：
下面是 for 循环的控制流：
init 会首先被执行，且只会执行一次。这一步允许您声明并初始化任何循环控制变量。您也可以不在这里写任何语句，只要有一个分号出现即可。
接下来，会判断 condition。如果为真，则执行循环主体。如果为假，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。
在执行完 for 循环主体后，控制流会跳回上面的 increment 语句。该语句允许您更新循环控制变量。该语句可以留空，只要在条件后有一个分号出现即可。
条件再次被判断。如果为真，则执行循环，这个过程会不断重复（循环主体，然后增加步值，再然后重新判断条件）。在条件变为假时，for 循环终止。好绕,绕晕了>_<
当上面的代码被编译和执行时，它会产生下列结果：
不像 for 和 while 循环，它们是在循环头部测试循环条件。do...while 循环是在循环的尾部检查它的条件。
do...while 循环与 while 循环类似，但是 do...while 循环会确保至少执行一次循环。
C# 中 do...while 循环的语法：
请注意，条件表达式出现在循环的尾部，所以循环中的 statement(s) 会在条件被测试之前至少执行一次。
如果条件为真，控制流会跳转回上面的 do，然后重新执行循环中的 statement(s)。这个过程会不断重复，直到给定条件变为假为止。
当上面的代码被编译和执行时，它会产生下列结果：
C# 允许在一个循环内使用另一个循环，下面演示几个实例来说明这个概念。
C# 中 嵌套 for 循环 语句的语法：
C# 中 嵌套 while 循环 语句的语法：
C# 中 嵌套 do...while 循环 语句的语法：
关于嵌套循环有一点值得注意，您可以在任何类型的循环内嵌套其他任何类型的循环。比如，一个 for 循环可以嵌套在一个 while 循环内，反之亦然。
下面的程序使用了一个嵌套的 for 循环来查找 2 到 100 中的质数：
当上面的代码被编译和执行时，它会产生下列结果：
不是质数的,肯定 可以分解成两个数:一个小于 sqrt(a), 一个大于sqrt(a)
代码如下:
C# 中 break 语句有以下两种用法：
当 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句。
它可用于终止 switch 语句中的一个 case。
如果您使用的是嵌套循环（即一个循环内嵌套另一个循环），break 语句会停止执行最内层的循环，然后开始执行该块之后的下一行代码。
C# 中 break 语句的语法：
当上面的代码被编译和执行时，它会产生下列结果：
C# 中的 continue 语句有点像 break 语句。但它不是强迫终止，continue 会跳过当前循环中的代码，强迫开始下一次循环。
对于 for 循环，continue 语句会导致执行条件测试和循环增量部分。对于 while 和 do...while 循环，continue 语句会导致程序控制回到条件测试上。
C# 中 continue 语句的语法：
当上面的代码被编译和执行时，它会产生下列结果：
未完待续,下一章节,つづく
C# 简介
C# 是一个现代的、通用的、面向对象的编程语言，它是由微软（Microsoft）开发的，由 Ecma 和 ISO 核准认可的。ECMA是“European
Computer Manufactures Association”的缩写，即:欧洲计算机制造联合会。
C# 是由 Anders Hejlsberg(安德斯-海森博格,代表作:Delphi,C#,TypeScript) 和他的团队在 .Net 框架开发期间开发的。
C# 是专为公共语言基础结构（CLI,common Language Infrastructure）设计的。CLI 由可执行代码和运行时环境组成，允许在不同的计算机平台和体系结构上使用各种高级语言。
下面列出了 C# 成为一种广泛应用的专业语言的原因：
现代的、通用的编程语言。
面向对象。
面向组件。
容易学习。
结构化语言。
它产生高效率的程序。
它可以在多种计算机平台上编译。
.Net 框架的一部分。
C# 强大的编程功能
虽然 C# 的构想十分接近于传统高级语言 C 和 C++，是一门面向对象的编程语言，但是它与 Java 非常相似，有许多强大的编程功能，因此得到广大程序员的亲睐。下面列出 C# 一些重要的功能：
布尔条件（Boolean Conditions）
自动垃圾回收（Automatic Garbage Collection）
标准库（Standard Library）
组件版本（Assembly Versioning）
属性（Properties）和事件（Events）
委托（Delegates）和事件管理（Events Management）
易于使用的泛型（Generics）
索引器（Indexers）
条件编译（Conditional Compilation）
简单的多线程（Multithreading）
LINQ (Language Integrated Query,以查询数据库相同的方式操作内存数据)和Lambda (λ匿名函数)表达式
集成 Windows
C# 环境
在这一章中，我们将讨论创建 C# 编程所需的工具。我们已经提到 C# 是 .Net 框架的一部分，且用于编写 .Net 应用程序。因此，在讨论运行 C# 程序的可用工具之前，让我们先了解一下 C# 与 .Net 框架之间的关系。
.Net 框架（.Net Framework）
.Net 框架是一个创新的平台，能帮您编写出下面类型的应用程序：Windows 应用程序
Web 应用程序
Web 服务
.Net 框架应用程序是多平台的应用程序。框架的设计方式使它适用于下列各种语言：C#、C++、Visual Basic、Jscript、COBOL 等等。所有这些语言可以访问框架，彼此之间也可以互相交互。
.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 (Language
Integrated Query)以查询数据库相同的方式操作内存数据
C# 的集成开发环境（Integrated Development Environment - IDE）
微软（Microsoft）提供了下列用于 C# 编程的开发工具：Visual Studio 2010 (VS)
Visual C# 2010 Express (VCE)
Visual Web Developer
后面两个是免费使用的，可从微软官方网址下载。
使用这些工具，您可以编写各种 C# 程序，从简单的命令行应用程序到更复杂的应用程序。
您也可以使用基本的文本编辑器（比如 Notepad）编写 C# 源代码文件，并使用命令行编译器（.NET 框架的一部分）编译代码为组件。
Visual C# Express 和 Visual Web Developer Express 版本是 Visual Studio 的定制版本，且具有相同的外观和感观。它们保留 Visual Studio 的大部分功能。
在本教程中，我们使用的是 Visual C# 2010 Express。
您可以从 Microsoft Visual Studio 上进行下载。它会自动安装在您的机器上。请注意，您需要一个可用的网络连接来完成速成版的安装。
在 Linux 或 Mac OS 上编写 C# 程序
虽然 .NET 框架是运行在 Windows 操作系统上，但是也有一些运行于其它操作系统上的版本可供选择。Mono是 .NET 框架的一个开源版本，它包含了一个 C# 编译器，且可运行于多种操作系统上，比如各种版本的 Linux 和 Mac OS。如需了解更多详情，请访问 Go
Mono。
Mono 的目的不仅仅是跨平台地运行微软 .NET 应用程序，而且也为 Linux 开发者提供了更好的开发工具。
Mono 可运行在多种操作系统上，包括 Android、BSD、iOS、Linux、OS X、Windows、Solaris 和 UNIX。
C# 程序结构
在我们学习 C# 编程语言的基础构件块之前，让我们先看一下 C# 的最小的程序结构，以便作为接下来章节的参考。
C# Hello World 实例
一个 C# 程序主要包括以下部分：命名空间声明（Namespace declaration）
一个 class
Class 方法
Class 属性
一个 Main 方法
语句（Statements）& 表达式（Expressions）
注释
让我们看一个可以打印出 "Hello World" 的简单的代码：
using System;
namespace BeyondApplication
{
class Girl
{
static void Main(string[] args)
{
/* 我的第一个 C# 程序*/
Console.WriteLine("Hello Beyond");
Console.ReadKey();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Hello Beyond
让我们看一下上面程序的各个部分：
程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。
下一行是 namespace 声明。一个 namespace 是一系列的类。BeyondApplication 命名空间包含了类 Girl。
下一行是 class 声明。类 Girl 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，Girl 类只有一个 Main 方法。
下一行定义了 Main 方法，是所有 C# 程序的 入口点。Main 方法说明当执行时 类将做什么动作。
下一行 /*...*/ 将会被编译器忽略，且它会在程序中添加额外的 注释。
Main 方法通过语句 Console.WriteLine("Hello Beyond"); 指定了它的行为。
WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 "Hello, Beyond!"。
最后一行 Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。
以下几点值得注意：
C# 是大小写敏感的。
所有的语句和表达式必须以分号（;）结尾。
程序的执行从 Main 方法开始。
与 Java 不同的是，文件名可以不同于类的名称。
编译 & 执行 C# 程序
如果您使用 Visual Studio.Net 编译和执行 C# 程序，请按下面的步骤进行：启动 Visual Studio。
在菜单栏上，选择 File -> New -> Project。
从模板中选择 Visual C#，然后选择 Windows。
选择 Console Application。
为您的项目制定一个名称，然后点击 OK 按钮。
新项目会出现在解决方案资源管理器（Solution Explorer）中。
在代码编辑器（Code Editor）中编写代码。
点击 Run 按钮或者按下 F5 键来运行程序。会出现一个命令提示符窗口（Command Prompt window），显示 Hello World。
您也可以使用命令行代替 Visual Studio IDE 来编译 C# 程序：
打开一个文本编辑器，添加上面提到的代码。
保存文件为 c#_01.cs
打开命令提示符工具，定位到文件所保存的目录。
键入 csc c#_01.cs 并按下 enter 键来编译代码。(前提是:已经安装了.net framework,并将其添加到环境变量path栏中,如图所示)
如果代码没有错误，命令提示符会进入下一行，并生成c#_01.exe 可执行文件。
接下来，键入 c#_01 来执行程序。
您将看到 "Hello Beyond" 打印在屏幕上。
如图所示:
C# 基本语法
C# 是一种面向对象的编程语言。在面向对象的程序设计方法中，程序由各种相互交互的对象组成。相同种类的对象通常具有相同的类型，或者说，是在相同的 class 中。
例如，以 Rectangle（矩形）对象为例。它具有 length 和 width 属性。
根据设计，它可能需要接受这些属性值、计算面积和显示细节。
让我们来看看一个 Rectangle（矩形）类的实现，并借此讨论 C# 的基本语法：
using System;// 注意是大写的
namespace RectangleApplication
{
class Rectangle
{
// 成员变量
double length;
double width;
public void Acceptdetails()//注意C#中方法名首字母一般要大写
{ // 成员变量和方法,直接用名字调用
length = 4.5;
width = 3.5;
}
public double GetArea()
{
return length * width;
}
public void Display()
{
Console.WriteLine("Length: {0}", length);
Console.WriteLine("Width: {0}", width);
Console.WriteLine("Area: {0}", GetArea());
}
}
class ExecuteRectangle
{
static void Main(string[] args)
{ // 使用new关键字创建对象
Rectangle r = new Rectangle();
r.Acceptdetails();
r.Display();
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Length: 4.5 Width: 3.5 Area: 15.75
运行效果如下:
using 关键字
在任何 C# 程序中的第一条语句都是：using System; // 注意是大写的
using 关键字用于在程序中包含命名空间。一个程序可以包含多个 using 语句。
class 关键字
class 关键字用于声明一个类。
C# 中的注释
注释是用于解释代码。编译器会忽略注释的条目。在 C# 程序中，多行注释以 /* 开始，并以字符 */ 终止，如下所示：/* This program demonstrates The basic syntax of C# programming Language */
单行注释是用 '//' 符号表示。例如：
}//end class Rectangle
成员变量
变量是类的属性或数据成员，用于存储数据。在上面的程序中，Rectangle 类有两个成员变量，名为 length 和 width。
成员函数
函数是一系列执行指定任务的语句。类的成员函数是在类内声明的。我们举例的类 Rectangle 包含了三个成员函数： AcceptDetails、GetArea 和 Display。
实例化一个类
在上面的程序中，类 ExecuteRectangle 是一个包含 Main() 方法和实例化 Rectangle 类的类。
标识符
标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：标识符必须以字母开头，后面可以跟一系列的字母、数字（ 0 - 9 ）或下划线（ _ ）。标识符中的第一个字符不能是数字。
标识符必须不包含任何嵌入的空格或符号，比如 ? - +! @ # % ^ & * ( ) [ ] { } . ; : " ' / \。但是，可以使用下划线（ _ ）。
标识符不能是 C# 关键字。
C# 关键字
关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。
在 C# 中，有些标识符在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字（contextual keywords）。
下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：
| 保留关键字 | ||||||
| abstract | as | base | bool | break | byte | case |
| catch | char | checked | class | const | continue | decimal |
| default | delegate | do | double | else | enum | event |
| explicit | extern | false | finally | fixed | float | for |
| foreach | goto | if | implicit | in | in (generic modifier) | int |
| interface | internal | is | lock | long | namespace | new |
| null | object | operator | out | out (generic modifier) | override | params |
| private | protected | public | readonly | ref | return | sbyte |
| sealed | short | sizeof | stackalloc | static | string | struct |
| switch | this | throw | true | try | typeof | uint |
| ulong | unchecked | unsafe | ushort | using | virtual | void |
| volatile | while | |||||
| 上下文关键字 | ||||||
| add | alias | ascending | descending | dynamic | from | get |
| global | group | into | join | let | orderby | partial (type) |
| partial (method) | remove | select | set |
C# 数据类型
在 C# 中，变量分为以下几种类型：值 类型（Value types）
引用 类型（Reference types）
指针 类型（Pointer types）
值类型（Value types）
值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。值类型直接包含数据。比如 int、char、float，它们分别存储数字、字母、浮点数。
当您声明一个 int 类型时，系统分配内存来存储值。
下表列出了 C# 2010 中可用的值类型：
| 类型 | 描述 | 范围 | 默认值 |
|---|---|---|---|
| bool | 布尔值 | True 或 False | False |
| byte | 8 位无符号整数 | 0 到 255 | 0 |
| char | 16 位 Unicode 字符 | U +0000 到 U +ffff | '' |
| decimal | 128 位精确的十进制值，28-29 有效位数 | (-7.9 x 1028 到 7.9 x 1028) / 100 到 28 | 0.0M |
| double | 64 位双精度浮点型 | (+/-)5.0 x 10-324 到 (+/-)1.7 x 10308 | 0.0D |
| float | 32 位单精度浮点型 | -3.4 x 1038 到 + 3.4 x 1038 | 0.0F |
| int | 32 位有符号整数类型 | -2,147,483,648 到 2,147,483,647 | 0 |
| long | 64 位有符号整数类型 | -923,372,036,854,775,808 到 9,223,372,036,854,775,807 | 0L |
| sbyte | 8 位有符号整数类型 | -128 到 127 | 0 |
| short | 16 位有符号整数类型 | -32,768 到 32,767 | 0 |
| uint | 32 位无符号整数类型 | 0 到 4,294,967,295 | 0 |
| ulong | 64 位无符号整数类型 | 0 到 18,446,744,073,709,551,615 | 0 |
| ushort | 16 位无符号整数类型 | 0 到 65,535 | 0 |
表达式 sizeof(type) 产生以字节为单位存储对象或类型的存储尺寸。
下面举例获取任何机器上 int 类型的存储尺寸：
namespace DataTypeApplication
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Size of int: {0}", sizeof(int));
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Size of int: 4
运行效果如下:
引用类型（Reference types）
引用类型 不包含存储在变量中的实际数据，但它们包含对变量的引用。换句话说，它们指的是一个内存位置。
?????使用多个变量时，引用类型可以指向一个内存位置。???Excuse Me???
引用位置保存在栈中，数据存储在堆中???Excuse Me???
换句话说，它们指的是一个内存位置。
?????使用多个变量（栈引用）时，引用类型可以指向一个内存位置（堆）。?????
如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。
内置的 引用类型有：object、dynamic 和 string。
对象（Object）类型
对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。
对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。
但是，在分配值之前，需先进行类型转换。
当一个值类型转换为对象类型时，则被称为 装箱；
另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。 注:与Java类同
object obj; obj = 100; // 这是装箱
动态（Dynamic）类型
您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。声明动态类型的语法：
dynamic <variable_name> = value;
例如：
dynamic d = 20;
动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。
字符串（String）类型
字符串（String）类型 允许您给变量分配任何字符串值。字符串（String）类型是 System.String 类的别名。它是从对象（Object）类型派生的。
字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。
例如：
String str = "w3cschool.cn";
一个 @引号字符串： 形似Objective-C
@"w3cschool.cn";
C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待，比如：
string str = @"C:\Windows";
等价于：
string str = "C:\\Windows";
@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。
string str = @"<script type=""text/javascript""> <!-- --> </script>";
用户自定义引用类型有：class、interface 或 delegate。后续会再细讲
指针类型（Pointer types）
指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。声明指针类型的语法：
type* identifier;
例如：
char* cptr; int* iptr;
后续会再细讲
C# 类型转换
类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型。在 C# 中，类型铸造有两种形式：
隐式类型转换 - 这些转换是 C# 默认的以安全方式进行的转换。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
显式类型转换 - 这些转换是通过用户使用预定义的函数显式完成的。显式转换需要强制转换运算符。
下面的实例显示了一个显式的类型转换：
namespace TypeConversionApplication
{
class ExplicitConversion
{
static void Main(string[] args)
{
double d = 520.67;
int i;
// 强制转换 double 为 int,会损失精度
i = (int)d;
Console.WriteLine(i);
Console.ReadKey();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
520
C# 类型转换方法
C# 提供了下列内置的类型转换方法：| 序号 | 方法 & 描述 |
|---|---|
| 1 | ToBoolean 如果可能的话，把类型转换为布尔型。 |
| 2 | ToByte 把类型转换为字节类型。 |
| 3 | ToChar 如果可能的话，把类型转换为单个 Unicode 字符类型。 |
| 4 | ToDateTime 把类型（整数或字符串类型）转换为 日期-时间 结构。 |
| 5 | ToDecimal 把浮点型或整数类型转换为十进制类型。 |
| 6 | ToDouble 把类型转换为双精度浮点型。 |
| 7 | ToInt16 把类型转换为 16 位整数类型。 |
| 8 | ToInt32 把类型转换为 32 位整数类型。 |
| 9 | ToInt64 把类型转换为 64 位整数类型。 |
| 10 | ToSbyte 把类型转换为有符号字节类型。 |
| 11 | ToSingle 把类型转换为小浮点数类型。 |
| 12 | ToString 把类型转换为字符串类型。 |
| 13 | ToType 把类型转换为指定类型。 |
| 14 | ToUInt16 把类型转换为 16 位无符号整数类型。 |
| 15 | ToUInt32 把类型转换为 32 位无符号整数类型。 |
| 16 | ToUInt64 把类型转换为 64 位无符号整数类型。 |
namespace TypeConversionApplication
{
class StringConversion
{
static void Main(string[] args)
{
int i = 67;
float f = 52.067f; //注意后面的f
double d = 13.14;
bool b = true; //注意这个布尔 true
Console.WriteLine(i.ToString());
Console.WriteLine(f.ToString());
Console.WriteLine(d.ToString());
Console.WriteLine(b.ToString());
Console.ReadKey();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
67 52.067 13.14 True //注意这个变首字母大写了
C# 变量
一个变量只不过是一个供程序操作的存储区的名字。在 C# 中，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。
C# 中提供的基本的值类型大致可以分为以下几类：
| 类型 | 举例 |
|---|---|
| 整数类型 | sbyte、byte、short、ushort、int、uint、long、ulong 和 char |
| 浮点型 | float 和 double |
| 十进制类型 | decimal |
| 布尔类型 | true 或 false 值，指定的值 |
| 空类型 | 可为空值的数据类型 |
C# 中的变量定义
C# 中变量定义的语法：<data_type> <variable_list>;
在这里，data_type 必须是一个有效的 C# 数据类型，可以是 char、int、float、double 或其他用户自定义的数据类型。variable_list 可以由一个或多个用逗号分隔的标识符名称组成。
一些有效的变量定义如下所示：
int i, j, k; char c, ch; float f, salary; double d;
您可以在变量定义时进行初始化：
int i = 100;
C# 中的变量初始化
变量通过在等号后跟一个常量表达式进行初始化（赋值）。初始化的一般形式为：variable_name = value;
变量可以在声明时被初始化（指定一个初始值）。
初始化由一个等号后跟一个常量表达式组成，如下所示：
<data_type> <variable_name> = value;
一些实例：
int d = 3, f = 5; /* 初始化 d 和 f. */ byte z = 22; /* 初始化 z. */ double pi = 3.14159; /* 声明 pi 的近似值 */ char x = 'x'; /* 变量 x 的值为 'x' */
正确地初始化变量是一个良好的编程习惯，否则有时程序会产生意想不到的结果。
请看下面的实例，使用了各种类型的变量：
namespace VariableDefinition
{
class Program
{
static void Main(string[] args)
{ // 仅仅声明变量
short a;
int b ;
double c;
/* 实际初始化 */
a = 6;
b = 7;
c = a + b;
Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
a = 6, b = 7, c = 13
接受来自用户的值
System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。例如：
int num; num = Convert.ToInt32(Console.ReadLine());
函数 Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，因为 Console.ReadLine() 返回值是System.String类型。
C# 中的 Lvalues 和 Rvalues
C# 中的两种表达式：lvalue：lvalue 表达式可以出现在赋值语句的左边或右边。
rvalue：rvalue 表达式只能出现在赋值语句的右边，不能出现在赋值语句的左边。
变量是 lvalue 的，所以可以出现在赋值语句的左边。
数值是 rvalue 的，因此不能被赋值，不能出现在赋值语句的左边。
下面是一个有效的语句：
int g = 20;
下面是一个无效的语句，会产生编译时错误：
10 = 20;
C# 常量
常量是固定值，程序执行期间不会改变。常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。
常量可以被当作常规的变量，只是它们的值在定义后不能被修改。
整数常量
整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，没有前缀则表示十进制。
整数常量也可以有后缀，可以是 U 和 L 的组合，
其中，U 和 L 分别表示 unsigned 和 long。后缀可以是大写或者小写，多个后缀以任意顺序进行组合。
这里有一些整数常量的实例：
212 /* 合法 */ 215u /* 合法 */ 0xFeeL /* 合法 */ 078 /* 非法：8 不是一个八进制数字 */ 032UU /* 非法：不能重复后缀 */
以下是各种类型的整数常量的实例：
85 /* 十进制 */ 0213 /* 八进制 */ 0x4b /* 十六进制 */ 30 /* int */ 30u /* 无符号 int */ 30l /* long */ 30ul /* 无符号 long */
浮点常量
一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。
这里有一些浮点常量的实例：
3.14159 /* 合法 */ 314159E-5L /* 合法 */ 510E /* 非法：不完全指数 */ 210f /* 非法：没有小数或指数 */ .e55 /* 非法：缺少整数或小数 */
使用小数形式表示时，必须包含小数点、指数或同时包含两者。
使用指数形式表示时，必须包含整数部分、小数部分或同时包含两者。
有符号的指数是用 e 或 E 表示的。
字符常量
字符常量是括在单引号里，例如，'x'，且可存储在一个简单的字符类型变量中。一个字符常量可以是一个普通字符（例如 'x'）、一个转义序列（例如 '\t'）或者一个通用字符（例如 '\u02C0'）。
在 C# 中有一些特定的字符，当它们的前面带有反斜杠时有特殊的意义，可用于表示换行符（\n）或制表符 tab（\t）等。
在这里，列出一些转义序列码：
| 转义序列 | 含义 |
|---|---|
| \\ | \ 字符 |
| \' | ' 字符 |
| \" | " 字符 |
| \? | ? 字符 |
| \a | Alert 或 bell |
| \b | 退格键（Backspace） |
| \f | 换页符（Form feed） |
| \n | 换行符（Newline） |
| \r | 回车 |
| \t | 水平制表符 tab |
| \v | 垂直制表符 tab |
| \ooo | 一到三位的八进制数 |
| \xhh . . . | 一个或多个数字的十六进制数 |
namespace EscapeChar
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello\tWorld\n\n");
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Hello World
字符串常量
字符常量是括在双引号 "" 里，或者是括在 @"" 里。字符串常量包含的字符与字符常量相似，可以是：普通字符、转义序列和通用字符
使用字符串常量时，可以把一个很长的行拆成多个行，可以使用空格分隔各个部分。
这里是一些字符串常量的实例。下面所列的各种形式表示相同的字符串。
"hello, dear" "hello, \ dear" "hello, " "d" "ear" //这个是使用空格 分隔各个部分 @"hello dear"
定义常量
常量是使用 const 关键字来定义的 。定义一个常量的语法如下：const <data_type> <constant_name> = value;
下面的代码演示了如何在程序中定义和使用常量：
using System;
namespace DeclaringConstants
{
class Program
{
static void Main(string[] args)
{
const double pi = 3.14159; // 常量声明
double r;
Console.WriteLine("Enter Radius: ");
r = Convert.ToDouble(Console.ReadLine());
double areaCircle = pi * r * r;
Console.WriteLine("Radius: {0}, Area: {1}", r, areaCircle);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Enter Radius: 3 Radius: 3, Area: 28.27431
C# 运算符
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，分类如下：
算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
杂项运算符
本教程将逐一讲解算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符及其他运算符。
算术运算符
下表显示了 C# 支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 把两个操作数相加 | A + B 将得到 30 |
| - | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
| * | 把两个操作数相乘 | A * B 将得到 200 |
| / | 分子除以分母 | B / A 将得到 2 |
| % | 取模运算符，整除后的余数 | B % A 将得到 0 |
| ++ | 自增运算符，整数值增加 1 | A++ 将得到 11 |
| -- | 自减运算符，整数值减少 1 | A-- 将得到 9 |
实例
请看下面的实例，了解 C# 中所有可用的算术运算符：using System;
namespace OperatorsApplication
{
class Program
{
static void Main(string[] args)
{
int a = 21;
int b = 10;
int c;
c = a + b;
Console.WriteLine("Line 1 - c 的值是 {0}", c);
c = a - b;
Console.WriteLine("Line 2 - c 的值是 {0}", c);
c = a * b;
Console.WriteLine("Line 3 - c 的值是 {0}", c);
c = a / b;
Console.WriteLine("Line 4 - c 的值是 {0}", c);
c = a % b;
Console.WriteLine("Line 5 - c 的值是 {0}", c);
c = a++;
Console.WriteLine("Line 6 - c 的值是 {0}", c);
c = a--;
Console.WriteLine("Line 7 - c 的值是 {0}", c);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - c 的值是 31 Line 2 - c 的值是 11 Line 3 - c 的值是 210 Line 4 - c 的值是 2 Line 5 - c 的值是 1 Line 6 - c 的值是 21 Line 7 - c 的值是 22
关系运算符
下表显示了 C# 支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果相等则条件为真。 | (A == B) 不为真。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 | (A > B) 不为真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 | (A < B) 为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (A >= B) 不为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (A <= B) 为真。 |
实例
请看下面的实例，了解 C# 中所有可用的关系运算符：using System;
class Program{
static void Main(string[] args){
int a = 21;
int b = 10;
if (a == b){
Console.WriteLine("Line 1 - a 等于 b");
}else{
Console.WriteLine("Line 1 - a 不等于 b");
}
if (a < b){ Console.WriteLine("Line 2 - a 小于 b"); }else{ Console.WriteLine("Line 2 - a 不小于 b"); } if (a > b){
Console.WriteLine("Line 3 - a 大于 b");
}else{
Console.WriteLine("Line 3 - a 不大于 b");
}
/* 改变 a 和 b 的值 */
a = 5;
b = 20;
if (a <= b) { Console.WriteLine("Line 4 - a 小于或等于 b"); } if (b >= a)
{
Console.WriteLine("Line 5 - b 大于或等于 a");
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - a 不等于 b Line 2 - a 不小于 b Line 3 - a 大于 b Line 4 - a 小于或等于 b Line 5 - b 大于或等于 a
逻辑运算符
下表显示了 C# 支持的所有逻辑运算符。假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 称为逻辑与运算符。如果两个操作数都非零，则条件为真。 | (A && B) 为假。 |
| || | 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 | (A || B) 为真。 |
| ! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |
实例
请看下面的实例，了解 C# 中所有可用的逻辑运算符：using System;
namespace OperatorsApplication{
class Program{
static void Main(string[] args){
bool a = true;
bool b = true;
if (a && b){
Console.WriteLine("Line 1 - 条件全为真");
}
if (a || b){
Console.WriteLine("Line 2 - 条件至少有一个为真");
}
/* 改变 a 和 b 的值 */
a = false;
b = true;
if (a && b){
Console.WriteLine("Line 3 - 条件为真");
}else{
Console.WriteLine("Line 3 - 条件不全为真");
} if (!(a && b)){
Console.WriteLine("Line 4 - 条件ab至少有一个为假");
}
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - 条件全为真 Line 2 - 条件至少有一个为真 Line 3 - 条件不全为真 Line 4 - 条件ab至少有一个为假
位运算符
位运算符作用于位，并逐位执行操作。&、 | 和 ^ (异或)的真值表如下所示：| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
下表列出了 C# 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。 | (A & B) 将得到 12，即为 0000 1100 |
| | | 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。 | (A | B) 将得到 61，即为 0011 1101 |
| ^ | 如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。 | (A ^ B) 将得到 49，即为 0011 0001 |
| ~ | 二进制补码运算符是一元运算符，具有"翻转"位效果。 | (~A ) 将得到 -61，即为 1100 0011，2 的补码形式，带符号的二进制数。如下 |
| << | 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 | A << 2 将得到 240，即为 1111 0000 |
| >> | 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 | A >> 2 将得到 15，即为 0000 1111 |
/*
1. 计算机里的运算都按照补码进行的
2. 正数原码就是补码
6的原码/补码:0000 0110
6按位取反以后,得到了一个补码:1111 1001,
这是一个补码,将这个补码再转换成原码就是-7
4. 负数的补码 = 原码取反 + 1
5. 那么负数的原码 = 补码 - 1 后,再取反
所以:补码(1111 1001) - 1 就是1111 1000,
然后再取反(符号位不变)1000 0111也就是 -7
*/
实例
请看下面的实例，了解 C# 中所有可用的位运算符：using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
Console.WriteLine("Line 1 - c 的值是 {0}", c );
c = a | b; /* 61 = 0011 1101 */
Console.WriteLine("Line 2 - c 的值是 {0}", c);
c = a ^ b; /* 49 = 0011 0001 */
Console.WriteLine("Line 3 - c 的值是 {0}", c);
c = ~a; /*-61 = 1100 0011 */
Console.WriteLine("Line 4 - c 的值是 {0}", c);
c = a << 2; /* 240 = 1111 0000 */ Console.WriteLine("Line 5 - c 的值是 {0}", c); c = a >> 2; /* 15 = 0000 1111 */
Console.WriteLine("Line 6 - c 的值是 {0}", c);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - c 的值是 12 Line 2 - c 的值是 61 Line 3 - c 的值是 49 Line 4 - c 的值是 -61 Line 5 - c 的值是 240 Line 6 - c 的值是 15
赋值运算符
下表列出了 C# 支持的赋值运算符：| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，把右边操作数的值赋给左边操作数 | C = A + B 将把 A + B 的值赋给 C |
| += | 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 | C += A 相当于 C = C + A |
| -= | 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 | C -= A 相当于 C = C - A |
| *= | 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 | C *= A 相当于 C = C * A |
| /= | 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 | C /= A 相当于 C = C / A |
| %= | 求模且赋值运算符，求两个操作数的模赋值给左边操作数 | C %= A 相当于 C = C % A |
| <<= | 左移且赋值运算符 | C <<= 2 等同于 C = C << 2 |
| >>= | 右移且赋值运算符 | C >>= 2 等同于 C = C >> 2 |
| &= | 按位与且赋值运算符 | C &= 2 等同于 C = C & 2 |
| ^= | 按位异或且赋值运算符 | C ^= 2 等同于 C = C ^ 2 |
| |= | 按位或且赋值运算符 | C |= 2 等同于 C = C | 2 |
实例
请看下面的实例，了解 C# 中所有可用的赋值运算符：using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 21;
int c;
c = a;
Console.WriteLine("Line 1 - = c 的值 = {0}", c);
c += a;
Console.WriteLine("Line 2 - += c 的值 = {0}", c);
c -= a;
Console.WriteLine("Line 3 - -= c 的值 = {0}", c);
c *= a;
Console.WriteLine("Line 4 - *= c 的值 = {0}", c);
c /= a;
Console.WriteLine("Line 5 - /= c 的值 = {0}", c);
c = 200;
c %= a;
Console.WriteLine("Line 6 - %= c 的值 = {0}", c);
c <<= 2; Console.WriteLine("Line 7 - <<= c 的值 = {0}", c); c >>= 2;
Console.WriteLine("Line 8 - >>= c 的值 = {0}", c);
c &= 2;
Console.WriteLine("Line 9 - &= c 的值 = {0}", c);
c ^= 2;
Console.WriteLine("Line 10 - ^= c 的值 = {0}", c);
c |= 2;
Console.WriteLine("Line 11 - |= c 的值 = {0}", c);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - = c 的值 = 21 Line 2 - += c 的值 = 42 Line 3 - -= c 的值 = 21 Line 4 - *= c 的值 = 441 Line 5 - /= c 的值 = 21 Line 6 - %= c 的值 = 11 Line 7 - <<= c 的值 = 44 Line 8 - >>= c 的值 = 11 Line 9 - &= c 的值 = 2 Line 10 - ^= c 的值 = 0 Line 11 - |= c 的值 = 2
杂项运算符
下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和三目运算符 a?b:c
运算符描述实例
sizeof()返回数据类型的大小。sizeof(int)，将返回 4.
typeof()返回 class 的类型。typeof(StreamReader);
&返回变量的地址。&a; 将得到变量的实际地址。
*变量的指针。*a; 将指向一个变量。
? :条件表达式 如果条件为真 ? 则为 X : 否则为 Y
is判断对象是否为某一类型。
If( PingPong is Sport) // 检查 乒乓 是否是 Sport 类的一个对象。
as强制转换，即使转换失败也不会抛出异常。
Object obj = new StringReader("Hello");
StringReader r = obj as StringReader;
实例
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
/* sizeof 运算符的实例 */
Console.WriteLine("int 的大小是 {0}", sizeof(int));
Console.WriteLine("short 的大小是 {0}", sizeof(short));
Console.WriteLine("double 的大小是 {0}", sizeof(double));
/* 三元运算符符的实例 */
int a, b;
a = 6;
b = (a == 7) ? 1314 : 520;
Console.WriteLine("b 的值是 {0}", b);
b = (a == 6) ? 1314 : 520;
Console.WriteLine("b 的值是 {0}", b);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 520b 的值是 1314
C# 中的运算符优先级
运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。
下表将按运算符优先级从高到低列出各个运算符，
具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。
在表达式中，较高优先级的运算符会优先被计算。
| 类别 | 运算符 | 结合性 |
|---|---|---|
| 后缀 | () [] -> . ++ - - | 从左到右 |
| 一元 | + - ! ~ ++ - - (type)* & sizeof | 从右到左 |
| 乘除 | * / % | 从左到右 |
| 加减 | + - | 从左到右 |
| 移位 | << >> | 从左到右 |
| 关系 | < <= > >= | 从左到右 |
| 相等 | == != | 从左到右 |
| 位与 AND | & | 从左到右 |
| 位异或 XOR | ^ | 从左到右 |
| 位或 OR | | | 从左到右 |
| 逻辑与 AND | && | 从左到右 |
| 逻辑或 OR | || | 从左到右 |
| 条件 | ?: | 从右到左 |
| 赋值 | = += -= *= /= %=>>= <<= &= ^= |= | 从右到左 |
| 逗号 | , | 从左到右 |
实例
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 20;
int b = 10;
int c = 15;
int d = 5;
int e;
e = (a + b) * c / d; // ( 30 * 15 ) / 5
Console.WriteLine("(a + b) * c / d 的值是 {0}", e);
e = ((a + b) * c) / d; // (30 * 15 ) / 5
Console.WriteLine("((a + b) * c) / d 的值是 {0}", e);
e = (a + b) * (c / d); // (30) * (15/5)
Console.WriteLine("(a + b) * (c / d) 的值是 {0}", e);
e = a + (b * c) / d; // 20 + (150/5)
Console.WriteLine("a + (b * c) / d 的值是 {0}", e);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
(a + b) * c / d 的值是 90 ((a + b) * c) / d 的值是 90 (a + b) * (c / d) 的值是 90 a + (b * c) / d 的值是 50
C# 判断
判断结构要求程序员指定一个或多个要评估或测试的条件，以及条件为真时要执行的if语句（必需的）和条件为假时要执行的else语句（可选的）。
判断语句
C# 提供了以下类型的判断语句。点击链接查看每个语句的细节。| 语句 | 描述 |
|---|---|
| if 语句 | 一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。 |
| if...else 语句 | 一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。 |
| 嵌套 if 语句 | 您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。 |
| switch 语句 | 一个 switch 语句允许测试一个变量等于多个值时的情况。 |
| 嵌套 switch 语句 | 您可以在一个 switch 语句内使用另一个 switch 语句。 |
? : 三目运算符
我们已经在前面的章节中讲解了 条件运算符 ? :，可以用来替代 if...else 语句。它的一般形式如下：Exp1 ? Exp2 : Exp3;
其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和位置。
? 表达式的值是由 Exp1 决定的。
如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。
如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。
C# if 语句
一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。
语法
C# 中 if 语句的语法：if(boolean_expression)
{
/* 如果布尔表达式为真将执行的语句 */
}如果布尔表达式为 true，则 if 语句内的代码块将被执行。如果布尔表达式为 false，则 if 语句结束后的第一组代码（闭括号后）将被执行。
实例
using System;
namespace DecisionMaking
{
class Program
{
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 6;
/* 使用 if 语句检查布尔条件 */
if (a < 7)
{
/* 如果条件为真，则输出下面的语句 */
Console.WriteLine("a 小于 7");
}
Console.WriteLine("a 的值是 {0}", a);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
a 小于 7 a 的值是 6
C# if...else 语句
一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
语法
C# 中 if...else 语句的语法：if(boolean_expression)
{
/* 如果布尔表达式为真将执行的语句 */
}else{
/* 如果布尔表达式为假将执行的语句 */
}如果布尔表达式为 true，则执行 if 块内的代码。如果布尔表达式为 false，则执行 else 块内的代码。
实例
using System;
namespace DecisionMaking
{
class Program
{
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 1314;
/* 检查布尔条件 */
if (a <= 520){
/* 如果条件为真，则输出下面的语句 */
Console.WriteLine("a 小于等于 520");
}else{
/* 如果条件为假，则输出下面的语句 */
Console.WriteLine("a 大于 520");
}
Console.WriteLine("a 的值是 {0}", a);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
a 大于 520a 的值是 1314
if...else if...else 语句
一个 if 语句后可跟一个可选的 else if...else 语句，这可用于测试多种条件。当使用 if...else if...else 语句时，以下几点需要注意：
一个 if 后可跟零个或一个 else，它必须在任何一个 else if 之后。
一个 if 后可跟零个或多个 else if，它们必须在 else 之前。
一旦某个 else if 匹配成功，其他的 else if 或 else 将不会被测试。
语法
C# 中的 if...else if...else 语句的语法：if(boolean_expression 1){
/* 当布尔表达式 1 为真时执行 */
}else if( boolean_expression 2){
/* 当布尔表达式 2 为真时执行 */
}else if( boolean_expression 3){
/* 当布尔表达式 3 为真时执行 */
}else {
/* 当上面条件都不为真时执行 */
}
实例
using System;
namespace DecisionMaking
{
class Program{
static void Main(string[] args){
/* 局部变量定义 */
int a = 100;
/* 检查布尔条件 */
if (a == 10){
/* 如果 if 条件为真，则输出下面的语句 */
Console.WriteLine("a 的值是 10");
}else if (a == 20){
/* 如果 else if 条件为真，则输出下面的语句 */
Console.WriteLine("a 的值是 20");
}else if (a == 30){
/* 如果 else if 条件为真，则输出下面的语句 */
Console.WriteLine("a 的值是 30");
}else{
/* 如果上面条件都不为真，则输出下面的语句 */
Console.WriteLine("没有匹配的值");
}
Console.WriteLine("a 的准确值是 {0}", a);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：-_-! 没有匹配的值,还要我打这么多代码?!
没有匹配的值 a 的准确值是 100
C# 嵌套 if 语句
在 C# 中，嵌套 if-else 语句是合法的，这意味着您可以在一个 if 或 else if 语句内使用另一个 if 或 elseif语句。
语法
C# 中 嵌套 if 语句的语法：if( boolean_expression 1){
/* 当布尔表达式 1 为真时执行 */
if(boolean_expression 2){
/* 当布尔表达式 2 为真时执行 */
}
}您可以嵌套 else if...else，方式与嵌套 if 语句相似。
实例
using System;
namespace DecisionMaking
{
class Program
{
static void Main(string[] args){
//* 局部变量定义 */
int a = 100;
int b = 200;
/* 检查布尔条件 */
if (a == 100){
/* 如果条件为真，则检查下面的条件 */
if (b == 200){
/* 如果条件为真，则输出下面的语句 */
Console.WriteLine("a 的值是 100，且 b 的值是 200");
}
}
Console.WriteLine("a 的准确值是 {0}", a);
Console.WriteLine("b 的准确值是 {0}", b);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
a 的值是 100，且 b 的值是 200 a 的准确值是 100 a 的准确值是 200
C# switch 语句
一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。
语法
C# 中 switch 语句的语法：switch(expression){
case constant-expression :
statement(s);
break; // break千万不要忘记写
case constant-expression :
statement(s);
break; // break千万不要忘记写
/* 您可以有任意数量的 case 语句 */
default : /* 可选的 */
statement(s);
break;
}switch 语句必须遵循下面的规则：
switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个
class 类型，其中 class 有一个单一的转换函数???将其转换为整型或枚举类型。
在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值 和 一个冒号。
case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量。
当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
不是每一个 case 都需要包含 break。如果 case 语句为空，则可以不包含 break，控制流将会 继续 后续的
case，直到遇到 break 为止。
C# 不允许从一个开关部分 继续执行到 下一个开关部分。如果 case 语句中有处理语句，则必须包含 break或其他跳转语句。
一个 switch 语句可以有一个可选的 default case，出现在
switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句同样是必需加的。
C# 不支持从一个 case 标签显式贯穿到另一个 case 标签。
如果要使 C# 支持从一个 case 标签显式贯穿到另一个 case 标签，可以使用goto 一个 switch-case 或 goto default
实例
using System;
namespace DecisionMaking{
class Program{
static void Main(string[] args){
/* 局部变量定义 */
char cup = 'E';
switch (cup){
case 'A':
Console.WriteLine("贫乳赛高！");
break;
case 'B': // 注意这儿穿透了
case 'C':
Console.WriteLine("普普通通");
break;
case 'D':
Console.WriteLine("合格了");
break;
case 'E':
Console.WriteLine("完美的罩杯");
break;
default:
Console.WriteLine("逆天的罩杯");
break;
}
Console.WriteLine("妳的罩杯是 {0}", cup);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
完美的罩杯 妳的罩杯是 E
C# 嵌套 switch 语句
您可以把一个 switch 作为一个外部 switch 的语句序列的一部分，即可以在一个 switch 语句内使用另一个 switch 语句。即使内部和外部switch 的 case 常量包含共同的值，也没有矛盾。
语法
C# 中 嵌套 switch 语句的语法：switch(ch1)
{
case 'A':
printf("这个 A 是外部 switch 的一部分" );
switch(ch2)
{
case 'A':
printf("这个 A 是内部 switch 的一部分" );
break;
case 'B': /* 内部 B case 代码 */
}
break;
case 'B': /* 外部 B case 代码 */
}
实例
using System;
namespace DecisionMaking
{
class Program
{
static void Main(string[] args)
{
int a = 100;
int b = 200;
switch (a)
{
case 100:
Console.WriteLine("这是外部 switch 的一部分");
switch (b)
{
case 200:
Console.WriteLine("这是内部 switch 的一部分");
break;
}
break;
}
Console.WriteLine("a 的准确值是 {0}", a);
Console.WriteLine("b 的准确值是 {0}", b);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
这是外部 switch 的一部分 这是内部 switch 的一部分 a 的准确值是 100 b 的准确值是 200
C# 循环
有的时候，可能需要多次执行同一块代码。一般情况下，语句是顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。编程语言提供了允许更为复杂的执行路径的多种控制结构。
循环语句允许我们多次执行一个语句或语句组
循环类型
C# 提供了以下几种循环类型。点击链接查看每个类型的细节。| 循环类型 | 描述 |
|---|---|
| while 循环 | 当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。 |
| for 循环 | 多次执行一个语句序列，简化管理循环变量的代码。 |
| do...while 循环 | 除了它是在循环主体结尾测试条件外，其他与 while 语句类似。 |
| 嵌套循环 | 您可以在 while、for 或 do..while 循环内使用一个或多个循环。 |
循环控制语句
循环控制语句更改执行的正常序列。当执行离开一个范围时，所有在该范围中创建的自动对象都会被销毁。C# 提供了下列的控制语句。点击链接查看每个语句的细节。
| 控制语句 | 描述 |
|---|---|
| break 语句 | 终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。 |
| continue 语句 | 引起循环跳过主体的剩余部分，立即重新开始测试条件。 |
无限循环
如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
for (; ; )
{
Console.WriteLine("Hey! I am Trapped");
}
}
}
}当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，程序员偏向于使用 for(;;) 结构来表示一个无限循环。
C# while 循环
只要给定的条件为真，C# 中的 while 循环语句会重复执行一个目标语句。
语法
C# 中 while 循环的语法：while(condition)
{
statement(s);
}在这里，statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。
condition 可以是任意的表达式，当为任意非零值时都为真。当条件为真时执行循环。
当条件为假时，程序流将继续执行紧接着循环的下一条语句。
实例
using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 5;
/* while 循环执行 */
while (a <= 7)
{
Console.WriteLine("a 的值： {0}", a);
a++;
}
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
a 的值： 5 a 的值： 6 a 的值： 7
C# for 循环
一个 for 循环是一个允许您编写一个执行特定次数的循环的重复控制结构。
语法
C# 中 for 循环的语法：for ( init; condition; increment )
{
statement(s);
}下面是 for 循环的控制流：
init 会首先被执行，且只会执行一次。这一步允许您声明并初始化任何循环控制变量。您也可以不在这里写任何语句，只要有一个分号出现即可。
接下来，会判断 condition。如果为真，则执行循环主体。如果为假，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。
在执行完 for 循环主体后，控制流会跳回上面的 increment 语句。该语句允许您更新循环控制变量。该语句可以留空，只要在条件后有一个分号出现即可。
条件再次被判断。如果为真，则执行循环，这个过程会不断重复（循环主体，然后增加步值，再然后重新判断条件）。在条件变为假时，for 循环终止。好绕,绕晕了>_<
实例
using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
/* for 循环执行 */
for (int a = 5; a <= 7; a++)
{
Console.WriteLine("a 的值： {0}", a);
}
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
a 的值： 5 a 的值： 6 a 的值： 7
C# do...while 循环
不像 for 和 while 循环，它们是在循环头部测试循环条件。do...while 循环是在循环的尾部检查它的条件。do...while 循环与 while 循环类似，但是 do...while 循环会确保至少执行一次循环。
语法
C# 中 do...while 循环的语法：do
{
statement(s);
}while( condition );请注意，条件表达式出现在循环的尾部，所以循环中的 statement(s) 会在条件被测试之前至少执行一次。
如果条件为真，控制流会跳转回上面的 do，然后重新执行循环中的 statement(s)。这个过程会不断重复，直到给定条件变为假为止。
实例
using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 5;
/* do 循环执行 */
do
{
Console.WriteLine("a 的值： {0}", a);
a = a + 1;
} while (a <= 7);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
a 的值： 5 a 的值： 6 a 的值： 7
C# 嵌套循环
C# 允许在一个循环内使用另一个循环，下面演示几个实例来说明这个概念。
语法
C# 中 嵌套 for 循环 语句的语法：for ( init; condition; increment )
{
for ( init; condition; increment ) { statement(s); }statement(s);
}
C# 中 嵌套 while 循环 语句的语法：
while(condition)
{
while(condition) { statement(s); }statement(s);
}
C# 中 嵌套 do...while 循环 语句的语法：
do
{
statement(s);
do
{
statement(s);
}while( condition );
}while( condition );关于嵌套循环有一点值得注意，您可以在任何类型的循环内嵌套其他任何类型的循环。比如，一个 for 循环可以嵌套在一个 while 循环内，反之亦然。
实例
下面的程序使用了一个嵌套的 for 循环来查找 2 到 100 中的质数：using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
/* 局部变量定义 */
int i, j;
for (i = 2; i < 100; i++)
{
for (j = 2; j <= (i / j); j++)
if ((i % j) == 0) break; // 如果找到，则不是质数
if (j > (i / j))
Console.WriteLine("{0} 是质数", i);
}
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
2 是质数 3 是质数 5 是质数 7 是质数 11 是质数 13 是质数 17 是质数 19 是质数 23 是质数 29 是质数 31 是质数 37 是质数 41 是质数 43 是质数 47 是质数 53 是质数 59 是质数 61 是质数 67 是质数 71 是质数 73 是质数 79 是质数 83 是质数 89 是质数 97 是质数
不是质数的,肯定 可以分解成两个数:一个小于 sqrt(a), 一个大于sqrt(a)
代码如下:
// 注意是大写的
// 注意:C#里方法名首字母一般大写
using System;
namespace DecisionApplication{
class Program{
static void Main(string[] args){
// 2~100的素数
int j;
for(int i = 2;i < 100; i++){
// 不是素数的,肯定 可以分解成两个数:一个小于 sqrt(a), 一个大于sqrt(a)
double sqrtDouble = System.Math.Sqrt(i);
// 强转成int
int sqrtInt = Convert.ToInt32(sqrtDouble);
for(j = 2;j <= sqrtInt; j++){
if(i % j == 0){
//Console.WriteLine("a = {0},不是素数",i);
break;
}
}
if(j >= sqrtInt + 1){
Console.WriteLine("a = {0} 是素数",i);
}
}
Console.ReadLine();
}
}
}
C# break 语句
C# 中 break 语句有以下两种用法：当 break 语句出现在一个循环内时，循环会立即终止，且程序流将继续执行紧接着循环的下一条语句。
它可用于终止 switch 语句中的一个 case。
如果您使用的是嵌套循环（即一个循环内嵌套另一个循环），break 语句会停止执行最内层的循环，然后开始执行该块之后的下一行代码。
语法
C# 中 break 语句的语法：break;
实例
using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 5;
/* while 循环执行 */
while (a < 2006)
{
Console.WriteLine("a 的值： {0}", a);
a++;
if (a > 7)
{
/* 使用 break 语句终止 loop */
break;}
}
Console.ReadLine();
}
}
}
当上面的代码被编译和执行时，它会产生下列结果：
a 的值： 5 a 的值： 6 a 的值： 7
C# continue 语句
C# 中的 continue 语句有点像 break 语句。但它不是强迫终止，continue 会跳过当前循环中的代码，强迫开始下一次循环。对于 for 循环，continue 语句会导致执行条件测试和循环增量部分。对于 while 和 do...while 循环，continue 语句会导致程序控制回到条件测试上。
语法
C# 中 continue 语句的语法：continue;
实例
using System;
namespace Loops
{
class Program
{
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 5;
/* do 循环执行 */
do
{
if (a == 5)
{
/* 跳过迭代 */
a = a + 1;
continue;}
Console.WriteLine("a 的值： {0}", a);
a++;
} while (a < 8);
Console.ReadLine();
}
}
}
当上面的代码被编译和执行时，它会产生下列结果：
a 的值： 6 a 的值： 7
未完待续,下一章节,つづく
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 【C#基础】【语法02】课堂作业题 01-08
- 【C#基础】【语法03】课堂作业题 01-11
- 【C#基础】【语法04】课堂作业题 01-08
- 【C#基础】【语法02】课后作业题 01-08
- 【C#基础】【语法03】课后作业题 01-06
- 【C#基础】【语法01】课堂作业题 01-07
- 【C#基础】【语法01】课后作业题 01-05
- 0712c#第一天C#语言基础介绍与语法入门
- C++语法基础01--类（class)
- C#基础语法(第一天)
- Python语法基础01.注释
- C# 2008 学习笔记 - LINQ基础（三）- LINQ语法
- C#语法基础
- [code static]C#基础语法
- C#基础部分之语法和基础知识
- 一、C#学习基础篇----基础语法
- Python3 与 C# 基础语法对比（就当Python和C#基础的普及吧）
- Python3 与 C# 基础语法对比（List、Tuple、Dict、Set专栏）
- 黑马程序员-C#基础知识-学习笔记01
- C#基础语法