VB.net 2010 视频教程 VB.net 2010 视频教程 c#入门经典教程
当前位置:
主页 > 编程开发 > c#教程 >
  • c#教程之C# 编程基础

  • 2016-04-14 06:50 来源:未知

 C# 编程基础

本节先介绍编写简单控制台的C# 程序的方法,然后系统讲解C# 的基本语法,最后列出C# 的所有关键字。

17.2.1 第一个C# 程序

用Visual Studio 2008创建一个“其他语言”中“Visual C#”的“控制台应用程序”模板的项目HelloWorld,参见图17-5:

图17-5  新建项目对话框
按“确定”按钮关闭对话框后,系统会在指定路径中创建名为HelloWorld的目录和项目,并自动生成代码文件Program.cs(C# 的代码文件名的后缀为cs,是C Sharp的首字母缩写。另外,C# 中没有.h头文件):
using System;
using System.Collections.Generic;
using System.Text;
 
namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}
其中,“using 命名空间;”指令与标准C++的命名空间的using指令“using namespace 命名空间;” 类似;代码都包含在与项目同名的命名空间中;程序类Program中含有程序入口的主方法Main(该方法的参数似C/C++)。
在该程序的Main方法中,添加对控制台的写行方法调用,以输出字符串“Hello, World!”:
    Console.WriteLine("Hello, World!");
注意,类与方法(成员函数)的分隔符不再是C++的“::”而是“.”,串直接量前没有标准C++的普通字符串转换为宽字符串的L运算符。因为在C# 中只有一种字符类型——16位的宽字符类型char。编译并运行该程序,输出结果如图17-6所示。

图17-6  HelloWorld程序运行结果
为了防止不在IDE环境下运行该程序时命令窗口会一闪而逝,可以在上面的语句后面添加如下语句:
            Console.WriteLine("Press any key to close.");
            Console.ReadKey();

17.2.2 基本语法

因为C# 源于C++和Java,所以在语法方面与它们非常相似,但是也存在一些差别。下面系统介绍C# 语法的基本内容,重点放在与C++的不同上。

1.符号与标记

与C++一样,C# 程序也采用区分大小写的自由书写格式,编译器会忽略多余的白空符;C# 也支持“\a”、“\n”和“\t”等转移字符;C# 的每个语句也都以分号“;”结束;语句块也用花括号对“{”和“}”来界定。表17-5列出了C#语言的符号与标记(粗体为C# 特有的)。
    1)文档注释符“///……”和“/**……*/”
C# 除了支持C++的单行注释“// ……”和定界注释“/* …… */”外,还增加了与之对应的如下两种文档注释方式:
表17-5  C# 语言的符号与标记
说明 符号与标记
空白 空格SP
制表符 水平制表符HT(Tab)或垂直制表符VT
标点 . , : ;
行结束符 回车CR
注释 //、/*、*/、///、/**
预处理指令 #
{}
泛型 <> 
可空类型 ?
字符 Unicode字符
转移字符 \代码
逐字符 @"……"、@标识符
数值后缀 d D、f F、l L、lu LU、m M、u U、ul UL
运算符 +、-、*、/、%、++、--、<、==、>、?:、??、()、…
 
l  单行文档注释“/// ……”——“// ……”方式的扩展,增加了一个斜线符“/”。
l  定界文档注释:“/** …… */”——“/* …… */”方式的扩展,在起端增加了一个星号符“*”。
这两种新注释,都用于C# 项目说明文档的自动提取和生成,说明文档采用的是XML格式,由C# 编译器自动生成。但是需要添加/doc编译器选项,或在Visual Studio的IDE中激活该功能。具体方法是:选“项目”菜单中的“*属性”菜单项;在IDE中部打开的项目属性页中,选左列的“生成”选项,在右边下部的“输出”栏中,选中“XML文档文件”复选框以激活文档自动生成功能,还可以输入或修改“输出路径”和文件名,默认为项目的“bin\Debug”或“bin\Release”子目录和“项目名.XML”。参见下图:

图17-7  激活文档自动生成功能
例如,C# 编译器为不加任何注释的HelloWorld项目所生成的说明文档为:
// HelloWorld.XML
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>HelloWorld</name>
    </assembly>
    <members>
    </members>
</doc>
如果你在Program类的定义前加上一行,在键入“///”后,系统会自动生成下面代码中的灰色部分,然后你自己再添加黑色部分。
    /// <summary>
    /// Start class for simple HelloWorld
    /// </summary>
则编译器会自动生成如下说明文档:
// HelloWorld.XML
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>HelloWorld</name>
    </assembly>
    <members>
        <member name="T:HelloWorld.Program">
            <summary>
            Start class for simple HelloWorld
            </summary>
        </member>
    </members>
</doc>
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;
int? y = null;
if (x.HasValue) Console.WriteLine(x.Value); // 输出“123”
if (y.HasValue) Console.WriteLine(y.Value); // 无输出

2.类型

与C++一样,C# 也是一种强类型语言,其每个变量和对象也都必须具有被预先声明的类型。但是由于C# 是专门为.NET设计的语言,所以它的类型体系与C++有很大的不同,而与.NET框架一致。
C# 有如下两大类型种类:
l  值类型——包括简单、枚举、结构和指针等类型。该类型的变量存储数据本身,对值类型的变量进行赋值时,会复制变量所包含的值。其中的指针类型,仅可用于unsafe(非安全)模式。
l  引用类型——包括类、接口和数组等类型。该类型(也称为对象)的变量存储对实际数据的引用,对引用类型的变量进行赋值时,只复制对象的引用(指针/句柄),而不会复制对象本身。
值类型可以通过装箱(boxing)转换成引用类型,然后再经过拆箱(unboxing)转换回值类型。但是无法将原始的引用类型转换为值类型。
C# 不支持联合类型,也没有关键字union。

3.简单类型

简单类型属于C# 语言的值类型,对应于C++语言的基本类型,包括字符、布尔类型、以及整数和实数等数值类型。与C++/CLI相似,C# 中的基本类型都与.NET框架的System命名空间中的对应类型等同,是它们的别名,参见表17-6。
表17-6  C# 的简单类型
C#类型 C++/CLI类型 .NET框架类型 值类型 字节/位数 范围和精度
bool bool System.Boolean 真或假 -/1 true或false
char wchar_t System.Char 字符 2/16 所有UTF-16编码(0~0xFFFF)
sbyte [signed] char System.SByte 整数 1/8 -128 ~ 127
byte unsigned char System.Byte 1/8 0 ~ 255
short [signed] short System.Int16 2/16 -32 768 ~ 32 767
ushort unsigned short System.UInt16 2/16 0 ~ 65 535
int [signed] int/long System.Int32 4/32 -2 147 483 648 ~ 2 147 483 647
uint unsigned int/long System.UInt32 4/32 0 ~ 4 294 967 295
long [signed] long long System.Int64 8/64 -9 223 372 036 854 775 808
~ 9 223 372 036 854 775 807
ulong unsigned long long System.UInt64 8/64 0 ~ 18 446 744 073 709 551 615
float float System.Single 浮点数 4/32 ±1.5×10-45 ~ ±3.4×1038
double double System.Double 8/64 ±5.0×10-324 ~ ±1.7×10308
decimal Decimal System.Decimal 高精度十进制小数 16/128 ±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++不同的是:
l  可以用(从System.Object继承的)GetType()方法来获得指定变量或对象的类型名称。简单类型返回的是.NET的类型名,对象则返回类或结构的名称。例如:
int i = 1;
MyClass obj;
Console.WriteLine("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,该类型主要用于货币(money)的数量计算。在C# 中可以用m或M后缀,将一个实数常量指定为decimal类型。没有后缀的实数会被视为double类型,直接赋值给decimal变量会导致编译错误。例如:
decimal money = 1234.5m; // 正确
decimal d = 1234.5; // 编译错误

3.运算符与表达式

C# 运算符和表达式与C/C++几乎完全一样,仅有的区别如下:
1)基元(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 -727379968
    }
    static int H() {
       return x * y; // Depends on default
    }
}
又例如:
try {
     int i, i2 = int.MaxValue, i2 = 200;
     i = checked(i1 * i2);
 } catch(Exception e){
     //MessageBox.Show(e.ToString());
     Console.WriteLine(e.ToString());
 }
2)一元运算符——全局命名空间限定符::。虽然C# 不再支持全局变量和全局函数,但是仍然有全局命名空间,所以还是保留了全局命名空间限定符“::”(类似于C++的全局运算符::)。注意,因为在C# 中,双冒号符“::”已经不再(似C++)作为命名空间之间和CLR对象与成员之间的分隔符,而是专用的全局命名空间限定符。
3)二元运算符:
l  模运算符%——在C# 中,%除了可以像C++那样用来求整数的余外,还可以用于浮点数和decimal类型。例如5 % 1.5 = 0.5。
l  是运算符is——用于动态检验一个对象的运行时类型是否与指定类型兼容。格式为:表达式 is 类型名。结果为一个布尔值,若表达式可以成功地转换成指定类型,则为true,否则为false。
l  转为运算符as——用于将一个值显式地转换为一个指定的引用类型或可空(值)类型。格式为:标识符 as 类型名。转换为引用类型时,采用的是引用转换或装箱转换;转换为可空类型时,采用的是包装转换、拆箱转换或空类型转换。与强制转换不同,as转换不会抛出异常。如果指定的转换是不可能的,则结果为空null。
is和as运算符在模板和泛型运算中非常有用。
l  空接合运算符(null coalescing operator)??——用于在某个可空类型变量a的值为空时,提供备用的值b。格式为:a ?? b。当a非空时结果为a,否则为b。功能相对于:a.HasValue ? a : b。例如:
double? x = null;
……
double y = x ?? 0;
C# 表达式中运算符优先级与C++的类似,参见表17-7(粗体的是C# 特有的):
表17-7  C# 运算符优先级表(从高到低)
优先级 类型 运算符
1 基元 .(成员,如x.y)、( )(方法,如f(x))、[ ](数组,如a[i])、++(后缀增,如i++)、--(后缀减,如i--)、new(创建对象,如new MyClass)、typeof(类型,如typeof(x))、checked(已检验,如checked(x*y))、unchecked(未检验,如unchecked(x*y))
2 一元 +(正,如+x)、-(负,如-x)、!(逻辑非,如!x)、~(求补,如~x)、++(前缀加,如++i)、--(前缀减,如--i)、()(强制类型转换,如(int)x)
3 乘性 *(乘,如x*y)、/(除,如x/y)、%(模,如x%y)
4 加性 +(加,如x+y)、-(减,如x-y)
5 位移 <<(左移,如i<<4)、>>(右移,如i>>4)
6 关系和
类型测试
<(小于,如x<y)、>(大于,如x>y)、<=(小于等于,如x<=y)、>=(大于等于,如x>=y)、is(是,如x is int)、as(转为,如x as int)
7 等性 ==(相等,如x==y)、!=(不等,如x!=y)
8 逻辑与 &(位与,如x&4)
9 逻辑异或 ^(位异或,如x^y)
10 逻辑或 |(位或,如x|y)
11 条件与 &&(逻辑与,如x&&y)
12 条件或 ||(逻辑或,如x||y)
13 空接合 ??(空接合,如a??b)
14 条件 ?:(条件,如x?a:b)
15 赋值 =(等于,如x=y)、*=(乘等于,如x*=y)、/=(除等于,如x/=y)、+=(加等于,如x+=y)、-=(减等于,如x-=y)、<<=(左移等于,如x<<=y)、>>=(右移等于,如x>>=y)、&=(位与等于,如x&=y)、^=(位异或等于,如x^=y)、|=(位或等于,如x|=y)
 

4.枚举

与C/C++类似,C# 中的枚举(enumeration)类型也是一个命名常量的集合。枚举声明的完整格式为(灰色方括号[ ]中的内容是可选的):
[[属性]] [枚举修饰符] enum 标识符 [: 整型基类型] {
       [[属性]] 标识符 [ = 常量表达式],
       ……
       [[属性]] 标识符 [ = 常量表达式]
}[;]
其中,枚举修饰符有:new、public、protected、internal、private, 默认为private。默认的整数基类型为int。常用格式为:
enum 枚举名 [: 基类型] {枚举成员名 [= 枚举值], ……,
              枚举成员名 [= 枚举值]};
例如:
enum Color {Red, Green, Blue}
enum Days : byte {Sun, Mon, Tue, Wed, Thu, Fri, Sat};
C# 的枚举类型都是抽象类类型System.Enum结构的派生值类型。Enum的C#定义如下:
[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Enum : ValueType, IComparable, IFormattable, IConvertible
包含多个公用方法成员(参见表17-8),可以在用户定义的枚举类型中,使用这些公用方法。
表17-8  Enum类的部分静态公用方法
名称 说明
Format 根据指定格式将指定枚举类型的指定值转换为其等效的字符串表示形式。
GetName 在指定枚举中检索具有指定值的常数的名称。
GetNames 检索指定枚举中常数名称的数组。
GetUnderlyingType 返回指定枚举的基础类型。
GetValues 检索指定枚举中常数值的数组。
IsDefined 返回指定枚举中是否存在具有指定值的常数的指示。
Parse 已重载。将一个或多个枚举常数的名称或数字值的字符串表示转换成等效的枚举对象。
 
与C++不同,你不能用整数值来代替枚举值。而且枚举可以作为顶层类型,也可以作为类的成员(嵌套类型),但是不能作为局部类型来定义,这点也与C++不同。还有一个与C++不同点是,在C# 的枚举类型定义体后的分号是可选的,而在C++中却是必须的。

5.数组

C# 中的数组与C++的很相似,但是其声明格式却与C++同。C# 数组与C++的最大差别是,C# 支持多维数组(也支持C++的数组的数组)。
下面是C# 数组的声明格式(其中的灰色方括号表示可选项)和使用格式:
l  一维数组——声明格式为:
类型[] 数组名 [ = [new 类型[[n]] ] {表达式1, ……, 表达式n} ];
例如:
int[] a = {0, 2, 4, 6, 8};
string[] sa = new string[5];
object[] array;
使用格式为:数组名[i]。例如:sa[2] = "abcd";
l  二维数组——声明格式为:
类型[,] 数组名 [ = [new 类型[[m, n]] ] {{表达式11, ……, 表达式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# 支持动态多维数组。
比较:C++只有一维数组,而且数组的声明格式左边内的方括号在数组名之后,而不是在类型名之后。例如:
int a[5]; // C# 不能如此简洁地声明数组,左边方括号内不允许指定元素数
int* a = new int[5]; // 对应于C# 的int[] a = new int[5];
int a[] = {1, 3, 5, 7, 9}; // 对应于C# 的int[] a ={1, 3, 5, 7, 9};
C# 中的用户数组都是从.NET的System.Array类派生的。Array类的C# 定义为:
[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Array : ICloneable, IList, ICollection, IEnumerable
其公用属性和方法也可以被用户数组所使用,例如,可用只读属性:public int Length { get; }来获得数组中的元素总数,用方法:public int GetLength (int dimension)来获得指定维的元素数等。

6.变量和常量

与C++最大的不同是,C# 不支持全局变量和常量,所有变量和常量都必须位于类或结构之内,它们可以是类变量(字段)与类常量,也可以是方法(成员函数)和块语句中的局部变量和常量。
与C++一样,C# 的变量名也是以字母、下划线开头的字母、下划线和数字串。但是C# 支持逐字标识符,所以也可以在(与保留关键字同名的)变量名前加@字符,但是并不提倡这样做。
与C++不同的是,(但是与Basic相似)C# 会为每个未初始化的成员变量(字段)赋初值:数值变量的初值为0、布尔变量的初值为false、对象实例的初值为空null。但是C# 并不为局部变量赋初值,所以方法体中的局部变量,必须先初始化后,才能被使用,不然为编译错误。这一点也与C++不同,在C++中使用未初始化的变量是合法的(但是却是无意义的,而且可能是一种很难排查的逻辑型错误),最多给出一个警告提示。
在C# 中也用const关键字来定义常量,局部常量的声明格式为:
const 类型 常量名 [ = 常量表达式] [,……, 常量名 [ = 常量表达式]];
类的常量成员的声明格式为:
[[属性]] [常量修饰符] const常量名 [ = 常量表达式] [,……, 常量名 [ = 常量表达式]];
其中,常量修饰符有:new(覆盖基类同名成员)、public、protected、internal(只能被本程序访问)和private。常量名中的字母一般全大写,例如:
public const double PI = 3.14159, MAX = 100.0;
与C++一样,C# 中的常量也必须在编译时被初始化,而且在运行时不能被修改。但是与C++不同的是,C# 中的常量默认为静态的。

7.流程控制

程序默认是顺序执行的,在C# 中可以像C++那样,用条件和开关语句来进行分支控制,用各种迭代语句(包括C# 新增的foreach)来进行循环控制。
1)分支
C# 的if-else语句与C++的相同,switch-case语句也差不多,区别有:
l  C# 的switch-case语句中的每个case语句必须用break、return、throw或goto语句跳出,不允许像C++那样,多个case语句使用同一个代码段。不过可以用“goto case 标号;”来实现同样的功能。
l  C# 除了允许整数和字符作为选择类型外,还允许用字符串作为选择类型。
例如:
string name;
……
switch (name) {
    case "张三": …… break;
    case "李四": …… break;
    ……
    default: …… break;
}
2)循环
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的隐式转换。数值类型的隐式转换参见表17-9。
表17-9  隐式数值类型转换
被转换类型 可安全转换到的类型
sbyte short、int、long、float、double、decimal
byte short、ushort、int、uint、long、ulong、float、double、decimal
short int、long、float、double、decimal
ushort int、uint、long、ulong、float、double、decimal
int long、float、double、decimal
uint long、ulong、float、double、decimal
long float、double、decimal
ulong float、double、decimal
float double
char ushort、int、uint、long、ulong、float、double、decimal
 
2)显式转换
与C++一样,C# 中的显式转换(implicit conversion)也是指使用强制转换(cast)运算符“(类型)”进行的类型转换。如果显式转换位于“已检验”(checked)上下文内,在被转换的值超出目标类型的取值范围时,会导致OverflowException异常,这是C# 新增的观念。如果显式转换位于“未检验”(unchecked)上下文内,则不会抛出异常,但是转换行为会不明确也不可靠,这点与C++类似。表17-10列出了可以安全进行显式转换的类型。
表17-10  显式数值类型转换
被转换类型 可安全转换到的类型
sbyte byte、ushort、uint、ulong、char
byte sbyte、char
short sbyte、byte、ushort、uint、ulong、char
ushort sbyte、byte、short、char
int sbyte、byte、short、ushort、uint、ulong、char
uint sbyte、byte、short、ushort、char
long sbyte、byte、short、ushort、int、uint、ulong、char
ulong sbyte、byte、short、ushort、int、uint、long、char
float sbyte、byte、short、ushort、int、uint、long、ulong、decimal、char
double sbyte、byte、short、ushort、int、uint、long、ulong、float、decimal、char
decimal sbyte、byte、short、ushort、int、uint、long、ulong、float、double、char
char sbyte、byte、short
 
3)命令转换
除了上面所介绍的隐式和显式转换外,在C# 中还可以利用.NET的System.Convert类提供的一套公用静态的转换方法,来进行显式类型转换,参见表17-11。
表17-11  显式类型转换的静态方法
方法 功能
ToBoolean 将指定的值转换为等效的布尔值。
ToByte 将指定的值转换为8位无符号整数。
ToChar 将指定的值转换为Unicode字符。
ToDateTime 将指定的值转换为DateTime
ToDecimal 将指定值转换为Decimal数字。
ToDouble 将指定的值转换为双精度浮点数字。
ToInt16 将指定的值转换为16位有符号整数。
ToInt32 将指定的值转换为32位有符号整数。
ToInt64 将指定的值转换为64位有符号整数。
ToSByte 将指定的值转换为8位有符号整数。
ToSingle 将指定的值转换为单精度浮点数字。
ToString 将指定值转换为其等效的String表示形式。
ToUInt16 将指定的值转换为16位无符号整数。
ToUInt32 将指定的值转换为32位无符号整数。
ToUInt64 将指定的值转换为64位无符号整数。
 
例如:
using System;
int i = 1234;
Conver.ToInt16(i);

9.命名空间

与标准C++一样,C# 也支持命名空间。定义和使用的方法也差不多,主要区别是分隔符由C++的命名空间分隔符——双冒号“::”改成了C# 的统一分隔符——句点“.”。
1)命名空间声明
C# 也使用关键字namespace来定义命名空间。具体的声明格式为:
namespace 限定标识符 {
       [extern alias 标识符 ……] // 外部别名指令
       [using指令 ……]
       [类型声明 ……] //命名空间成员声明
}
其中,限定标识符为用句点分隔的命名空间名的层次系列;类型声明包括:类声明、结构声明、接口声明、枚举声明和委托声明。using指令包括using 命名空间指令和using别名指令,将在下面介绍。例如:
namespace N {
    using List = System.Collections.ArrayList;
    partial class A {
       List x; // x为System.Collections.ArrayList类型
    }
}
namespace N1 {
    using N;
    using A = N.A;
    class B: A {} // A等于N.A
}
2)using 命名空间指令
在C# 中也是用using关键字来使用命名空间,但是不需要namespace关键字。格式为:
using 命名空间; // 相当于C++的using指令“using namespace命名空间;”
例如:
using System;
using System.Windows.Forms;
注意,没有与C++的using声明“using 命名空间::成员;”功能类似的C# 指令。
3)命名空间的别名
可以用C# 的using别名指令,来定义命名空间及其成员类型的别名。格式为:
using 标识符 = 命名空间或类型名;
例如:
using Img = System.Drawing.Imaging; // 命名空间别名
using Graph = System.Drawing.Graphics; // 类别名

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) {…}
例如:
using System;
namespace N {
    class A {
       static int Main(string[] args) {
           for (int i = 0; i < args.Length; i++)
              Console.WriteLine(args[i]);
           return 0;
       }
    }
}
在Visual Sudio自动生成的C# 程序中,Main方法一般位于与项目名同名的命名空间的Program类中,参见17.2.1中的例子代码。

17.2.3 关键字

C# 有两类关键字,普通关键字(keyword)是不能用作标识符的保留字,上下文关键字(contextual keyword)不是保留字,只是在特定的上下文中提供特殊的代码含义。
C# 3.0有77个普通关键字和14个上下文关键字(contextual keyword),C# 4.0增加了将原有的两个普通关键字in和out作为泛型修饰符的用法,还增加了4个新的上下文关键字。所以,C# 有77个不同的关键字和18个不同的上下文关键字,共计95个不同的关键字,参见 表17-12和 表17-13。表中,粗体的为C# 特有的关键字,斜粗体的为4.0版新增加的,其余(正常的)为与C++相同的关键字。
表17-12  C# 关键字(77+2个)
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 (泛型修饰符) int interface
internal is lock long
namespace new null object
operator out out (泛型修饰符) 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  
 
表17-13  C# 的上下文关键字(18+2个)
add dynamic from (in) get
global group (by) into join(in on equals)
let orderby(descending) partial (类型) partial (方法)
remove select set value
var where (泛型类型约束) where (查询子句) yield
 
 
在上下文关键字中,partial(分部/部分)包含2.0版引进的partial(类型)和3.0版引进的partial(方法),where(在哪里/什么地方)包含2.0版引进的where(泛型类型约束)和3.0版引进的where(查询子句);3.0版引进的from、group、into、join、let、orderby、select等7个用于LINQ查询;var用于定义隐式类型的本地变量(一种由编译器确定类型的强类型变量)也是3.0版引进的;add和remove用于定义在用户代码预订(subscribes to)和退订(unsubscribes from)你的事件时调用的定制事件访问程序(custom event accessor)、dynamic用于定义动态类型的变量、global::用于指明全局命名空间(为C# 程序的默认无名命名空间)它们4个都是4.0版新引进的。
C# 中不支持的标准C++关键字有如下20个(其中粗体为常用的):asm、auto、const_cast、delete、dynamic_cast、export、friendinline、mutable、register、reinterpret_cast、signed、static_cast、templatetypedef、typeid、typename、unionunsignedwchar_t
相关教程
关于我们--广告服务--免责声明--本站帮助-友情链接--版权声明--联系我们       黑ICP备07002182号