博客已更新：C#(Csharp)基础教程(中)(菜鸟教程笔记)内容包括：判断、循环、封装、方法、可空类型、数组、字符串、结构体、枚举。
1.1 C# 概述
C# 是一个现代的、通用的、面向对象的编程语言，它是由微软（Microsoft）开发的，由 Ecma 和 ISO 核准认可的。
C# 是由 Anders Hejlsberg 和他的团队在 .Net 框架开发期间开发的。
C# 是专为公共语言基础结构（CLI）设计的。CLI 由可执行代码和运行时环境组成，允许在不同的计算机平台和体系结构上使用各种高级语言。下面列出了 C# 成为一种广泛应用的专业语言的原因：
现代的、通用的编程语言。
面向对象。
面向组件。
容易学习。
结构化语言。
它产生高效率的程序。
它可以在多种计算机平台上编译。
.Net 框架的一部分。
1.2 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 和 Lambda 表达式
集成 Windows
1.3 C# 与.Net的关系
在这里，主要讨论创建 C# 编程所需的工具。前面已经提到 C# 是 .Net 框架的一部分，且用于编写 .Net 应用程序。因此，在讨论运行 C# 程序的可用工具之前，让我们先了解一下 C# 与 .Net 框架之间的关系。
1.3.1 .Net
.NET是微软公司下的一个开发平台，.NET核心就是.NET Framwork（.NET框架）是.NET程序开发和运行的环境，在这个平台下可以用不同的语言进行开发，因为.NET是跨语言的一个平台。语言可以是C#,f#,j#,vb.net等等。java和.NET不同的一点是，java是跨平台的，不跨语言的。.NET跨平台仅限于安卓系统和 iOS
苹果系统。.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
如需了解每个组件的详细信息，请参阅微软（Microsoft）的文档。
1.3.2 C#
C#是一个.NET平台下的一个程序设计语言，仅仅是一个语言。是运行在.net CLR上的，用于创建应用程序的高级语言。 程序设计语言是为了方便开发人员和计算机沟通的工具。
1.4 C# 的集成开发环境（Integrated Development Environment - IDE）
1.4.1 Windows上编写 C# 程序
微软（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 的大部分功能。
1.4.2 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。
VS 是 Visual Studio，它是微软提供的一个工具集，由各种各样的工具组成。VS 可以支持 C/C++、VB、JAVA、C# 编程。然了一次只能支持一种编程方式。在 VS 安装完成，第一次运行的时候会让你选择常用语言，如果你选择 C/C++，那么他就成了能够进行 C/C++ 编程的平台也许就是你所说的 VC 了。如果不想用 C/C++
的话，只需要修改一下他的初始化设置，选择别的编程语言，就成为了另一种的语言的编程环境了。
VC 是 Visual C++，是一个独立的 C/C++ 的开发工具，比较著名的是 VC6.0，现在的 VC2010其实就是 VC10.0。再通俗一点，以 VS2010 和 VC2010 为例，VS2010 相当与 Office2010，包括了 World2010、Excel2010 等，而 VC2010 就相当于是 World2010。
2.1 Hello World
一个 C# 程序主要包括以下部分：
命名空间声明（Namespace declaration）
一个 class
Class 方法
Class 属性
一个 Main 方法
语句（Statements）& 表达式（Expressions）
注释
using System;
namespace HelloWorldApplication
{
class HelloWorld
{
static void Main(string[] args)
{
/* 我的第一个 C# 程序*/
Console.WriteLine('Hello World');
Console.ReadKey();
}
}
}
Hello World
程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。
下一行是 namespace 声明。一个 namespace 里包含了一系列的类。HelloWorldApplication 命名空间包含了类 HelloWorld。
下一行是 class 声明。类 HelloWorld 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，HelloWorld 类只有一个 Main 方法。
下一行定义了 Main 方法，是所有 C# 程序的 入口点。Main 方法说明当执行时 类将做什么动作。
下一行/*...*/将会被编译器忽略，且它会在程序中添加额外的注释。
Main 方法通过语句 Console.WriteLine('Hello World'); 指定了它的行为。WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 'Hello World'。
最后一行 Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。以下几点值得注意：
C# 是大小写敏感的。
所有的语句和表达式必须以分号（;）结尾。
程序的执行从 Main 方法开始。
与 Java 不同的是，文件名可以不同于类的名称。
3.1 程序实例
C# 是一种面向对象的编程语言。在面向对象的程序设计方法中，程序由各种相互交互的对象组成。相同种类的对象通常具有相同的类型，或者说，是在相同的 class 中。例如，以 Rectangle（矩形）对象为例。它具有 length 和 width 属性。根据设计，它可能需要接受这些属性值、计算面积和显示细节。让我们来看看一个 Rectangle（矩形）类的实现，并借此讨论 C# 的基本语法：
using System;
namespace RectangleApplication
{
class Rectangle
{
// 成员变量
double length;
double width;
public void Acceptdetails()
{
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)
{
Rectangle r = new Rectangle();
r.Acceptdetails();
r.Display();
Console.ReadLine();
}
}
}
Length: 4.5
Width: 3.5
Area: 15.75
3.2 C# 基本语法
3.2.1 using关键字
在任何 C# 程序中的第一条语句都是：
using System;
一般在程序开头添加 using System;，这时System.String 就可简写为string 。例如：
// using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
System.String a = 'Hello World!';
System.Console.WriteLine(a);
System.Console.ReadKey();
}
}
}
和
using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
string a = 'Hello World!';
Console.WriteLine(a);
Console.ReadKey();
}
}
}
是等价的。using 关键字用于在程序中包含命名空间。一个程序可以包含多个 using 语句。
3.2.2 class关键字
class关键字用于声明一个类
3.2.3 注释
注释是用于解释代码。编译器会忽略注释的条目。在 C# 程序中，多行注释以/*开始，并以字符 */ 终止，如下所示：
/* This program demonstrates
The basic syntax of C# programming
Language */
单行注释是用 '//’ 符号表示。例如：
}//end class Rectangle
3.2.3 成员变量
变量是类的属性或数据成员，用于存储数据。在上面的程序中，Rectangle 类有两个成员变量，名为 length 和 width。
3.2.4 实例化一个类
在上面的程序中，类 ExecuteRectangle 是一个包含 Main() 方法和实例化 Rectangle 类的类。
Rectangle r = new Rectangle();
3.2.5 标识符
标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：
标识符必须以字母、下划线或 @ 开头，后面可以跟一系列的字母、数字（ 0 - 9 ）、下划线（ _ ）、@。
标识符中的第一个字符不能是数字。
标识符必须不包含任何嵌入的空格或符号，比如 ? - +! # % ^ & * ( ) [ ] { } . ; : ' ’ / \。
标识符不能是 C# 关键字。除非它们有一个 @ 前缀。 例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
不能与C#的类库名称相同。
3.2.6 C# 关键字
关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。在 C# 中，有些关键字在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字（contextual keywords）。下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：
3.2.7 C# 占位符{}
当 WriteLine() 函数有多个参数时，输出第一个参数(双引号内的)中的内容，而第二个及后面的参数中的内容替换掉第一个参数中对应位置的占位符一起输出。
static void Main(string[] args)
{
Console.WriteLine('A:{0}，a:{1}',65,97);
Console.ReadLine();
}
A:65，a:97
如果第一个参数没有留占位符,那么第二个参数内容不输出。
Console.WriteLine('A:,a:',65,97);
A:,a:
占位符从零开始计数,且占位符中的数字不能大于第二个及后面的参数的总个数减一(要求占位符必须有可替换的值)。占位符数字与第二个及后面的参数字符位置一一对应。
static void Main(string[] args)
{
Console.WriteLine('A:{1}，a:{0}',65,97);
Console.ReadLine();
}
A:97,a:65
在 C# 中，变量分为以下几种类型：
值类型（Value types）
引用类型（Reference types）
指针类型（Pointer types）
4.1 值类型（Value types）
值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，系统分配内存来存储值。下表列出了 C# 2010 中可用的值类型：如需得到一个类型或一个变量在特定平台上的准确尺寸，可以使用 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
4.2 引用类型（Reference types）
引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。
换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的引用类型有：object、dynamic 和 string。
就像仓库，仓库里有货架，货架上有编号：A1,A2,A3…, 这些编号就可以看做是引用类型，现在来了一批货，有 “土豆，黄瓜，西红柿”，这些就是值类型，如果你想让 A1=土豆，那么就要把土豆搬到 A1
里面去，这就叫装箱，装箱需要耗费人力和工时（也就是耗费CPU和内存），同理拆箱就要把对应编号的货物搬出来，也是需要耗费人力和工时。
从内存上看，值类型是在栈中的操作，而引用类型是在堆中的操作。（导致 => 值类型存取速度快，引用类型存取速度慢。）
从本质上看，值类型表示实际数据，引用类型表示指向存储在内存堆中的数据的指针或引用。（值类型是具体的那个数值所占用的空间大小，而引用类型是存放那个数值的空间地址。）
从来源上看，值类型继承自System.ValueType，引用类型继承自System.Object。
特别的：结构体是值类型，类和string是引用类型。
4.2.1 对象（Object）类型
对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object
类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。
当一个值类型转换为对象类型时，则被称为装箱；另一方面，当一个对象类型转换为值类型时，则被称为拆箱。
装箱：值类型转换为对象类型, 实例：
int val = 8;
object obj = val;//整型数据转换为了对象类型（装箱）
拆箱：之前由值类型转换而来的对象类型再转回值类型, 实例：
int val = 8;
object obj = val;//先装箱
int nval = （int）obj;//再拆箱
只有装过箱的数据才能拆箱。
4.2.2 动态（Dynamic）类型
您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。声明动态类型的语法：
dynamic <variable_name> = value;
实例为：
dynamic d = 20;
动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。
4.2.3 字符串（String）类型
字符串（String）类型 允许您给变量分配任何字符串值。字符串（String）类型是 System.String 类的别名。它是从对象（Object）类型派生的。字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。例如：
string str = 'runoob.com';
一个 @引号字符串：
@'runoob.com';
C# string 字符串的前面可以加 @（称作'逐字字符串'）将转义字符（\）当作普通字符对待，比如：
string str = @'C:\Windows';
等价于：
string str = 'C:\\Windows';
@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。
string str = @'<script type=''text/javascript''>
<!--
-->
</script>';
用户自定义引用类型有：class、interface 或 delegate。我们将在以后的章节中讨论这些类型。
4.3 指针类型（Pointer types）
指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。声明指针类型的语法：
type* identifier;
例如：
char* cptr;
int* iptr;
类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型。在 C# 中，类型铸造有两种形式：
隐式类型转换 ：这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
显式类型转换 ：显式类型转换，即强制类型转换。通过用户使用预定义的函数显式完成的，显式转换需要强制转换运算符，而且强制转换会造成数据丢失。转换类型的范围大小和从属关系和隐式转换相反。显式转换可能会导致数据出错，或者转换失败，甚至无法编译成功。
下面的实例显示了一个隐式的类型转换：
namespace TypeConvertion
{
class Class1
{
}
class Class2 : Class1 //类Class2是类Class1的子类
{
}
class Program
{
static void Main(string[] args)
{
int inum = 100;
long lnum = inum; // 进行了隐式转换，将 int 型（数据范围小）数据转换为了 long 型（数据范围大）的数据
Class1 c1 = new Class2(); // 这里也是隐式转换，将一个新建的 Class2 实例转换为了其基类 Class1 类型的实例 C1
}
}
}
下面的实例显示了一个显式的类型转换：
namespace TypeConversionApplication
{
class ExplicitConversion
{
static void Main(string[] args)
{
double d = 5673.74;
int i;
// 强制转换 double 为 int
i = (int)d;
Console.WriteLine(i);
Console.ReadKey();
}
}
}
5673
5.1 C# 类型转换方法
C# 提供了下列内置的类型转换方法：下面的实例把不同值的类型转换为字符串类型：
namespace TypeConversionApplication
{
class StringConversion
{
static void Main(string[] args)
{
int i = 75;
float f = 53.005f;
double d = 2345.7652;
bool b = true;
Console.WriteLine(i.ToString());
Console.WriteLine(f.ToString());
Console.WriteLine(d.ToString());
Console.WriteLine(b.ToString());
Console.ReadKey();
}
}
}
75
53.005
2345.7652
True
5.2 Convert.ToInt32()的取整
C# 中对 double 类型的数据取整，可以使用Convert.ToInt32()方法，也可使用 int 强制转换为整数，使用 int 时并不存在四舍五入的情况，而是直接将后面的小数位数丢掉。比如:
class Program
{
static void Main(string[] args)
{
double a = 1.35;
double b = 1.65;
int a1 = Convert.ToInt32(a);
int a2 = (int)(a);
int b1 = Convert.ToInt32(b);
int b2 = (int)(b);
Console.WriteLine('{0}使用convert方法转化的结果为：{1}',a,a1);
Console.WriteLine('{0}使用int强制转换的结果为：{1}',a,a2);
Console.WriteLine('{0}使用convert方法转化的结果为：{1}', b, b1);
Console.WriteLine('{0}使用int强制转换的结果为：{1}', b, b2);
Console.ReadKey();
}
}
1.35使用convert方法转化的结果为：1
1.35使用int强制转换的结果为：1
1.65使用convert方法转化的结果为：2
1.65使用int强制转换的结果为：1
一个变量只不过是一个供程序操作的存储区的名字。在 C# 中，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。范围内的值可以存储在内存中，可以对变量进行一系列操作。我们已经讨论了各种数据类型。C# 中提供的基本的值类型大致可以分为以下几类：C# 允许定义其他值类型的变量，比如 enum，也允许定义引用类型变量，比如 class。这些我们将在以后的章节中进行讨论。在本章节中，我们只研究基本变量类型。
6.1 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;
6.2 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 = 10;
b = 20;
c = a + b;
Console.WriteLine('a = {0}, b = {1}, c = {2}', a, b, c);
Console.ReadLine();
}
}
}
a = 10, b = 20, c = 30
6.3 接受来自用户的值
System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。例如：
int num;
num = Convert.ToInt32(Console.ReadLine());
函数 Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，因为 Console.ReadLine() 只接受字符串格式的数据。
6.4 C# 中的 Lvalues 和 Rvalues
C# 中的两种表达式：
lvalue(左值)：lvalue 表达式可以出现在赋值语句的左边或右边。
rvalue(右值)：rvalue 表达式可以出现在赋值语句的右边，不能出现在赋值语句的左边。
变量是 lvalue 的，所以可以出现在赋值语句的左边。数值是 rvalue 的，因此不能被赋值，不能出现在赋值语句的左边。下面是一个有效的语句：
int g = 20;
下面是一个无效的语句，会产生编译时错误：
10 = 20;
常量是固定值，程序执行期间不会改变。常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。常量可以被当作常规的变量，只是它们的值在定义后不能被修改。
7.1 整数常量
整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：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 */
7.2 浮点常量
一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。这里有一些浮点常量的实例：
3.14159
/* 合法 */
314159E-5L
/* 合法 */
510E
/* 非法：不完全指数 */
210f
/* 非法：没有小数或指数 */
.e55
/* 非法：缺少整数或小数 */
使用小数形式表示时，必须包含小数点、指数或同时包含两者。使用指数形式表示时，必须包含整数部分、小数部分或同时包含两者。有符号的指数是用 e 或 E 表示的。
7.3 字符常量
字符常量是括在单引号里，例如，'x’，且可存储在一个简单的字符类型变量中。一个字符常量可以是一个普通字符（例如 'x’）、一个转义序列（例如 '\t’）或者一个通用字符（例如 '\u02C0’）。在 C# 中有一些特定的字符，当它们的前面带有反斜杠时有特殊的意义，可用于表示换行符（\n）或制表符 tab（\t）。在这里，列出一些转义序列码：以下是一些转义序列字符的实例：
namespace EscapeChar
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine('Hello\tWorld\n\n');
Console.ReadLine();
}
}
}
Hello
World
7.4 字符串常量
字符串常量是括在双引号''里，或者是括在@''里。字符串常量包含的字符与字符常量相似，可以是：普通字符、转义序列和通用字符使用字符串常量时，可以把一个很长的行拆成多个行，可以使用空格分隔各个部分。这里是一些字符串常量的实例。下面所列的各种形式表示相同的字符串。
string a = 'hello, world';
// hello, world
string b = @'hello, world';
// hello, world
string c = 'hello \t world';
// hello
world
string d = @'hello \t world';
// hello \t world
string e = 'Joe said \'Hello\' to me';
// Joe said 'Hello' to me
string f = @'Joe said ''Hello'' to me';
// Joe said 'Hello' to me
string g = '\\\\server\\share\\file.txt';
// \\server\share\file.txt
string h = @'\\server\share\file.txt';
// \\server\share\file.txt
string i = 'one\r\ntwo\r\nthree';
string j = @'one
two
three';
7.5 定义常量
常量是使用 const 关键字来定义的 。定义一个常量的语法如下：
const <data_type> <constant_name> = value;
下面的代码演示了如何在程序中定义和使用常量：
using System;
public class ConstTest
{
class SampleClass
{
public int x;
public int y;
public const int c1 = 5;
public const int c2 = c1 + 5;
public SampleClass(int p1, int p2)
{
x = p1;
y = p2;
}
}
static void Main()
{
SampleClass mC = new SampleClass(11, 22);
Console.WriteLine('x = {0}, y = {1}', mC.x, mC.y);
Console.WriteLine('c1 = {0}, c2 = {1}',
SampleClass.c1, SampleClass.c2);
}
}
x = 11, y = 22
c1 = 5, c2 = 10
7.6 静态常量和动态常量
7.6.1 静态常量（编译时常量）const
在编译时就确定了值，必须在声明时就进行初始化且之后不能进行更改，可在类和方法中定义。定义方法如下：
const double a=3.14；// 正确声明常量的方法
const int b;
// 错误，没有初始化
7.6.2 动态常量（运行时常量）readonly
在运行时确定值，只能在声明时或构造函数中初始化，只能在类中定义。定义方法如下：
class Program
{
readonly int a=1;
// 声明时初始化
readonly int b;
// 构造函数中初始化
Program()
{
b=2;
}
static void Main()
{
}
}
7.6.3 静态常量与动态常量的使用场景
在下面两种情况下，可以使用 const 常量：
取值永久不变(比如圆周率、一天包含的小时数、地球的半径等)。
对程序性能要求非常苛刻。
除此之外的其他情况都应该优先采用 readonly 常量。
8.1 算术运算符
下表显示了 C# 支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：请看下面的实例，了解 C# 中所有可用的算术运算符：
using System;
namespace OperatorsAppl
{
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);
// ++a 先进行自增运算再赋值
c = ++a;
Console.WriteLine('Line 6 - c 的值是 {0}', c);
// 此时 a 的值为 22
// --a 先进行自减运算再赋值
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 的值是 22
Line 7 - c 的值是 21
c = a++: 先将 a 赋值给 c，再对 a 进行自增运算。c = ++a: 先将 a 进行自增运算，再将 a 赋值给 c 。c = a --: 先将 a 赋值给 c，再对 a 进行自减运算。c = --a: 先将 a 进行自减运算，再将 a 赋值给 c 。
using System;
namespace OperatorsAppl
{
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; // 重新初始化 a
b = ++a;
Console.WriteLine('a = {0}', a);
Console.WriteLine('b = {0}', b);
Console.ReadLine();
// a-- 先赋值再进行自减运算
a = 1;
// 重新初始化 a
b= a--;
Console.WriteLine('a = {0}', a);
Console.WriteLine('b = {0}', b);
Console.ReadLine();
// --a 先进行自减运算再赋值
a = 1;
// 重新初始化 a
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
8.2 关系运算符
下表显示了 C# 支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
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
8.3 逻辑运算符
下表显示了 C# 支持的所有逻辑运算符。假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：
using System;
namespace OperatorsAppl
{
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 - 条件为真');
}
Console.ReadLine();
}
}
}
Line 1 - 条件为真
Line 2 - 条件为真
Line 3 - 条件不为真
Line 4 - 条件为真
8.4 位运算符
位运算符作用于位，并逐位执行操作。&、
和 ^ 的真值表如下所示：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，则：
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
8.5 赋值运算符
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
8.6 其他运算符
下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。
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 = 10;
b = (a == 1) ? 20 : 30;
Console.WriteLine('b 的值是 {0}', b);
b = (a == 10) ? 20 : 30;
Console.WriteLine('b 的值是 {0}', b);
Console.ReadLine();
}
}
}
int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 30
b 的值是 20
8.7 C# 中的运算符优先级
运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

收起资源包目录
共 25 条
1
F:\Test\tt_test\t6\t6\obj\x86\Debug\ResolveAssemblyReference.cache F:\Test\tt_test\t6\t6\obj\x86\Debug\t6.Form1.resources
F:\Test\tt_test\t6\t6\obj\x86\Debug\t6.Properties.Resources.resources F:\Test\tt_test\t6\t6\obj\x86\Debug\GenerateResource.read.1.tlog
F:\Test\tt_test\t6\t6\obj\x86\Debug\GenerateResource.write.1.tlog F:\Test\tt_test\t6\t6\bin\Debug\t6.exe F:\Test\tt_test\t6\t6\bin\Debug\t6.pdb
F:\Test\tt_test\t6\t6\obj\x86\Debug\t6.exe F:\Test\tt_test\t6\t6\obj\x86\Debug\t6.pdb