【图文】C#基本语法_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
C#基本语法
&&C#基础语法
大小：796.50KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢&&文章详情
C#基础语法总结
C#笔记&&基础篇
一．入门知识
VS中的常用快捷键
Ctrl+K+D:快速对齐代码
Ctrl+Z:撤销
Ctrl+S:保存(一定要经常保存！)
Ctrl+J:快速弹出智能提示
Shift+End 、Shift+Home
Ctrl+K+C:注释所选代码
Ctrl+K+U:取消对所选代码的注释
F1：转到帮助文档
折叠冗余代码：#Region 和#EndRegion
新建空的&&tab键&新增子节点&&&回车键&新增兄弟节点
F7快捷截图 F8预览
.net/dotnet:一般指.Net Framework框架.一种平台,一种技术.
C#(sharp):一种编程语言,可以开发基于.net平台的应用.
(*) Java即是一种平台又是一种编程语言
xmind 绘图软件
1、概念:.net与c#
.Net FrameWork框架提供了一个稳定的运行环境，；来保障我们.Net平台正常的运转
2、.net都能干什么（S）
桌面应用程序&& &&&&&& Winform（.net开发的桌面应用程序叫Winform应用程序）
Internet应用程序& ASP.NET
(.net开发的internet应用程序叫ASP.NET应用程序)
手机开发&&&&&&&&&&&&& wp8&
(.net可以做手机开发,Wp8，目前在中国刚刚起步,也许 这是一个机会)
Wp8已经来袭,要善于抓住机会,敢于尝试.----掌握分寸
Unity3D游戏开发或者虚拟现实(大家的机遇)
C/S:客户机(Client)/服务器模式(Server)& 如:qq
3、.NET两种交互模式(s)
(C/S是Client/Server的缩写。客户端需要安装专用的客户端软件。& Winform)
B/S:浏览器(Browser)/服务器模式(Server)
(B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器Internet应用程ASP.NET
IDE指的就是我们的开发工具。
(.net的IDE就是vs2010、vs2012、vs2013
注：MSDN(我们的百科全书,帮助)神器
5、vs的操作
1)、启动VS
a、双击图标
b、调出cmd，输入 devenu
2)、解决方案、项目及类之间的关系
解决方案：公司
项目：部门
在视图里面找解决方案资源管理器
3)、Program中的各个组成部分
引用命名空间：
京东----》京东在线商城项目---》顾客类
淘宝----》淘宝在线商城项目---》顾客类
高端霸气公司----》老赵牛X项目---》顾客类
4)、方法或者函数
Main函数是我们程序的主入口，你写的代码如果想要被执行的话，必须写在Main函数当中。
.sln：解决方案文件，里面包含着整个解决方案的信息，可以双击运行。
.csproj:项目文件，里面包含着这个项目的信息，可以双击运行。
2、书写代码需要注意的地方：
1)、代码中出现的所有标点都是英文半角 shift键快速切换中文半角和英文半角
shift+空格 切换全角/半角
2)、在c#代码中，每行代码的结束，我们都以分号结束，注意：这个分号也是英文半角的分号。
3)、Console.WriteLine("要打印的内容");
&& Console.ReadKey();
&& a、暂停当前程序，等待用户按下任意键继续，按下的任意键将显示在我们的控制台当中
3、运行程序的两种方式
1)、点击绿色的启动按钮
2)、使用快捷键F5
4、生成解决方案
帮助我们排查语法错误。
1)、如果你的代码中出现了红色的波浪线，意味着你的代码中出现了
语法错误。
2)、如果你的代码中出现了绿色的波浪线，说明你的代码语法并没有错误，
只不过提示你有可能会出现错误，但是不一定会出现错误。警告线
二．基础知识
1、c#中的注释符
3)、三种注释方式
第一种:单行注释& 以//开头,后面的就是注释内容
&& //单行注释
第二种:多行注释& 以 /*开头&& */结束 之间的是注释内容
&& /*& */多行注释
第三种:文档注释& 在方法或类的上一行输入 ///就会产生
&& ///文档注释
用来在计算机当中存储数据。如果你要是用变量的话，应该要先声明再赋值再使用。
存储整数100
数据类型：整数
在内存中开辟的空间应该是整数类型 int
存储变量的语法：
变量类型 变量名;
变量名=值;
"="号：在这并不表示等于的意思，而是赋值的意思，表示把等号右边的值赋值给等号左边的变量。
声明并且给变量赋值的简写形式：
变量类型 变量名=值;
3、数据类型
1)、整数类型：int& 只能存储整数，不能存储小数。
2)、小数类型：double 既能存储整数，也能存储小数，小数点后面的位数 15~16位。
3)、金钱类型：decimal：用来村粗金钱，值后面需要加上一个m.
4)、字符串类型:string,用来存储多个文本，也可以存储空，字符串类型的值需要被 双引号引来，
这个双引号必须是英文半角状态下的双引号
5)、字符类型：char,用来存储单个字符，最多、最少只能有一个字符，不能存储空。
字符类型的值需要用 单引号因起来。英文半角状态下的单引号。
4、命名规则：
****首先要保证的就是这个变量的名字要有意义。
1 现阶段给变量起名字的时候都以字母开头
2 后面可以跟任意&字母&、数字、下划线.
1）你起的变量名不要与c#系统中的关键字重复.
2）在c#中,大小写是敏感的.& HTML
3)同一个变量名不允许重复定义(先这么认为,不严谨)
给变量起名字的时候要满足两个命名规范：
1、Camel 骆驼命名规范。要求变量名首单词的首字母要小写，其余每个单词的首字母要大写。
多用于给变量命名。
2、Pascal 命名规范：要求每个单词的首字母都要大写，其余字母小写。多用于给类或者方法命名。
HighSchoolStudent
highSchoolStudent
1)、算数运算符
2)、赋值运算符
=：表示赋值的意思，表示把等号右边的值，赋值给等号左边的变量。
由等号连接的表达式称之为赋值表达式。
注意:每个表达式我们都可以求解除一个定值，对于赋值表达式而言，等号左边的变量的值，
就是整个赋值表达式的值。
int number=10;
6、+号和占位符的作用
1)、连接：当+号两边有一边是字符串的时候，+号就起到连接的作用。
2)、相加：两边是数字的时候
使用方法：先挖个坑，再填个坑。
使用占位符需要注意的地方：
1)、你挖了几个坑，就应该填几个坑，如果你多填了，没效果。
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 如果你少填了，抛异常。
2)、输出顺序：按照挖坑的顺序输出。
异常是指：语法上并没有任何错误，只不过在程序运行的期间，由于某些原因出现了问题，
使程序不能再正常的运行。
转义符指的就是一个'\'+一个特殊的字符，组成了一个具有特殊意义的字符。
\n:表示换行
\":表示一个英文半角的双引号
\t:表示一个tab键的空格
\b:表示一个退格键，放到字符串的两边没有效果。
\r\n:windows操作系统不认识\n,只认识\r\n
\\:表示一个\
1、取消\在字符串中的转义作用，使其单纯的表示为一个'\'
2、将字符串按照编辑的原格式输出
9、类型转换
1)隐式类型转换：
我们要求等号两遍参与运算的操作数的类型必须一致，如果不一致，满足下列条件会发生
自动类型转换，或者称之为隐式类型转换。
两种类型兼容
例如：int 和 double 兼容(都是数字类型)
目标类型大于源类型
例如：double & int&& 小的转大的&
2)显示类型转换：
1、两种类型相兼容& int--double
2、大的转成小的& double----int
(待转换的类型)要转换的值;
自动类型转换：int----&double
显示类型转换：double---&int
控制小数点位数的：{0:0.00}:小数点后两位
3)Convert类型转换
1、类型如果相兼容的两个变量，可以使用自动类型转换或者强制类型转换，
但是，如果两个类型的变量不兼容，比如 string与int或者string 与double，
这个时候我们可以使用一个叫做Convert的转换工厂进行转换。
注意：使用Convert进行类型转换，也需要满足一个条件：
面儿上必须要过的去。
&&&&&&&&&&& int number = Convert.ToInt32(Console.ReadLine());&
4)int.parse&&& Convert的内部方法，比其效率高一点，不过还会抛异常
尝试着将一个字符串转换成int类型。
int number= int.Parse(Console.ReadLine());
5) int.TryParse是方法，需要有参数和返回值，如果失败，不会抛出异常
int num=0;
bool b=int.TryParse(&3&, out num)//如果可以转换成功，b=true，num=3;否则，b=num=0;
10、运算符
1、算数运算符
++：分为前++和后++，不管是前++还是后++，最终的结果都是给这个变量加一。
区别表现表达式当中，如果是前++，则先给这个变量自身加一，然后带着这个加一后的值去参与运算。
如果是后++，则先拿原值参与运算，运算完成后，再讲这个变量自身加一。
--：同上。
对于向加加或者减减这样只需要一个操作数就能完成的运算，我们称之为一元运算符。
+ - * / % 对于这些需要两个或以上才能完成运算的操作符，我们称之为二元运算符。
一元运算符的优先级要高于而元运算符。
如果在一个表达式当中，既有一元运算符，又有二元运算符，我们首先计算一元运算符。&
int number=10;
int result=10 + ++&
2、关系运算符
&、& &、& &=、& &=、& ==、& !=
关系运算符是用来描述两个事物之间的关系
由关系运算符连接的表达式称之为关系表达式。
3、bool类型
在c#中我们用bool类型来描述对或者错。
bool类型的值只有两个 一个true& 一个false
4、逻辑运算符
又逻辑运算符连接的表达式叫做逻辑表达式
逻辑运算符两边放的一般都是关系表达式或者bool类型的值。
&5&3 &&true
&3&5||false
&逻辑表达式的结果同样也是bool类型
5、复合赋值运算符
int number=10;
number+=20;
number=number+20;
number-=5;
number=number-5;
number*=5;
number=number*5;
6.三元表达式
表达式1?表达式2:表达式3;
表达式1一般为一个关系表达式。
如果表达式1的值为true，那么表达式2的值就是整个三元表达式的值。
如果表达式1的值为false，那么表达式3的值就是整个三元表达式的值。
注意：表达式2的结果类型必须跟表达式3的结果类型一致，并且也要跟整个三元表达式的结果类型一致。
顺序结构：程序从Main函数进入，从上到下一行一行的执行，不会落下任何一行。
if(判断条件)
&&&&&&&& 要执行的代码;
判断条件：一般为关系表达式或者bool类型的值。
执行过程：程序运行到if处，首先判断if所带的小括号中的判断条件，
如果条件成立，也就是返回true，则执行if所带的大括号中的代码，
如果判断条件不成立，也就是返回一个false。则跳过if结构，继续向下执行。
if结构的特点：先判断，再执行，有可能一行代码都不执行
用于一种情况的判断。
分支结构:& if-else
if(判断条件)
&&&&&&&& 执行的代码;
&&&&&&&& 执行的代码
执行过程：程序执行到if处，首先判断if所带的小括号中的判断条件是否成立，
如果成立，也就是返回一个true，则执行if所带的大括号中的代码，
执行完成后，跳出if-else结构。
如果if所带的小括号中的判断条件不成立，也就是返回一个false，
则跳过if语句，执行else所带的大括号中的语句，执行完成后，跳出if-else结构。
if-else特点：先判断，再执行，最少都要执行一条代码。
用于两种情况的判断
注意：else永远跟离它最近的那个if配对
选择结构：if else-if &&switch-case
if else-if
作用：用来处理多条件的区间性的判断。
if(判断条件)
&&&&&&&& 要执行的代码;
else if(判断条件)
&&&&&&&& 要执行的代码;
else if(判断条件)
&&&&&&&& 要执行的代码;
else if(判断条件)
&&&&&&&& 要执行的代码;
&&&&&&&& 要执行的代码;
执行过程；程序首先判断第一个if所带的小括号中的判断条件，如果条件成立，也就是返回一个true，
则执行该if所带的大括号中的代码，执行完成后，立即跳出if else-if结构。
如果第一个if所带的判断条件不成立，也就是返回一个false，则继续向下进行判断，依次的判断每一个if所带
的判断条件，如果成立，就执行该if所带的大括号中的代码，如果不成立，则继续向下判断，
如果每个if所带的判断条件都不成立，就看当前这个if else-if结构中是否存在else。
如果有else的话，则执行else中所带的代码，如果没有else，则整个 if-else if神马都不做。
else可以省略。
switch-case
用来处理多条件的定值的判断。
switch(变量或者表达式的值)
&&&&&&&& case 值1:要执行的代码;
&&&&&&&& case 值2:要执行的代码;
&&&&&&&& case 值3:要执行的代码;
&&&&&&&& ..........
&&&&&&&& default:要执行的代码;
执行过程：程序执行到switch处，首先将括号中变量或者表达式的值计算出来，
然后拿着这个值依次跟每个case后面所带的值进行匹配，一旦匹配成功，则执行
该case所带的代码，执行完成后，遇到break。跳出switch-case结构。
如果，跟每个case所带的值都不匹配。就看当前这个switch-case结构中是否存在
default，如果有default，则执行default中的语句，如果没有default，则该switch-case结构
什么都不做。
循环结构：while &do-while& &for
while循环：
while(循环条件)
&&&&&&&& 循环体;
执行过程：程序运行到while处，首先判断while所带的小括号内的循环条件是否成立，
如果成立的话，也就是返回一个true，则执行循环体，执行完一遍循环体后，再次回到
循环条件进行判断，如果依然成立，则继续执行循环体，如果不成立，则跳出while循环。
在while循环当中，一般总会有那么一行代码，能够改变循环条件，使之终有一天不再成立，
如果没有那么一行代码能够改变循环条件，也就是循环条件永远都成立，我们称之这种循环
叫做死循环。
最简单的最常用的死循环：
while(true)
特点：先判断，再执行，有可能一遍循环都不执行。
do-while循环。
&&&&&&&& 循环体;
}while(循环条件);
执行过程:程序首先会执行do中的循环体，执行完成后，去判断do-while循环的循环条件，
如果成立，则继续执行do中的循环体，如果不成立，则跳出do-while循环。
特点：先循环，再判断，最少执行一遍循环体。
for(表达式1;表达式2;表达式3)
&&&&&&&& 循环体;
表达式1一般为声明循环变量，记录循环的次数(int i=0;)
表达式2一般为循环条件(i&10)
表达式3一般为改变循环条件的代码，使循环条件终有一天不再成立(i++)。
执行过程：程序首先执行表达式1，声明了一个循环变量用来记录循环的次数，
然后执行表达式2，判断循环条件是否成立，如果表达式2返回的结果为true，
则执行循环体。当执行完循环体后，执行表达式3，然后执行表达式2继续判断循环条件是否成立，
如果成立则继续执行循环体，如果不成立，则跳出for循环。&
12 break, Continue
1)、可以跳出switch-case结构。
2)、可以跳出当前循环。
break一般不单独的使用，而是跟着if判断一起使用，表示，当满足某些条件的时候，就不再循环了。
立即结束本次循环,判断循环条件,如果成立,则进入下一次循环,否则退出循环.
13、异常捕获
1．try-catch
.我们在程序中经常会出现各种各样的异常，你如果想要你的程序变得坚强一些。
在你的代码中应该经常性的使用try-catch来进行异常捕获。
哪行代码有可能出现异常，你就踹它一脚。
&&&&&&&& 可能会出现异常的代码;
&&&&&&&& ....
&&&&&&&& ...
&&&&&&&& ...
//try和catch之间不能有其他的代码
&&&&&&&& 出现异常后要执行的代码;
执行过程:如果try中的代码没有出现异常，那么catch中的代码不会执行。
如果try中的代码出现了异常，那怕这行出现异常的代码后面还有一百行都不会执行了，
而是直接跳到catch中执行代码
2、变量的作用域
变量的作用域就是你能够使用到这个变量的范围。
变量的作用域一般从声明它的那个括号开始到那个括号所对应的结束的括号结束。
在这个范围内，我们可以访问并使用变量。超出这个范围就访问不到了
14、程序调试
1)、写完一段程序后，想看一下这段程序的执行过程。
2)、当你写完这段程序后，发现，程序并没有按照你想象的样子去执行。
调试方法：
1)、F11逐语句调试(单步调试)
2)、F10逐过程调试
3)、断点调试
声明的常量的语法：
const 变量类型 变量名=值;
什么时候会用到常量？
[public] enum 枚举名
&&&&&&&& 值1,
&&&&&&&& 值2,
&&&&&&&& 值3,
&&&&&&&& ........
public:访问修饰符。公开的公共的，哪都可以访问。
enum：关键字，声明枚举的关键字
枚举名：要符合Pascal命名规范
将枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用这个枚举。
枚举就是一个变量类型 ，int--double& string& decimal.
只是枚举声明、赋值、使用的方式跟那些普通的变量类型不一样。
我们可以将一个枚举类型的变量跟int类型和string类型互相转换。
枚举类型默认是跟int类型相互兼容的，所以可以通过强制类型转换的语法互相转换。
当转换一个枚举中没有的值的时候，不会抛异常，而是直接将数字显示出来。
枚举同样也可以跟string类型互相转换，如果将枚举类型转换成string类型，则直接调用ToString().
如果将字符串转换成枚举类型则需要下面这样一行代码：
&&&&&&&& (要转换的枚举类型)Enum.Parse(typeof(要转换的枚举类型),"要转换的字符串");
如果转换的字符串是数字，则就算枚举中没有，也会不会抛异常。
如果转换的字符串是文本，如果枚举中没有，则会抛出异常。
所有的类型都能够转换成string类型，调用ToString()。
可以帮助我们一次性声明多个不同类型的变量。
[public] struct 结构名
&&&&&&&& 成员;//字段
变量在程序运行期间只能存储一个值，而字段可以存储多个值。
一次性存储多个相同类型的变量。
数组类型[] 数组名=new 数组类型[数组长度];
***数组的长度一旦固定了，就不能再被改变了&
19、冒泡排序
冒泡排序：就是将一个数组中的元素按照从大到小或者从小到大的顺序进行排列。
int[] nums={9,8,7,6,5,4,3,2,1,0}; 0 1 2 3 4 5 6 7 8 9
第一趟比较：8 7 6 5 4 3 2 1 0 9 交换了9次&&&& i=0& j=nums.Length-1-i
第二趟比较：7 6 5 4 3 2 1 0 8 9 交换了8次&&&& i=1& j=nums.Length-1-i
第三趟比较：6 5 4 3 2 1 0 7 8 9 交换了7次&&&& i=2& j=nums.Length-1-i
第四趟比较：5 4 3 2 1 0 6 7 8 9 交换了6次&&&& i=3& j=nums.Length-1-i
第五趟比较：4 3 2 1 0 5 6 7 8 9 交换了5次
第六趟比较：3 2 1 0 4 5 6 7 8 9 交换了4次
第七趟比较：2 1 0 3 4 5 6 7 8 9 交换了3次
第八趟比较：1 0 2 3 4 5 6 7 8 9 交换了2次
第九趟比较：0 1 2 3 4 5 6 7 8 9 交换了1次
for(int i=0;i&number.Length-1;i++)
&&&&&&&& for(int j=0;j&nums.Length-1-i;j++)
&&&&&&&& {
&&&&&&&&&&&&&&&&&& if(nums[j]&nums[j+1])
&&&&&&&&&&&&&&&&&& {
&&&&&&&&&&&&&&&&&&&&&&&&&&& int temp=nums[j];
&&&&&&&&&&&&&&&&&&&&&&&&&&& nums[j]=nums[j+1];
&&&&&&&&&&&&&&&&&&&&&&&&&&& nums[j+1]=
&&&&&&&&&&&&&&&&&& }
&&&&&&&& }
函数就是将一堆代码进行重用的一种机制。
1.函数的语法：
[public] static 返回值类型 方法名([参数列表])
&&&&&&&& 方法体；
public:访问修饰符，公开的，公共的，哪都可以访问。
static：静态的
返回值类型：如果不需要写返回值，写void
方法名：Pascal 每个单词的首字母都大些。其余字母小写
参数列表：完成这个方法所必须要提供给这个方法的条件。如果没有参数，小括号也不能省略。
方法写好后，如果想要被执行，必须要在Main()函数中调用。
方法的调用语法：
类名.方法名([参数]);
***在某些情况下，类名是可以省略的，如果你写的方法跟Main()函数同在一个类中，这个时候，
类名可以省略。
1、在方法中返回要返回的值。
2、立即结束本次方法。
3、我们在Main()函数中，调用Test()函数，我们管Main()函数称之为调用者，
管Test()函数称之为被调用者。
如果被调用者想要得到调用者的值：
1)、传递参数。
2)、使用静态字段来模拟全局变量。
如果调用者想要得到被调用者的值：
1)、返回值
不管是实参还是形参，都是在内存中开辟了空间的。
5、方法的功能一定要单一。
GetMax(int n1,int n2)
方法中最忌讳的就是出现提示用户输入的字眼。&
6、out、ref、params
1)、out参数。
如果你在一个方法中，返回多个相同类型的值的时候，可以考虑返回一个数组。
但是，如果返回多个不同类型的值的时候，返回数组就不行了，那么这个时候，
我们可以考虑使用out参数。
out参数就侧重于在一个方法中可以返回多个不同类型的值。
2)、ref参数
能够将一个变量带入一个方法中进行改变，改变完成后，再讲改变后的值带出方法。
ref参数要求在方法外必须为其赋值，而方法内可以不赋值。
3)、params可变参数
将实参列表中跟可变参数数组类型一致的元素都当做数组的元素去处理。
params可变参数必须是形参列表中的最后一个元素。&
7、方法的重载
概念：方法的重载指的就是方法的名称相同给，但是参数不同。
参数不同，分为两种情况
1)、如果参数的个数相同，那么参数的类型就不能相同。
2)、如果参数的类型相同，那么参数的个数就不能相同。
***方法的重载跟返回值没有关系。
8、方法的递归
方法自己调用自己。
找出一个文件夹中所有的文件。请登录查看
C# 基本语法
C# 是一种面向对象的编程语言。在面向对象的程序设计方法中，程序由各种相互交互的对象组成。相同种类的对象通常具有相同的类型，或者说，是在相同的 class 中。 例如，以 Rectangle（矩形）对象为例。它具有 length 和 width 属性。根据设计，它可能需要接受这些属性值、计算面积和显示细节。 让我们来看看一个 Rectangle（矩形）类的实现，并借此讨论 C# 的基本语法：
namespace RectangleApplication
class Rectangle
// 成员变量
public void Acceptdetails()
length = 4.5;
width = 3.5;
public double GetArea()
return length *
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
在任何 C# 程序中的第一条语句都是：
using 关键字用于在程序中包含命名空间。一个程序可以包含多个 using 语句。
class 关键字用于声明一个类。
注释是用于解释代码。编译器会忽略注释的条目。在 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# 中，有些标识符在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字（contextual keywords）。 下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：
保留关键字 abstractasbaseboolbreakbytecase catchcharcheckedclassconstcontinuedecimal defaultdelegatedodoubleelseenumevent explicitexternfalsefinallyfixedfloatfor foreachgotoifimplicitinin (generic modifier)int interfaceinternalislocklongnamespacenew nullobjectoperatoroutout (generic modifier)overrideparams privateprotectedpublicreadonlyrefreturnsbyte sealedshortsizeofstackallocstaticstringstruct switchthisthrowtruetrytypeofuint ulonguncheckedunsafeushortusingvirtualvoid volatilewhile 上下文关键字 addaliasascendingdescendingdynamicfromget globalgroupintojoinletorderbypartial(type) partial (method)removeselectset
意见反馈：
联系方式：
广告等垃圾信息
不友善内容
违反法律法规的内容
不宜公开讨论的政治内容C# 教程之基本语法
来源：未知
因为C# 源于C++和Java，所以在语法方面与它们非常相似，但是也存在一些差别。下面系统介绍C# 语法的基本内容，重点放在与C++的不同上。
1）符号与标记
与C++一样，C# 程序也采用区分大小写的自由书写格式，编译器会忽略多余的白空符；C# 也支持&\a&、&\n&和&\t&等转移字符；C# 的每个语句也都以分号&;&结束；语句块也用花括号对&{&和&}&来界定。参见下表：（红色为C# 特有的）
C# 的符号与标记
符号与标记
水平制表符HT（Tab）或垂直制表符VT
//、/*、*/、///、/**
预处理指令
Unicode字符
@&&&&、@标识符
d D、f F、l L、lu LU、m M、u U、ul UL
+、-、*、/、%、++、--、&、==、&、?:、??、()、&&
（1）文档注释符&///&&&和&/**&&*/&
C# 除了支持C++的单行注释&// &&&和定界注释&/* && */&外，还增加了与之对应的如下两种文档注释方式：
l& 单行文档注释&/// &&&&&是&// &&&方式的扩展，增加了一个斜线符&/&。
l& 定界文档注释：&/** && */&&&是/* && */方式的扩展，在起端增加了一个星号符&*&。
这两种新注释，都用于C# 项目说明文档的自动提取和生成，说明文档采用的是XML格式，由C# 编译器自动生成。但是需要添加/doc编译器选项，或在Visual Studio的IDE中激活该功能。具体方法是：选&项目&菜单中的&*属性&菜单项；在IDE中部打开的项目属性页中，选左列的&生成&选项，在右边下部的&输出&栏中，选中&XML文档文件&复选框以激活文档自动生成功能，还可以输入或修改&输出路径&和文件名，缺省为项目的&bin\Debug&或&bin\Release&子目录和&项目名.XML&。参见下图：
例如，C# 编译器为不加任何注释的HelloWorld项目所生成的说明文档为：
// HelloWorld.XML
&?xml version=&1.0&?&
&&& &assembly&
&&&&&&& &name&HelloWorld&/name&
&&& &/assembly&
&&& &members&
&&& &/members&
如果你在Program类的定义前加上一行，在键入&///&后，系统会自动生成下面代码中的灰色部分，然后你自己再添加绿色部分。
&&& /// &summary&
&&& /// Start class for simple HelloWorld
&&& /// &/summary&
则编译器会自动生成如下说明文档：
// HelloWorld.XML
&?xml version=&1.0&?&
&&& &assembly&
&&&&&&& &name&HelloWorld&/name&
&&& &/assembly&
&&& &members&
&&&&&&& &member name=&T:HelloWorld.Program&&
&&&&&&&&&&& &summary&
&&&&&&&&&&& Start class for simple HelloWorld
&&&&&&&&&&& &/summary&
&&&&&&& &/member&
&&& &/members&
（2）逐字符@
C# 新引进的逐字符（verbatim character）@，可以避免解析字符串中的转移字符和标识符中的关键字等：
l& 逐字字符串（verbatim string）&&@&&&&，不解析其中的转移序列。例如：
string fn = @&C:\Doc\data.txt&;
l& 逐字标识符（verbatim identifier）&&@标识符，不解析标识符，使关键字也可以用作变量名、类名和方法名等普通标识符。例如：int @for = 12;
（3）可空类型符?
不能使用的对象，可以用设置其值为空null来标识。但是基本值类型是不能赋值为空的，那会导致编译错误。传统的经验解决办法是赋给其一个取值范围之外的值，如&-1&（0xFFFFFFFF），但这种方法并不标准。
现在C# 给出了一种完美的解决方案&&可空类型（nullable type）：声明值类型的变量时，在变量名后添加可空类型的问号符&?&，则该变量成为可空类型，可以被赋值为空。
在C# 中，还可以通过可空类型的共用只读属性HasValue，来判断可空类型变量是否为空。例如：
int? x = 123;
if (x.HasValue) Console.WriteLine(x.Value); // 输出123
if (y.HasValue) Console.WriteLine(y.Value); // 输出
与C++一样，C# 也是强类型语言，其每个变量和对象也都必须具有被预先声明的类型。但是由于C# 是专门为.NET设计的语言，所以它的类型体系与C++有很大的不同，而与.NET框架则一致。
C# 有如下两大类型种类：
l& 值类型&&包括简单、枚举、结构和指针类型。该类型的变量存储数据本身，对值类型的变量进行赋值时，会复制变量所包含的值。其中的指针类型，仅可用于unsafe（非安全）模式。
l& 引用类型&&包括类、数组和接口类型。该类型（也称为对象）的变量存储对实际数据的引用，对引用类型的变量进行赋值时，只复制对象的引用（指针/句柄），而不会复制对象本身。
值类型可以通过装箱（boxing）转换成引用类型，然后再经过拆箱（unboxing）转换回值类型。但是无法将原始的引用类型转换为值类型。
C# 不支持联合类型，也没有关键字union。
3）简单类型
简单类型属于C# 语言的值类型，对应于C++语言的基本类型，包括字符、布尔类型、以及整数和实数等数值类型。与C++/CLI相似，C# 中的基本类型都与.NET框架的System命名空间中的对应类型等同，是它们的别名。参见下表：
C# 的简单类型
C++/CLI类型
.NET框架类型
范围和精度
System.Boolean
true或false
System.Char
所有UTF-16编码（0~0xFFFF）
[signed] char
System.SByte
-128 ~ 127
unsigned char
System.Byte
[signed] short
System.Int16
-32 768 ~ 32 767
unsigned short
System.UInt16
0 ~ 65 535
[signed] int/long
System.Int32
-2 147 483 648 ~ 2 147 483 647
unsigned int/long
System.UInt32
0 ~ 4 294 967 295
[signed] long long
System.Int64
-9 223 372 036 854 775 808
~ 9 223 372 036 854 775 807
unsigned long long
System.UInt64
0 ~ 18 446 744 073 709 551 615
System.Single
&1.5&10-45 ~ &3.4&1038
System.Double
&5.0&10-324 ~ &1.7&10308
System.Decimal
高精度十进制小数
&1.0&10-28 ~ &7.9&1028
其中的sbyte、byte、short、ushort、int、uint、long、ulong和char等9种类型被为整数类型（integral types）。
可见，C# 的简单类型的名称，比C++的更简洁明了。如signed被省略；unsigned简写成了u，从而unsigned short、unsigned int和unsigned long long分别被改成了ushort 、uint和ulong；char对应于C++的wchar_t；sbyte部分对应于C++的char，但是sbyte只表示单字节的有符号整数，不再表示单字节的普通字符，因为在C# 不支持单字节字符。因此，在C# 中，不再需要C++中的L&&&&运算符来进行普通字符串常量向宽字符串的转换。
与C++非常不同等一点是，C# 中所有整形类型（如int和long）的字节数都是固定的，不再像C/C++那样依赖于CPU的字长。
还有几点与C++不同，但是与C++/CLI相同的是：
l& 可以用（从System.Object继承的）GetType()方法来获得指定变量或对象的类型名称。简单类型返回的是.NET的类型名，对象则返回类或结构的名称。例如：
int i = 1;
Console::WriteLine(L&The type of variable i is {0} and object obj is {1}.&,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& i.GetType(), obj-&GetType());
的输出为：The type of variable i is System.Int32 and the object obj is MyClass.
l& 具有.NET的高精度十进制小数类型System.Decimal的对应类型decimal。在C# 中可以用m或M后缀，将一个实数常量指定为decimal类型。没有后缀的实数会被视为double类型，直接赋值给decimal变量会导致编译错误。例如：
decimal money = 1234.5m; // 正确
decimal d = 1234.5; // 编译错误
注意：在C++/CLI中没有类似的后缀指示符，需要用Decimal的构造函数。例如：
// C++/CLI例
decimal d = 1234.5; // 编译错误
Decimal money = Decimal(1234.5); // 正确
3）运算符与表达式
C# 运算符（operators）和表达式（expression）与C/C++几乎完全一样，仅有的区别如下：
基元（primary）运算符：C# 新增加了如下两个基元表达式运算符：
l& checked（已检验）&&用于设置溢出检验上下文（overflow-checking context），控制对整型算术表达式中的操作和转换进行溢出检验，在出现溢出时会抛出异常。格式为：checked(表达式)或checked{语句块}。
l& unchecked（未检验）&&用于设置溢出检验上下文（overflow-checking context），控制对整型算术表达式中的操作和转换不进行溢出检验，在出现溢出时不抛出异常，结果为截断后的整数。格式为：unchecked(表达式)或unchecked{语句块}。
class Test {
&&&&&& static readonly int x = 1000000;
&&&&&& static readonly int y = 1000000;
&&&&&& static int F() {
&&&&&&&&&&&&& return checked(x * y); // Throws OverflowException
&&&&&& static int G() {
&&&&&&&&&&&&& return unchecked(x * y); // Returns -
&&&&&& static int H() {
&&&&&&&&&&&&& return x * // Depends on default
&&&& int i, i2 = int.MaxValue, i2 = 200;
&&&& i = checked(i1 * i2);
&catch(Exception e){
&&&& //MessageBox.Show(e.ToString());
&&&&&& &Console.WriteLine(e.ToString());
一元运算符：全局命名空间限定符::&&虽然C# 不再支持全局变量和全局函数，但是仍然有全局命名空间，所以还是保留了全局命名空间限定符&::&（类似于C++的全局运算符::）。注意，因为在C# 中，双冒号符&::&已经不再作为命名空间之间和CLR对象与成员之间的分隔符，而是专用的全局命名空间限定符。
二元运算符：
l& 模运算符%&&在C# 中，%既可以用来求整数的余。也可以用于浮点数和十进制数。例如5 % 1.5 = 0.5。
l& 是运算符is&&用于动态检验一个对象的运行时类型是否与指定类型兼容。格式为：
表达式 is 类型名
结果为一个布尔值，若表达式可以成功地转换成指定类型，则为true，否则为false。
l& 转为运算符as&&用于将一个值显式地转换为一个指定的引用类型或可空（值）类型。格式为：
标识符 as 类型名
转换为引用类型时，采用的是引用转换或装箱转换；转换为可空类型时，采用的是包装转换、拆箱转换或空类型转换。与强制转换不同，as转换不会抛出异常。如果指定的转换是不可能的，则结果为空null。
is和as运算符在模板和泛型运算中非常有用。
l& 空接合运算符（null coalescing operator）??&&用于在某个可空类型变量a的值为空时，提供备用的值b。格式为：
当a非空时结果为a，否则为b。功能相对于：a.HasValue ? a : b。例如：
double? x =
double y = x ?? 0;
C# 表达式中运算符的优先级（order of precedence）与C++的类似，参见下表：（其中，红色的运算符是C# 特有的）
C# 运算符优先级表（从高到低）
.（成员，如x.y）、( )（函数，如f(x)）、[ ]（数组，如a[i]）、++（后缀增，如i++）、--（后缀减，如i--）、new（创建对象，如new MyClass）、typeof（类型，如typeof(x)）、checked（已检验，如checked(x*y)）、unchecked（未检验，如unchecked(x*y)）
+（正，如+x）、-（负，如-x）、！（逻辑非，如!x）、~（求补，如~x）、++（前缀加，如++i）、--（前缀减，如--i）、()（强制类型转换，如(int)x）
*（乘，如x*y）、/（除，如x/y）、%（模，如x%y）
+（加，如x+y）、-（减，如x-y）
&&（左移，如i&&4）、&&（右移，如i&&4）
&（小于，如x&y）、&（大于，如x&y）、&=（小于等于，如x&=y）、&=（大于等于，如x&=y）、is（是，如x is int）、as（转为，如x as int）
==（相等，如x==y）、!=（不等，如x!=y）
&（位与，如x&4）
^（位异或，如x^y）
|（位或，如x|y）
&&（逻辑与，如x&&y）
||（逻辑或，如x||y）
??（空接合，如a??b）
?:（条件，如x?a:b）
=（等于，如x=y）、*=（乘等于，如x*=y）、/=（除等于，如x/=y）、+=（加等于，如x+=y）、-=（减等于，如x-=y）、&&=（左移等于，如x&&=y）、&&=（右移等于，如x&&=y）、&=（位与等于，如x&=y）、^=（位异或等于，如x^=y）、|=（位或等于，如x|=y）
与C/C++类似，C# 中的枚举（enum）类型也是一个命名常量的集合。枚举声明的完整格式为：（方括号[ ]中的内容是可选的）
[属性] [枚举修饰符] enum 标识符 [: 整型基类型] {
&&&&&& [属性] 标识符 [ = 常量表达式],
&&&&&& [属性] 标识符 [ = 常量表达式]
常用格式为：
public enum 枚举名 [: 基类型] {
&&&&&& 枚举成员名 [= 枚举值],
&&&&&& 枚举成员名 [= 枚举值]
enum Color {Red, Green, Blue}
枚举修饰符有：new、public、protected、internal、private。缺省的基类型为int。
C# 的枚举类型都是抽象类类型System.Enum结构的派生值类型。Enum的C#定义如下：
[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Enum : ValueType, IComparable, IFormattable, IConvertible
包含如下公用成员：
将此实例与指定对象进行比较并返回一个对二者的相对值的指示。
已重载。已重写。返回一个值，该值指示此实例是否与指定的对象相等。
根据指定格式将指定枚举类型的指定值转换为其等效的字符串表示形式。为静态方法。
已重写。返回该实例的值的哈希代码。
在指定枚举中检索具有指定值的常数的名称。为静态方法。
检索指定枚举中常数名称的数组。为静态方法。
获取当前实例的。（从继承。）
返回此实例的基础。
返回指定枚举的基础类型。为静态方法。
检索指定枚举中常数值的数组。为静态方法。
返回指定枚举中是否存在具有指定值的常数的指示。为静态方法。
已重载。将一个或多个枚举常数的名称或数字值的字符串表示转换成等效的枚举对象。为静态方法。
确定指定的实例是否是相同的实例。为静态方法。（从继承。）
已重载。返回设置为指定值的、指定枚举类型的实例。为静态方法。
已重载。已重写。将此实例的值转换为其等效的字符串表示。
在用户定义的枚举类型中，可以使用这些公用方法。
与C++不同，但是与C++/CLI类似的是，你不能用整数值来代替枚举值。而且枚举可以作为顶层类型，也可以作为类的成员（嵌套类型），但是不能作为局部类型来定义，这点也与C++不同。还有一个与C++不同点是，在C# 的枚举类型定义体后的分号是可选的，而在C++中是必须的。
C# 中的数组与C++的很相似，其声明格式与C++和C++/CLI的都不同。C# 数组与C++的最大差别是，C# 支持多维数组（也支持C++的数组的数组）。
声明格式：（非红色的方括号表示可选项）
l& 一维数组&&声明格式为：
类型[] 数组名 [ = [new 类型[[n]] ] {表达式1, &&, 表达式n} ];
例如：int[] a = {0, 2, 4, 6, 8}; string[] sa = new string[5]; object[]
使用格式为：数组名[i]。例如：sa[2] = &abcd&;
l& 二维数组&&声明格式为：
类型[,] 数组名 [ = [new 类型[[m, n]] ] {{表达式1, &&, 表达式1n},
&&, {表达式m1, &&, 表达式mn}} ];
例如：int[,] b = new int[5, 2]; &int[,] b = {{0, 1}, {2, 3}, {4, 5}, {6, 7}, {8, 9}};
l& 多维数组&&声明格式为：
类型[,,...,] 数组名 [ = [new 类型[[n1, n2, ..., nm]] ] {&&} ];
例如：int[,,] a = new int[3, 2, 4]; 使用格式为：数组名[i1, i2, &, in]。
l& 锯齿数组（jagged array）&&即数组的数组。例如：
int[][] = {new int[]{1}, new int[]{4,5,6}, new int[]{1,5}, new int[]{6}, new int[]{2, 3}};
注意：其中的每维的元素个数m、n、ni等，既可以是常数，也可以是变量。即C# 支持动态多维数组。
l& C++只有一维数组，例如：int a[5]; int* a = new int[5]; int a[] = {1, 3, 5, 7, 9};
l& C++/CLI：
n& 一维数组：array&元素类型&^ 数组名 = gcnew array&元素类型&(n); // n为元素个数，使用格式为：数组名[i]。例如：array&int&^ a1 = {3, 5, 6, 8, 6};
n& 多维数组：array&元素类型, 维数m&^ 数组名 = gcnew array&元素类型&(n1, n2, &, nm); // ni为各维的大小。使用格式为：数组名[i1, i2, &, im]。例如：array&String^, 2&^ a2 = gcnew array&String^, 2&(2, 3);
与C++/CLI一样，C# 中的用户数组都是从.NET的System.Array类派生的。Array类的C# 定义为：
[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Array : ICloneable, IList, ICollection, IEnumerable
其公用属性和方法也可以被用户数组所使用，例如，可用只读属性：public int Length { }来获得数组中的元素总数，用方法：public int GetLength (int dimension)来获得指定维的大小等。
6）变量和常量
与C++最大的不同是，C# 不支持全局变量和常量，所有变量和常量都必须位于类或结构之内，它们可以是类变量（字段）与类常量，也可以是函数和块语句中的局部变量和常量。
与C++一样，C# 的变量名也是以字母、下划线开头的字母、下划线和数字串。但是C# 支持逐字标识符，所以也可以在（与保留关键字同名的）变量名前加@字符，但是并不提倡这样做。
与C++不同的是，（但是与Basic相似）C# 会为每个未初始化的成员变量（字段）赋初值：数值变量的初值为0、布尔变量的初值为false、对象实例的初值为空null。但是函数体中的局部变量，必须先初始化后，才能被使用，不然为编译错误。这一点也与C++不同，在C++中使用未初始化的变量是合法的（但是却是无意义的，而且是一种很难排查的逻辑型错误），最多给出一个警告提示。
在C# 中也用const关键字来定义常量，局部常量的声明格式为：
const 类型 常量名 [ = 常量表达式] [,&&, 常量名 [ = 常量表达式]] ;
类的常量成员的声明格式为：
[属性] [常量修饰符] const常量名 [ = 常量表达式] [,&&, 常量名 [ = 常量表达式]] ;
其中，常量修饰符有：new（覆盖基类同名成员）、public、protected、internal（只能被本程序访问）和private。常量名中的字母一般全大写，例如：
public const double X = 1.0, Y = 2.0, Z = 3.0;
与C++一样，C# 中的常量也必须在编译时被初始化，而且在运行时不能被修改。但是与C++不同的是，C# 中的常量默认为静态的。
7）流程控制
程序缺省是顺序执行的，在C# 中可以像C++那样，用条件和开关语句来进行分支控制，用各种迭代语句（包括C# 新增的foreach）来进行循环控制。
C# 的if-else语句与C++的相同，switch-case语句也差不多，区别有：
l& C# 的switch-case语句中的每个case语句必须用break、return、throw或goto语句跳出，不允许像C++那样，多个case语句使用同一个代码段。不过可以用&goto case 标号;&来实现同样的功能。
l& C# 除了允许整数和字符作为选择类型外，还允许用字符串作为选择类型。
switch (name) {
&&&&&& case &张三&:
&&&&&&&&&&&&& &&
&&&&&&&&&&&&&
&&&&&& case &李四&:
&&&&&&&&&&&&& &&
&&&&&&&&&&&&&
&&&&&& default:
&&&&&&&&&&&&& &&
&&&&&&&&&&&&&
C# 除了支持C++的for、while和do-while循环，还增加了与C++/CLI的for each循环类似的foreach循环，格式为：
foreach ( type identifier in expr ) embedded-statement
其中的表达式的计算结果必须为数组或集合类型。例如：
string [] names = {&张三&, &李四&, &王五&, &&};
foreach (string name in names) {&&}
8）类型转换
与C++一样，C# 中的数据在需要时可以进行类型转换（type conversion），这种转换有时是隐式的，也可以用显式的强制转换，还可以用类型转换函数来进行命令式显式转换。
（1）隐式转换
与C++一样，当转换不会造成信息丢失时，C# 一般会采用自动的隐式转换（implicit conversion）。隐式转换包括对数值、枚举和引用的隐式转换。隐式转换可以发生在函数调用、表达式计算和分配时。但是不存在到字符类型char的隐式转换。数值类型的隐式转换参见下表：
隐式数值类型转换
被转换类型
可安全转换到的类型
short、int、long、float、double、decimal
short、ushort、int、uint、long、ulong、float、double、decimal
int、long、float、double、decimal
int、uint、long、ulong、float、double、decimal
long、float、double、decimal
long、ulong、float、double、decimal
float、double、decimal
float、double、decimal
ushort、int、uint、long、ulong、float、double、decimal
（2）显式转换
与C++一样，C# 中的显式转换（implicit conversion）也是指使用强制转换（cast）运算符&(类型)&进行的类型转换。如果显式转换位于&已检验&（checked）上下文内，在被转换的值超出目标类型的取值范围时，会导致OverflowException异常，这是C# 新增的观念。如果显式转换位于&未检验&（unchecked）上下文内，则不会抛出异常，但是转换行为会不明确也不可靠，这点与C++类似。下表列出了可以安全进行显式转换的类型：
显式数值类型转换
被转换类型
可安全转换到的类型
byte、ushort、uint、ulong、char
sbyte、char
sbyte、byte、ushort、uint、ulong、char
sbyte、byte、short、char
sbyte、byte、short、ushort、uint、ulong、char
sbyte、byte、short、ushort、char
sbyte、byte、short、ushort、int、uint、ulong、char
sbyte、byte、short、ushort、int、uint、long、char
sbyte、byte、short、ushort、int、uint、long、ulong、decimal、char
sbyte、byte、short、ushort、int、uint、long、ulong、float、decimal、char
sbyte、byte、short、ushort、int、uint、long、ulong、float、double、char
sbyte、byte、short
（3）命令转换
除了上面所介绍的隐式和显式转换外，在C# 中还可以利用.NET的System.Convert类提供的一套公用静态的转换函数，来进行显式类型转换。参见下表：
已重载。将指定的值转换为等效的布尔值。
已重载。将指定的值转换为8位无符号整数。
已重载。将指定的值转换为Unicode字符。
已重载。将指定的值转换为。
已重载。将指定值转换为数字。
已重载。将指定的值转换为双精度浮点数字。
已重载。将指定的值转换为16位有符号整数。
已重载。将指定的值转换为32位有符号整数。
已重载。将指定的值转换为64位有符号整数。
已重载。将指定的值转换为8位有符号整数。
已重载。将指定的值转换为单精度浮点数字。
已重载。将指定值转换为其等效的String表示形式。
已重载。将指定的值转换为16位无符号整数。
已重载。将指定的值转换为32位无符号整数。
已重载。将指定的值转换为64位无符号整数。
int i = 12345;
Conver.ToInt16(i);
9）命名空间
与标准C++一样，C# 也支持命名空间。定义和使用的方法也差不多，主要区别是分隔符由C++的命名空间分隔符&&双冒号&::&改成了C# 的统一分隔符&&句点&.&。
（1）命名空间声明
C# 也使用关键字namespace来定义命名空间。具体的声明格式为：
namespace 限定标识符 {
&&&&&& [extern alias 标识符 &&] // 外部别名指令
&&&&&& [using指令 &&]
&&&&&& [类型声明 &&] //命名空间成员声明
其中，限定标识符为用句点分隔的命名空间名的层次系列；类型声明包括：类声明、结构声明、接口声明、枚举声明和委托声明。using指令包括using 命名空间指令和using别名指令，将在下面介绍。例如：
namespace N
&&&&&& using List = System.Collections.ArrayL
&&&&&& partial class A
&&&&&&&&&&&&& L // x has type System.Collections.ArrayList
namespace N1
&&&&&& using N;
&&&&&& using A = N.A;
&&&&&& class B: A {} // A means N.A
（2）using 命名空间指令
在C# 中也是用using关键字来使用命名空间，但是不需要namespace关键字。格式为：
using 命名空间; // 相当于C++的using指令&using namespace命名空间;&
&&&&&& // 没有与C++的using声明&using 命名空间::成员;&功能相类似的C# 指令
using System.Windows.F
（3）命名空间的别名
可以用C# 的using别名指令，来定义命名空间及其成员类型的别名。格式为：
using 标识符 = 命名空间或类型名;
using Img = System.Drawing.I // 命名空间别名
using Graph = System.Drawing.G // 类别名
10）Main方法
与C/C++的main函数类似，C# 也有自己的程序入口函数Main。但是与C/C++不同的是，Main不能是全局函数，而必须是类或结构的静态成员方法，且在整个程序中必须唯一。
与C/C++一样，Main方法必须返回int或void类型。与C/C++的main类似，Main方法可以没有输入参数，也可以有一个命令行字符串参数。而C/C++的main则有两个参数，其中一个为命令行中参数的个数，这在C# 中已经变成多余，因为C# 的数组本身就带有Length属性。Main方法具有公用访问级别，但是public修饰符却是不必要的。
Main方法的可用签名（signature）格式为：
static void Main() {&}
static void Main(string[] args) {&}
static int Main() {&}
static int Main(string[] args) {&}
namespace N
&&&&&& class A
&&&&&&&&&&&&& static int Main(string[] args)
&&&&&&&&&&&&& {
&&&&&&&&&&&&&&&&&&&& for (int i = 0; i & args.L i++) Console.WriteLine(args[i]);
&&&&&&&&&&&&&&&&&&&& return 0;
&&&&&&&&&&&&& }
在Visual Sudio自动生成的C# 程序中，Main方法一般位于与项目名同名的命名空间的Program类中。例如：
using System.Collections.G
using System.T
namespace HelloWorld
&&& class Program
&&&&&&& static void Main(string[] args)
-----------