C#是一个简单的，现代的，通用的，面向对象的编程语言，它是由微软（Microsoft）开发的。
下面列出了C#成为一种广泛应用的专业语言的原因：
虽然C#的构想十分接近于传统的高级语言C和C++，是一门面向对象的编程语言，但是它与JAVA非常相似，有很大强大的编程功能，因此得到广大程序员的青睐。
下面列出C#的一些重要功能：
微软（Microsoft）提供了下列用于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#文件的后缀为**.cs**
以下创建了一个test.cs文件， 文件包含了可以打印'hello world'的简单代码：
using System; namespace HelloWorldApplication { class HelloWorld { static void Main(sting[] args) { /*我的第一个C#程序*/ Console.WriteLine('hello world'); Console.ReadKey(); } } }
当上面的代码被 编译并执行后，结果如下：
hello world;
我们来看一下上面程序的各个部分：
以下几点需要注意：
如果您使用Visual Studio .NET编译和执行C#程序，请按照下面的步骤操作：
您也可以使用命令行代替Visual Studio IDE来编译C#程序:
以Rectangle（矩形）对象为例，它具有length和width属性，根据这些属性可以计算面积。我们以一个Rectangle类的实现来讲解C#的基本语法：
using System; namespace RectangleApplication { class Rectangle { //成员变量 double length； double width； public void Acceptdetails() { length = 4; width = 3; } 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) { Reatangle r = new Rectangle(); r.Acceptdetails(); r.Display(); Console.ReadLine(); } } }
当上面的代码被编译执行时，他会产生下列结果：
length: 4
width: 3
Area: 12
在任何C#程序中的第一条语句都是：
using System;
class关键字用于声明一个类
注释是用于解释代码。编译器会忽略注释的条目。在C#程序中，多行注释用/* XXXXX */ ,如下所示：
/*This program demonstrates
The basic sysntax of C# programming
Language */
单行注释是用'//'符号表示。例如：
}//end class rectangle
变量是类的属性或数据成员，用于存储数据。在上面的程序中，Rectangle类有两个成员变量，名为length和width。
函数是一系列执行指定任务的语句。类的成员函数是在类内声明的。我们举例的类Rectangle包含了三个成员函数：AcceptDetails、GetArea和Display。
在上面的程序中，类ExecuteRectangle是一个包含Main() 方法和实例化Rectangle类的类。
标识符是用来识别类、变量、函数或任何其他用户定义的项目。在C#中，类的命名必须遵守如下基本规则：
关键字是C#编译器预定义的保留字。这些关键字不能用作标识符，但是，如果想使用这些关键字作为标识符，可以在关键字前面加上@字符作为前缀。
在C#中，有些关键字在代码的上下文中有特殊意义。如get和set，这些被称为上下文关键字。下表列出了C#中的保留关键字和上下文关键字：
| 保留关键字 | ||||||
|---|---|---|---|---|---|---|
| abstract | as | base | bool | break | byte | case |
| catch | char | checked | class | const | continue | decimal |
| default | delegate | do | double | else | enum | event |
| explict | extern | false | finally | fixed | float | for |
| foreach | goto | if | implict | 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 |
| global | group | into | join | let | orderby |
| partial(method) | remove | select | set |
在C#中，变量分为一下几种类型：
值类型变量可以直接分配给一个值，它们是从类System.ValueType 中派生的。
值类型直接包含数据。比如int、char、float， 它们分别存储数字，字符、浮点数。当您声明一个int类型时，系统分配内存类存储值。
下表列出了C#2010中可用的值类型：
| 类型 | 描述 | 范围 | 默认值 |
|---|---|---|---|
| bool | 布尔值 | True或False | False |
| byte | 8位无符号整数 | 0到255 | 0 |
| char | 16位Unicode字符 | U +0000到U+ffff | '\0’ |
| decimal | 128位精确的十进制值，28-29有效位数 | （-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 10 38 | 0.0F |
| int | 32位有符号整数类型 | -2,147,483,648到2,147,483,647 | 0 |
| long | 64位有符号整数类型 | -9,223,372,0.6,854,775,808到9,223,372,036,854,775,807 | 0L |
| sbyte | 8位有符号整型 | -128到127 | 0 |
| short | 16位有符号整数类型 | -32768到32767 | 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方法，表达式sizeof(type)返回以字节为单位的尺寸大小。下面举例获取任何机器上int类型的尺寸：
using System; namespace DataTypeApplication { class Program { static void Main(string[] args) { Console.WriteLine('Size of int:{0}', sizeof(int)); Console.ReadLine(); } } }
执行上面的代码，结果如下：
Size of int: 4
引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。
引用类型指的是一个内存位置，使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的引用类型有：object、dynamic和string。
对象类型是C#通用类型系统（Common Type System- CTS）中所有数据类型的终极基类。
Object 是 System.Object类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型和用户自定义类型）的值。但是，在分配之前，需要先进行类型转换。
当一个值类型转换为对象类型时，则被称为装箱；另一个方面，当一个对象类型转换为值类型时，则被称为拆箱。
object obj;
obj = 100; //这是装箱
动态数据类型变量中可以存储任何类型的值，这些变量的类型在运行时才会进行检查。
声明动态数据类型的语法：
dynamic <variable_name> = value;
例如：
dyamic d = 20;
动态类型与对象类型相似，但是对象类型变量检查是在编译时发生的，而动态类型变量的检查是在运行时发生的。
字符串（String）类型允许您给变量分配任何字符串值。字符串（String）类型是System.String类的别名。它是从对象（Object）类型派生的。字符串（String）类型的值可以通过两种形式进行分配：引号和@引号。
例如：
String str = 'hello world';
一个 @ 引号字符串：
@'hello world'
C#string 字符串的前面可以加@（称作“逐字字符串”）将转义字符（\）当作普通字符对待，比如：
sting str = @'C:\Windows';
等价于：
string str = 'C:\\Windows';
@字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。
string str = @'<script type =''text/javascript''>
<!--
-->
</script>';
用户自定义的引用类型有：class、interface或delegate。
指针类型变量存储另一种类型的内存地址。C#中的指针与C或C++中的指针有相同的功能。
什么指针类型的语法：
type* identifier
例如：
char* cptr；
int* iptr；
类型转换是把数据从一种类型转换为另一种类型。在C#中，类型转换有两种形式：
下面的实例展示了一个显示的类型转换：
using System; namespace ExplicitConversion { static void Main(string[] args) { double d = 512.6; int a; //强制转换double为int a = (int)d; Console.WriteLine('a = {0}', a); Console.ReadKey(); } }
上方代码被编译并执行后，结果如下：
5673
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位无符号整数类型 |
下面实例把不同值的类型转换为字符串类型：
using System; namespace TypeConversionApplication { class StringConversion { static void Main(string[] args) { int i = 80; float f = 51.006f; double d = 123.2563; bool b = true; Console.WriteLine(i.ToString()); Console.WriteLine(f.ToString()); Console.WriteLine(d.ToString()); Console.WriteLine(b.ToString()); } } }
上面代码编译并执行后，结果如下：
80
51.006
123.2563
True
一个变量只不过是一个工程序操作存储的名字。在C#中，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。范围内的值可以存储在内存中，可以对变量进行一系列操作。
C#的基本类型大致可以分为以下几类：
| 类型 | 举例 |
|---|---|
| 整数类型 | sbyte、byte、short、ushort、int、 uint、long、ulong和char |
| 浮点型 | float和double |
| 十进制类型 | decimal |
| 布尔类型 | true或false |
| 空类型 | 可为空值的数据类型 |
System命名空间中的Console类提供了一个函数ReadLine(), 用于接收来自用户的输入，并把它存储到一个变量中。
例如：
int num;
num = Convert.ToInt32(Console.ReadLine());
函数Convert.ToInt32()把用户输入的数据转换为int数据类型。因为Console.ReadLine()只接受字符串格式的数据。
运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。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 |
下面对自增（++）和自减运算符进行详细讲解：
通过下面的实例来讲解上方的运算：
using System; namespace OperatorsApplication { 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 先进行自增减运算再赋值 a = 1；//重新进行初始化 b = ++a; Console.WriteLine('a = {0}', a); Console.WriteLine('b = {0}', b); Console.ReadLine(); //a-- 先进行赋值，再进行自减运算 a = 1; //重新进行初始化 b = a--； Console.WriteLine('a = {0}', a); Console.WriteLine('b = {0}', b); Console.ReadLine(); //--a 先进行自减运算，再赋值 a = 1; // 重新进行初始化 b = --a； Console.WriteLine('a = {0}', a); Console.WriteLine('b = {0}', b); Console.ReadLine(); } } }
执行以上程序，输出结果为：
a = 2 b = 1 a = 2 b = 2 a = 0 b = 1 a = 0 b = 0
下面列出了C#支持的所有运算符。假设变量A为10， 变量的值为20，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 检查两个操作数是否相等，如果现等则条件为真 | （A == B）不为真 |
| != | 检查两个操作数是否相等，如果不相等则条件为真 | （A != B）为真 |
| > | 检查左操作数是否大于右操作数，如果是则条件为真 | （A > B）不为真 |
| < | 检查左操作数是否小于右操作数，如果是则条件为真 | （A < B）为真 |
| >= | 检查左操作数是否大于或等于右操作数，如果是则条件为真 | （A >= B） 不为真 |
| <= | 检查左操作数是否小于或等于右操作数，如果是则条件为真 | （A <= B）为真 |
下表列出了C#支持的所有运算符。假设变量A为布尔值True， 变量B为布尔值false，则：
| 运算符 | 描述 | 实例 |
|---|---|---|
| && | 称为逻辑与运算符，如果两个操作数都非零，则条件为真 | （A && B）为假 |
| || | 称为逻辑或运算符，如果两个操作数中有任意一个非零，则条件为真 | （A |
| ! | 称为逻辑非运算符，用来逆转操作数的逻辑状态，如果条件为真则逻辑非运算符将使其为假 | !(A && B)为真 |
位运算符作用于位，并逐位执行操作。&（位与），|（位或）和^（异或）的真值表如下：
| 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=60，且B = 13， 现在以二进制格式表示，他们如下所示： | ||||
| A = 0011 1100 | ||||
| B = 0000 1101 |
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A = 1100 0011 (每个位取反）
A >> 2 = 15 (即A / 22) A右移两位
A << 2 = 240 (即A * 22) A左移2位
下表列出了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 |
下表列出了C#支持的其他一些重要的运算符，包括sizeof，typeof和?:。
| 运算符 | 描述 | 实例 |
|---|---|---|
| sizeof() | 返回数据类型的大小 | sizeof(int), 将返回4 |
| typeof() | 返回class的类型 | typeof(StreamReader) |
| & | 返回变量的地址 | &a; 将得到变量的实际地址 |
| * | 变量的指针 | *a; 将指向一个变量。 |
| ?: | 条件表达式 | 如果条件为真 ? 则为 X : 否则为 Y |
| is | 判断对象是否为某一类型。 | If( Ford is Car) // 检查 Ford 是否是 Car 类的一个对象。 |
| as | 强制转换，即使转换失败也不会抛出异常。 | Object obj = new StringReader(“Hello”); StringReader r = obj as StringReader; |
下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。
| 类别 | 运算符 | 结合性 |
|---|---|---|
| 后缀 | () [] -> . ++ – | 从左到右 |
| 一元 | + - ！ ~ ++ – (type)* & sizeof | 从右到左 |
| 乘除 | * / % | 从左到右 |
| 加减 | + - | 从左到右 |
| 移位 | << >> | 从左到右 |
| 关系 | < <= > >= | 从左到右 |
| 相等 | == != | 从左到右 |
| 位与 AND | & | 从左到右 |
| 位异或 XOR | ^ | 从左到右 |
| 位或 OR | | | 从左到右 |
| 逻辑与 AND | && | 从左到右 |
| 逻辑或 OR | || | 从左到右 |
| 条件 | ?: | 从右到左 |
| 逗号 | , | 从左到右 |
下面是大多数编程语言中典型的判断结构的一般形式：
C#提供了以下类型的判断语句。
一个if语句 由一个布尔表达式后跟一个或多个语句组成。
if的语法：
```javascript
if (boolean_expression)
{
/* 如果布尔表达式为真，则执行该语句*/
}
如果布尔表达式为 true，则 if 语句内的代码块将被执行。如果布尔表达式为 false，则 if 语句结束后的第一组代码（闭括号后）将被执行。 **实例** ```javascript using System namespace ConditionChoose { class Program { static void Main(string[] args) { /*局部变量的定义*/ int a = 20; /*使用if语句检查布尔条件*/ if (a > 10) { Console.WriteLine('a 大于 10'); } Console.WriteLine('a 的值是{0}', a); Console.ReadLine(); } } }
当上面的代码被编译和执行时，结果如下：
a 大于 10
a 的值是20
一个if语句后可跟一个可选的else语句， else语句在布尔表达式为假时执行。其语法如下：
if(boolean_expression) { /*如果表达式为真将执行的语句*/ } else { /*如果表达式为假将执行的语句*/ } **实例** ```javascript using System namespace ConditonChoose { class Program { static void Main(string[] args) { int a = 20; /*检查布尔条件*/ if (a > 30) { Console.WriteLine('a 大于 30') } else { Console.WriteLine('a 小于 30') } Console.WriteLine('a 的值是{0}', a); Console.ReadLine(); } } }
当上面的代码被编译和执行时，结果如下:
a 小于 30
a的值是20
一个 if 语句后可跟一个可选的 else if…else 语句，这可用于测试多种条件。
当使用 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-else 语句是合法的，这意味着您可以在一个 if 或 else if 语句内使用另一个 if 或 else 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
b 的准确值是 200
一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。
语法
switch(expression){ case constant-expression : statement(s); break; case constant-expression : statement(s); break; /* 您可以有任意数量的 case 语句 */ default : /* 可选的 */ statement(s); break; }
switch 语句必须遵循下面的规则：
实例
using System; namespace MyApplication { class Program { static void Main(string[] args) { int day = 4; switch (day) { case 1: Console.WriteLine('Monday'); break; case 2: Console.WriteLine('Tuesday'); break; case 3: Console.WriteLine('Wednesday'); break; case 4: Console.WriteLine('Thursday'); break; case 5: Console.WriteLine('Friday'); break; case 6: Console.WriteLine('Saturday'); break; case 7: Console.WriteLine('Sunday'); break; } } } }
执行结果根据当天日期有所不同，我这里执行这天的结果为：
Thursday
以下实例判断学生的成绩，包含了 default 语句：
using System; namespace DecisionMaking { class Program { static void Main(string[] args) { /* 局部变量定义 */ char grade = 'B'; switch (grade) { case 'A': Console.WriteLine('很棒！'); break; case 'B': case 'C': Console.WriteLine('做得好'); break; case 'D': Console.WriteLine('您通过了'); break; case 'F': Console.WriteLine('最好再试一下'); break; default: Console.WriteLine('无效的成绩'); break; } Console.WriteLine('您的成绩是 {0}', grade); Console.ReadLine(); } } }
当上面的代码被编译和执行时，它会产生下列结果：
做得好
您的成绩是 B
您可以把一个 switch 作为一个外部 switch 的语句序列的一部分，即可以在一个 switch 语句内使用另一个 switch 语句。即使内部和外部 switch 的 case 常量包含共同的值，也没有矛盾。
语法
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
我们已经在前面的章节中讲解了 条件运算符 ? :，可以用来替代 if…else 语句。它的一般形式如下：
Exp1 ? Exp2 : Exp3;
其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和位置。
? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。
有的时候，可能需要多次执行同一块代码。一般情况下，语句是顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。
只要给定的条件为真，C#中的while循环语句会重复执行一个目标语句
语法
while(condition)
{
statement(s);
}
在这里，statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。condition 可以是任意的表达式，当为任意非零值时都为真。当条件为真时执行循环。
当条件为假时，程序流将继续执行紧接着循环的下一条语句。
实例
using System; namespace Loops { class Program { static void Main(string[] args) { /* 局部变量定义 */ int a = 10; /* while 循环执行 */ while (a < 20) { Console.WriteLine('a 的值： {0}', a); a++; } Console.ReadLine(); } } }
当上面的代码被编译和执行时，它会产生下列结果：
a 的值： 10 a 的值： 11 a 的值： 12 a 的值： 13 a 的值： 14 a 的值： 15 a 的值： 16 a 的值： 17 a 的值： 18 a 的值： 19
一个 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 = 10; a < 20; a = a + 1) { Console.WriteLine('a 的值： {0}', a); } Console.ReadLine(); } } }
当上面的代码被编译和执行时，它会产生下列结果：
a 的值： 10 a 的值： 11 a 的值： 12 a 的值： 13 a 的值： 14 a 的值： 15 a 的值： 16 a 的值： 17 a 的值： 18 a 的值： 19
C# 也支持foreach循环，使用foreach可以迭代数组或者一个集合对象。
以下实例有三个部分：
class ForEachTest { static void Main(string[] args) { int[] fibarray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 }; foreach (int element in fibarray) { System.Console.WriteLine(element); } System.Console.WriteLine(); // 类似 foreach 循环 for (int i = 0; i < fibarray.Length; i++) { System.Console.WriteLine(fibarray[i]); } System.Console.WriteLine(); // 设置集合中元素的计算器 int count = 0; foreach (int element in fibarray) { count += 1; System.Console.WriteLine('Element #{0}: {1}', count, element); } System.Console.WriteLine('Number of elements in the array: {0}', count); } }
输出结果为：
0 1 1 2 3 5 8 13 0 1 1 2 3 5 8 13 Element #1: 0 Element #2: 1 Element #3: 1 Element #4: 2 Element #5: 3 Element #6: 5 Element #7: 8 Element #8: 13 Number of elements in the array: 8
联系客服
