&>&C#基本语法(不熟悉C#语法的可以看看)
C#基本语法(不熟悉C#语法的可以看看)
上传大小：18KB
C#基本语法(不熟悉C#语法的可以看看)
综合评分：0
下载个数：
{%username%}回复{%com_username%}{%time%}\
/*点击出现回复框*/
$(".respond_btn").on("click", function (e) {
$(this).parents(".rightLi").children(".respond_box").show();
e.stopPropagation();
$(".cancel_res").on("click", function (e) {
$(this).parents(".res_b").siblings(".res_area").val("");
$(this).parents(".respond_box").hide();
e.stopPropagation();
/*删除评论*/
$(".del_comment_c").on("click", function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_invalid/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parents(".conLi").remove();
alert(data.msg);
$(".res_btn").click(function (e) {
var parentWrap = $(this).parents(".respond_box"),
q = parentWrap.find(".form1").serializeArray(),
resStr = $.trim(parentWrap.find(".res_area_r").val());
console.log(q);
//var res_area_r = $.trim($(".res_area_r").val());
if (resStr == '') {
$(".res_text").css({color: "red"});
$.post("/index.php/comment/do_comment_reply/", q,
function (data) {
if (data.succ == 1) {
var $target,
evt = e || window.
$target = $(evt.target || evt.srcElement);
var $dd = $target.parents('dd');
var $wrapReply = $dd.find('.respond_box');
console.log($wrapReply);
//var mess = $(".res_area_r").val();
var mess = resS
var str = str.replace(/{%header%}/g, data.header)
.replace(/{%href%}/g, 'http://' + window.location.host + '/user/' + data.username)
.replace(/{%username%}/g, data.username)
.replace(/{%com_username%}/g, data.com_username)
.replace(/{%time%}/g, data.time)
.replace(/{%id%}/g, data.id)
.replace(/{%mess%}/g, mess);
$dd.after(str);
$(".respond_box").hide();
$(".res_area_r").val("");
$(".res_area").val("");
$wrapReply.hide();
alert(data.msg);
}, "json");
/*删除回复*/
$(".rightLi").on("click", '.del_comment_r', function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_comment_del/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parent().parent().parent().parent().parent().remove();
$(e.target).parents('.res_list').remove()
alert(data.msg);
//填充回复
function KeyP(v) {
var parentWrap = $(v).parents(".respond_box");
parentWrap.find(".res_area_r").val($.trim(parentWrap.find(".res_area").val()));
评论共有0条
VIP会员动态
CSDN下载频道资源及相关规则调整公告V11.10
下载频道用户反馈专区
下载频道积分规则调整V1710.18
spring mvc+mybatis+mysql+maven+bootstrap 整合实现增删查改简单实例.zip
资源所需积分/C币
当前拥有积分
当前拥有C币
输入下载码
为了良好体验，不建议使用迅雷下载
C#基本语法(不熟悉C#语法的可以看看)
会员到期时间：
剩余下载个数：
剩余积分：0
为了良好体验，不建议使用迅雷下载
积分不足！
资源所需积分/C币
当前拥有积分
您可以选择
程序员的必选
绿色安全资源
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
您的积分不足，将扣除 10 C币
为了良好体验，不建议使用迅雷下载
无法举报自己的资源
你当前的下载分为234。
你还不是VIP会员
开通VIP会员权限，免积分下载
你下载资源过于频繁，请输入验证码
您因违反CSDN下载频道规则而被锁定帐户，如有疑问，请联络:!
若举报审核通过，可返还被扣除的积分
被举报人：
举报的资源分：
请选择类型
资源无法下载 （ 404页面、下载失败、资源本身问题）
资源无法使用 （文件损坏、内容缺失、题文不符）
侵犯版权资源 （侵犯公司或个人版权）
虚假资源 （恶意欺诈、刷分资源）
含色情、危害国家安全内容
含广告、木马病毒资源
*详细原因：
C#基本语法(不熟悉C#语法的可以看看)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)
-----------