C#标点符解释和用法

ALEX_DF_LJ 2009-12-13 02:12:44

高手们，帮帮忙吧！
在c#中的标点符的意义和用法是怎样的，如；是结束的吧！那"" , () [] {}等是怎用的，还有使用条件是怎样的？可以的话，把所有的标点符都写出来，解释下，教下小弟怎用吧！
谢过先啦！

...全文

96 10 打赏收藏转发到动态举报

写回复

用AI写文章

10 条回复

切换为时间正序

请发表友善的回复…

发表回复

十八道胡同 2009-12-13

打赏
举报

[Quote=引用 7 楼 alex_df_lj 的回复:]
嗯，谢谢大家！！本人正努力学习中，以后还要大家多提提小弟啊！！
[/Quote]
你从书上或者搜索一下比在这里等答案来的快。
Good Luck

Java_And_NET 2009-12-13

打赏
举报

string question = “是结束的吧！那"" , () [] {}等是怎用的，还有使用条件是怎样的？”；

private string GetStudyMethod()
{
string result = “”；
if(question == "不会")
{
result = "看书";
}
else
{
result = "看书";
}
return result;
}

Thr21ough 2009-12-13

打赏
举报

up~

ALEX_DF_LJ 2009-12-13

打赏
举报

嗯，谢谢大家！！本人正努力学习中，以后还要大家多提提小弟啊！！

xzjxylophone 2009-12-13

打赏
举报

多练习自然而然你该会的就全部会了。。。。。

ahfnlx 2009-12-13

打赏
举报

1111111122222222222222qqqqqqqqqqqqqqqqq

powerchuangwai 2009-12-13

打赏
举报

符号都简单,需要熟悉基本结构和框架...

tianliang1 2009-12-13

打赏
举报

"",里面放字符串的如String str="你好!";
(),一般在判断的时候用如if(条件)，while(条件)。。。
[],定义数组的时候用 int [] ab=new int [2]
{},初始化数据的时候用 int [] ab =new int[2]{1,2}
多看看书吧，尤其是教材，不用去记这些东西，你慢慢会掌握的

wuyq11 2009-12-13

打赏
举报

看MSDN
http://msdn.microsoft.com/zh-cn/library/aa691093(VS.71).aspx

红街咖啡 2009-12-13

打赏
举报

int[] array=new int[5];//声明长度为5的数组
string a="AAA";
int[] array={0,1,2};

if(1==1)
{
//看看书吧..
}

目录 1. 简介 1 1.1 Hello world 1 1.2 程序结构 2 1.3 类型和变量 3 1.4 表达式 6 1.5 语句 8 1.6 类和对象 12 1.6.1 成员 12 1.6.2 可访问性 13 1.6.3 类型参数 13 1.6.4 基类 14 1.6.5 字段 14 1.6.6 方法 15 1.6.6.1 参数 15 1.6.6.2 方法体和局部变量 17 1.6.6.3 静态方法和实例方法 17 1.6.6.4 虚方法、重写方法和抽象方法 18 1.6.6.5 方法重载 20 1.6.7 其他函数成员 21 1.6.7.1 构造函数 22 1.6.7.2 属性 23 1.6.7.3 索引器 23 1.6.7.4 事件 23 1.6.7.5 运算符 24 1.6.7.6 析构函数 25 1.7 结构 25 1.8 数组 26 1.9 接口 27 1.10 枚举 28 1.11 委托 29 1.12 特性 30 2. 词法结构 33 2.1 程序 33 2.2 文法 33 2.2.1 文法表示法 33 2.2.2 词法文法 34 2.2.3 句法文法 34 2.3 词法分析 34 2.3.1 行结束符 35 2.3.2 注释 35 2.3.3 空白 36 2.4 标记 37 2.4.1 Unicode 字符转义序列 37 2.4.2 标识符 38 2.4.3 关键字 39 2.4.4 文本 41 2.4.4.1 布尔值 41 2.4.4.2 整数 41 2.4.4.3 实数 42 2.4.4.4 字符 43 2.4.4.5 字符串 44 2.4.4.6 null 文本 46 2.4.5 运算符和标点符号 46 2.5 预处理指令 46 2.5.1 条件编译符号 47 2.5.2 预处理表达式 48 2.5.3 声明指令 49 2.5.4 条件编译指令 49 2.5.5 诊断指令 52 2.5.6 区域指令 52 2.5.7 行指令 53 2.5.8 Pragma 指令 53 2.5.8.1 Pragma warning 54 3. 基本概念 55 3.1 应用程序启动 55 3.2 应用程序终止 56 3.3 声明 56 3.4 成员 58 3.4.1 命名空间成员 58 3.4.2 结构成员 59 3.4.3 枚举成员 59 3.4.4 类成员 59 3.4.5 接口成员 59 3.4.6 数组成员 60 3.4.7 委托成员 60 3.5 成员访问 60 3.5.1 已声明可访问性 60 3.5.2 可访问域 61 3.5.3 实例成员的受保护访问 63 3.5.4 可访问性约束 64 3.6 签名和重载 65 3.7 范围 66 3.7.1 名称隐藏 68 3.7.1.1 通过嵌套隐藏 68 3.7.1.2 通过继承隐藏 69 3.8 命名空间和类型名称 70 3.8.1 完全限定名 72 3.9 自动内存管理 73 3.10 执行顺序 75 4. 类型 77 4.1 值类型 77 4.1.1 System.ValueType 类型 78 4.1.2 默认构造函数 78 4.1.3 结构类型 79 4.1.4 简单类型 79 4.1.5 整型 80 4.1.6 浮点型 81 4.1.7 decimal 类型 82 4.1.8 bool 类型 82 4.1.9 枚举类型 82 4.1.10 可以为 null 的类型 83 4.2 引用类型 83 4.2.1 类类型 84 4.2.2 对象类型 84 4.2.3 dynamic 类型 84 4.2.4 string 类型 85 4.2.5 接口类型 85 4.2.6 数组类型 85 4.2.7 委托类型 85 4.3 装箱和拆箱 85 4.3.1 装箱转换 85 4.3.2 拆箱转换 87 4.4 构造类型 87 4.4.1 类型实参 88 4.4.2 开放和封闭类型 88 4.4.3 绑定和未绑定类型 89 4.4.4 满足约束 89 4.5 类型形参 90 4.6 表达式树类型 91 4.7 dynamic 类型 91 5. 变量 93 5.1 变量类别 93 5.1.1 静态变量 93 5.1.2 实例变量 93 5.1.2.1 类中的实例变量 93 5.1.2.2 结构中的实例变量 94 5.1.3 数组元素 94 5.1.4 值参数 94 5.1.5 引用形参 94 5.1.6 输出形参 94 5.1.7 局部变量 95 5.2 默认值 95 5.3 明确赋值 96 5.3.1 初始已赋值变量 96 5.3.2 初始未赋值变量 97 5.3.3 确定明确赋值的细则 97 5.3.3.1 一般语句规则 98 5.3.3.2 块语句、checked 和 unchecked 语句 98 5.3.3.3 表达式语句 98 5.3.3.4 声明语句 98 5.3.3.5 if 语句 98 5.3.3.6 switch 语句 99 5.3.3.7 while 语句 99 5.3.3.8 do 语句 99 5.3.3.9 for 语句 99 5.3.3.10 break、continue 和 goto 语句 100 5.3.3.11 throw 语句 100 5.3.3.12 return 语句 100 5.3.3.13 try-catch 语句 100 5.3.3.14 try-finally 语句 100 5.3.3.15 try-catch-finally 语句 101 5.3.3.16 foreach 语句 102 5.3.3.17 using 语句 102 5.3.3.18 lock 语句 102 5.3.3.19 yield 语句 102 5.3.3.20 简单表达式的一般规则 102 5.3.3.21 带有嵌入表达式的表达式的一般规则 103 5.3.3.22 调用表达式和对象创建表达式 103 5.3.3.23 简单赋值表达式 103 5.3.3.24 && 表达式 104 5.3.3.25 || 表达式 104 5.3.3.26 ! 表达式 105 5.3.3.27 ?? 表达式 106 5.3.3.28 ?: 表达式 106 5.3.3.29 匿名函数 106 5.4 变量引用 107 5.5 变量引用的原子性 107 6. 转换 109 6.1 隐式转换 109 6.1.1 标识转换 110 6.1.2 隐式数值转换 110 6.1.3 隐式枚举转换 110 6.1.4 可以为 null 的隐式转换 110 6.1.5 null 文本转换 111 6.1.6 隐式引用转换 111 6.1.7 装箱转换 111 6.1.8 隐式动态转换 112 6.1.9 隐式常量表达式转换 112 6.1.10 涉及类型形参的隐式转换 112 6.1.11 用户定义的隐式转换 113 6.1.12 匿名函数转换和方法组转换 113 6.2 显式转换 113 6.2.1 显式数值转换 114 6.2.2 显式枚举转换 115 6.2.3 可以为 null 的显式转换 115 6.2.4 显式引用转换 116 6.2.5 拆箱转换 117 6.2.6 显式动态转换 117 6.2.7 涉及类型形参的显式转换 118 6.2.8 用户定义的显式转换 118 6.3 标准转换 119 6.3.1 标准隐式转换 119 6.3.2 标准显式转换 119 6.4 用户定义的转换 119 6.4.1 允许的用户定义转换 119 6.4.2 提升转换运算符 119 6.4.3 用户定义转换的计算 120 6.4.4 用户定义的隐式转换 120 6.4.5 用户定义的显式转换 121 6.5 匿名函数转换 122 6.5.1 匿名函数转换为委托类型的计算 123 6.5.2 匿名函数转换为表达式树类型的计算 124 6.5.3 实现示例 124 6.6 方法组转换 126 7. 表达式 129 7.1 表达式的分类 129 7.1.1 表达式的值 130 7.2 静态和动态绑定 130 7.2.1 绑定时间 131 7.2.2 动态绑定 131 7.2.3 构成表达式的类型 131 7.3 运算符 131 7.3.1 运算符的优先级和顺序关联性 132 7.3.2 运算符重载 133 7.3.3 一元运算符重载决策 134 7.3.4 二元运算符重载决策 134 7.3.5 候选用户定义运算符 134 7.3.6 数值提升 135 7.3.6.1 一元数值提升 135 7.3.6.2 二元数值提升 135 7.3.7 提升运算符 136 7.4 成员查找 137 7.4.1 基类型 138 7.5 函数成员 138 7.5.1 实参列表 140 7.5.1.1 对应形参 141 7.5.1.2 实参列表的运行时计算 142 7.5.2 类型推断 143 7.5.2.1 第一阶段 144 7.5.2.2 第二阶段 144 7.5.2.3 输入类型 144 7.5.2.4 输出类型 145 7.5.2.5 依赖 145 7.5.2.6 输出类型推断 145 7.5.2.7 参数类型显式推断 145 7.5.2.8 精确推断 145 7.5.2.9 下限推断 145 7.5.2.10 上限推断 146 7.5.2.11 固定 147 7.5.2.12 推断返回类型 147 7.5.2.13 方法组转换的类型推断 148 7.5.2.14 查找一组表达式的最通用类型 148 7.5.3 重载决策 149 7.5.3.1 适用函数成员 149 7.5.3.2 更好的函数成员 150 7.5.3.3 表达式的更佳转换 151 7.5.3.4 类型的更佳转换 151 7.5.3.5 更佳转换目标 151 7.5.3.6 泛型类中的重载 151 7.5.4 动态重载决策的编译时检查 152 7.5.5 函数成员调用 152 7.5.5.1 已装箱实例上的调用 153 7.6 基本表达式 154 7.6.1 文本 154 7.6.2 简单名称 154 7.6.2.1 块中的固定含义 155 7.6.3 带括号的表达式 156 7.6.4 成员访问 157 7.6.4.1 相同的简单名称和类型名称 158 7.6.4.2 语法多义性 159 7.6.5 调用表达式 159 7.6.5.1 方法调用 160 7.6.5.2 扩展方法调用 161 7.6.5.3 委托调用 163 7.6.6 元素访问 164 7.6.6.1 数组访问 164 7.6.6.2 索引器访问 165 7.6.7 this 访问 165 7.6.8 基访问 166 7.6.9 后缀增量和后缀减量运算符 166 7.6.10 new 运算符 167 7.6.10.1 对象创建表达式 168 7.6.10.2 对象初始值设定项 169 7.6.10.3 集合初始值设定项 171 7.6.10.4 数组创建表达式 172 7.6.10.5 委托创建表达式 174 7.6.10.6 匿名对象创建表达式 175 7.6.11 typeof 运算符 177 7.6.12 checked 和 unchecked 运算符 178 7.6.13 默认值表达式 180 7.6.14 匿名方法表达式 181 7.7 一元运算符 181 7.7.1 一元加运算符 181 7.7.2 一元减运算符 181 7.7.3 逻辑否定运算符 182 7.7.4 按位求补运算符 182 7.7.5 前缀增量和减量运算符 182 7.7.6 强制转换表达式 183 7.8 算术运算符 184 7.8.1 乘法运算符 184 7.8.2 除法运算符 185 7.8.3 余数运算符 186 7.8.4 加法运算符 187 7.8.5 减法运算符 189 7.9 移位运算符 190 7.10 关系和类型测试运算符 192 7.10.1 整数比较运算符 192 7.10.2 浮点比较运算符 193 7.10.3 小数比较运算符 194 7.10.4 布尔相等运算符 194 7.10.5 枚举比较运算符 194 7.10.6 引用类型相等运算符 194 7.10.7 字符串相等运算符 196 7.10.8 委托相等运算符 196 7.10.9 相等运算符和 null 197 7.10.10 is 运算符 197 7.10.11 as 运算符 197 7.11 逻辑运算符 198 7.11.1 整数逻辑运算符 199 7.11.2 枚举逻辑运算符 199 7.11.3 布尔逻辑运算符 199 7.11.4 可以为 null 的布尔逻辑运算符 199 7.12 条件逻辑运算符 200 7.12.1 布尔条件逻辑运算符 200 7.12.2 用户定义的条件逻辑运算符 201 7.13 空合并运算符 201 7.14 条件运算符 202 7.15 匿名函数表达式 203 7.15.1 匿名函数签名 204 7.15.2 匿名函数体 205 7.15.3 重载决策 205 7.15.4 匿名函数与动态绑定 206 7.15.5 外层变量 206 7.15.5.1 捕获的外层变量 206 7.15.5.2 局部变量实例化 207 7.15.6 匿名函数表达式计算 209 7.16 查询表达式 209 7.16.1 查询表达式的多义性 210 7.16.2 查询表达式转换 210 7.16.2.1 带继续符的 select 和 groupby 子句 211 7.16.2.2 显式范围变量类型 211 7.16.2.3 退化查询表达式 212 7.16.2.4 from、let、where、join 和 orderby 子句 212 7.16.2.5 select 子句 216 7.16.2.6 Groupby 子句 216 7.16.2.7 透明标识符 216 7.16.3 查询表达式模式 218 7.17 赋值运算符 219 7.17.1 简单赋值 219 7.17.2 复合赋值 221 7.17.3 事件赋值 222 7.18 表达式 222 7.19 常量表达式 223 7.20 布尔表达式 224 8. 语句 225 8.1 结束点和可到达性 225 8.2 块 227 8.2.1 语句列表 227 8.3 空语句 228 8.4 标记语句 228 8.5 声明语句 229 8.5.1 局部变量声明 229 8.5.2 局部常量声明 230 8.6 表达式语句 231 8.7 选择语句 231 8.7.1 if 语句 231 8.7.2 switch 语句 232 8.8 迭代语句 236 8.8.1 while 语句 236 8.8.2 do 语句 236 8.8.3 for 语句 237 8.8.4 foreach 语句 238 8.9 跳转语句 240 8.9.1 break 语句 241 8.9.2 continue 语句 242 8.9.3 goto 语句 242 8.9.4 return 语句 243 8.9.5 throw 语句 244 8.10 try 语句 245 8.11 checked 语句和 unchecked 语句 247 8.12 lock 语句 248 8.13 using 语句 248 8.14 yield 语句 250 9. 命名空间 253 9.1 编译单元 253 9.2 命名空间声明 253 9.3 Extern 别名 254 9.4 using 指令 255 9.4.1 using 别名指令 256 9.4.2 Using 命名空间指令 258 9.5 命名空间成员 260 9.6 类型声明 260 9.7 命名空间别名限定符 261 9.7.1 别名的唯一性 262 10. 类 263 10.1 类声明 263 10.1.1 类修饰符 263 10.1.1.1 抽象类 264 10.1.1.2 密封类 264 10.1.1.3 静态类 264 10.1.2 分部修饰符 265 10.1.3 类型形参 265 10.1.4 类基本规范 266 10.1.4.1 基类 266 10.1.4.2 接口实现 267 10.1.5 类型形参约束 268 10.1.6 类体 272 10.2 分部类型 272 10.2.1 特性 272 10.2.2 修饰符 273 10.2.3 类型形参和约束 273 10.2.4 基类 273 10.2.5 基接口 274 10.2.6 成员 274 10.2.7 分部方法 275 10.2.8 名称绑定 277 10.3 类成员 277 10.3.1 实例类型 278 10.3.2 构造类型的成员 279 10.3.3 继承 280 10.3.4 new 修饰符 280 10.3.5 访问修饰符 281 10.3.6 构成类型 281 10.3.7 静态成员和实例成员 281 10.3.8 嵌套类型 282 10.3.8.1 完全限定名 282 10.3.8.2 已声明可访问性 282 10.3.8.3 隐藏 283 10.3.8.4 this 访问 283 10.3.8.5 对包含类型的私有和受保护成员的访问 284 10.3.8.6 泛型类中的嵌套类型 285 10.3.9 保留成员名称 286 10.3.9.1 为属性保留的成员名称 286 10.3.9.2 为事件保留的成员名称 287 10.3.9.3 为索引器保留的成员名称 287 10.3.9.4 为析构函数保留的成员名称 287 10.4 常量 287 10.5 字段 289 10.5.1 静态字段和实例字段 290 10.5.2 只读字段 291 10.5.2.1 对常量使用静态只读字段 291 10.5.2.2 常量和静态只读字段的版本控制 291 10.5.3 可变字段 292 10.5.4 字段初始化 293 10.5.5 变量初始值设定项 293 10.5.5.1 静态字段初始化 294 10.5.5.2 实例字段初始化 295 10.6 方法 296 10.6.1 方法形参 298 10.6.1.1 值参数 299 10.6.1.2 引用形参 299 10.6.1.3 输出形参 300 10.6.1.4 形参数组 301 10.6.2 静态方法和实例方法 303 10.6.3 虚方法 304 10.6.4 重写方法 305 10.6.5 密封方法 307 10.6.6 抽象方法 308 10.6.7 外部方法 309 10.6.8 分部方法 310 10.6.9 扩展方法 310 10.6.10 方法体 311 10.6.11 方法重载 311 10.7 属性 311 10.7.1 静态属性和实例属性 312 10.7.2 访问器 313 10.7.3 自动实现的属性 317 10.7.4 可访问性 318 10.7.5 虚、密封、重写和抽象访问器 319 10.8 事件 321 10.8.1 类似字段的事件 323 10.8.2 事件访问器 324 10.8.3 静态事件和实例事件 325 10.8.4 虚、密封、重写和抽象访问器 325 10.9 索引器 326 10.9.1 索引器重载 329 10.10 运算符 329 10.10.1 一元运算符 331 10.10.2 二元运算符 331 10.10.3 转换运算符 332 10.11 实例构造函数 334 10.11.1 构造函数初始值设定项 335 10.11.2 实例变量初始值设定项 336 10.11.3 构造函数执行 336 10.11.4 默认构造函数 338 10.11.5 私有构造函数 338 10.11.6 可选的实例构造函数形参 339 10.12 静态构造函数 339 10.13 析构函数 341 10.14 迭代器 343 10.14.1 枚举器接口 343 10.14.2 可枚举接口 343 10.14.3 产生类型 343 10.14.4 枚举器对象 343 10.14.4.1 MoveNext 方法 344 10.14.4.2 Current 属性 345 10.14.4.3 Dispose 方法 345 10.14.5 可枚举对象 345 10.14.5.1 GetEnumerator 方法 346 10.14.6 实现示例 346 11. 结构 353 11.1 结构声明 353 11.1.1 结构修饰符 353 11.1.2 分部修饰符 353 11.1.3 结构接口 354 11.1.4 结构体 354 11.2 结构成员 354 11.3 类和结构的区别 354 11.3.1 值语义 355 11.3.2 继承 355 11.3.3 赋值 356 11.3.4 默认值 356 11.3.5 装箱和拆箱 356 11.3.6 this 的含义 358 11.3.7 字段初始值设定项 358 11.3.8 构造函数 358 11.3.9 析构函数 359 11.3.10 静态构造函数 359 11.4 结构示例 360 11.4.1 数据库整数类型 360 11.4.2 数据库布尔类型 361 12. 数组 365 12.1 数组类型 365 12.1.1 System.Array 类型 366 12.1.2 数组和泛型 IList 接口 366 12.2 数组创建 366 12.3 数组元素访问 367 12.4 数组成员 367 12.5 数组协变 367 12.6 数组初始值设定项 367 13. 接口 369 13.1 接口声明 369 13.1.1 接口修饰符 369 13.1.2 分部修饰符 369 13.1.3 Variant 类型形参列表 370 13.1.3.1 变化安全性 370 13.1.3.2 变化转换 371 13.1.4 基接口 371 13.1.5 接口体 372 13.2 接口成员 372 13.2.1 接口方法 373 13.2.2 接口属性 373 13.2.3 接口事件 374 13.2.4 接口索引器 374 13.2.5 接口成员访问 374 13.3 完全限定接口成员名 376 13.4 接口实现 376 13.4.1 显式接口成员实现 377 13.4.2 所实现接口的唯一性 379 13.4.3 泛型方法实现 380 13.4.4 接口映射 381 13.4.5 接口实现继承 383 13.4.6 接口重新实现 385 13.4.7 抽象类和接口 386 14. 枚举 387 14.1 枚举声明 387 14.2 枚举修饰符 387 14.3 枚举成员 388 14.4 System.Enum 类型 390 14.5 枚举值和运算 390 15. 委托 391 15.1 委托声明 391 15.2 委托兼容性 393 15.3 委托实例化 393 15.4 委托调用 394 16. 异常 397 16.1 导致异常的原因 397 16.2 System.Exception 类 397 16.3 异常的处理方式 397 16.4 公共异常类 398 17. 特性 399 17.1 特性类 399 17.1.1 特性用法 399 17.1.2 定位和命名参数 400 17.1.3 特性参数类型 401 17.2 特性说明 401 17.3 特性实例 406 17.3.1 特性的编译 406 17.3.2 特性实例的运行时检索 406 17.4 保留特性 407 17.4.1 AttributeUsage 特性 407 17.4.2 Conditional 特性 408 17.4.2.1 条件方法 408 17.4.2.2 条件特性类 410 17.4.3 Obsolete 特性 411 17.5 互操作的特性 412 17.5.1 与 COM 和 Win32 组件的互操作 412 17.5.2 与其他 .NET 语言的互操作 412 17.5.2.1 IndexerName 特性 412 18. 不安全代码 413 18.1 不安全上下文 413 18.2 指针类型 415 18.3 固定和可移动变量 418 18.4 指针转换 418 18.4.1 指针数组 419 18.5 表达式中的指针 420 18.5.1 指针间接寻址 420 18.5.2 指针成员访问 421 18.5.3 指针元素访问 422 18.5.4 address-of 运算符 422 18.5.5 指针递增和递减 423 18.5.6 指针算术运算 423 18.5.7 指针比较 424 18.5.8 sizeof 运算符 425 18.6 fixed 语句 425 18.7 固定大小缓冲区 429 18.7.1 固定大小缓冲区的声明 429 18.7.2 表达式中的固定大小缓冲区 430 18.7.3 明确赋值检查 431 18.8 堆栈分配 431 18.9 动态内存分配 432 A. 文档注释 435 A.1 简介 435 A.2 建议的标记 436 A.2.1 437 A.2.2

	437
A.2.3 	437
A.2.4 	438
A.2.5 	438
A.2.6 	439
A.2.7 	440
A.2.8 	440
A.2.9 	441
A.2.10 	441
A.2.11 	442
A.2.12 	442
A.2.13 	442
A.2.14 	443
A.2.15

443 A.2.16 444 A.2.17 444 A.2.18 444 A.3 处理文档文件 445 A.3.1 ID 字符串格式 445 A.3.2 ID 字符串示例 446 A.4 示例 449 A.4.1 C# 源代码 449 A.4.2 生成 XML 452 B. 语法 455 B.1 词法文法 455 B.1.1 行结束符 455 B.1.2 注释 455 B.1.3 空白 456 B.1.4 标记 456 B.1.5 Unicode 字符转义序列 456 B.1.6 标识符 456 B.1.7 关键字 458 B.1.8 文本 458 B.1.9 运算符和标点符号 460 B.1.10 预处理指令 460 B.2 句法文法 463 B.2.1 基本概念 463 B.2.2 类型 463 B.2.3 变量 464 B.2.4 表达式 464 B.2.5 语句 471 B.2.6 命名空间 475 B.2.7 类 475 B.2.8 结构 483 B.2.9 数组 483 B.2.10 接口 484 B.2.11 枚举 485 B.2.12 委托 486 B.2.13 特性 486 B.3 不安全代码的语法扩展 487 C. 参考资料 491

这个是C#语言规范2.0,3.0,4.0的合集，是关于 C# 语法的权威资料。它们包含该语言各个方面的详细信息，包括 Visual C# 产品文档未涉及的许多语法点。 4.0目录 1. 简介 1 1.1 Hello world 1 1.2 程序结构 2 1.3 类型和变量 3 1.4 表达式 6 1.5 语句 8 1.6 类和对象 12 1.6.1 成员 12 1.6.2 可访问性 13 1.6.3 类型参数 13 1.6.4 基类 14 1.6.5 字段 14 1.6.6 方法 15 1.6.6.1 参数 15 1.6.6.2 方法体和局部变量 17 1.6.6.3 静态方法和实例方法 17 1.6.6.4 虚方法、重写方法和抽象方法 18 1.6.6.5 方法重载 20 1.6.7 其他函数成员 21 1.6.7.1 构造函数 22 1.6.7.2 属性 23 1.6.7.3 索引器 23 1.6.7.4 事件 23 1.6.7.5 运算符 24 1.6.7.6 析构函数 25 1.7 结构 25 1.8 数组 26 1.9 接口 27 1.10 枚举 28 1.11 委托 29 1.12 特性 30 2. 词法结构 33 2.1 程序 33 2.2 文法 33 2.2.1 文法表示法 33 2.2.2 词法文法 34 2.2.3 句法文法 34 2.3 词法分析 34 2.3.1 行结束符 35 2.3.2 注释 35 2.3.3 空白 36 2.4 标记 37 2.4.1 Unicode 字符转义序列 37 2.4.2 标识符 38 2.4.3 关键字 39 2.4.4 文本 41 2.4.4.1 布尔值 41 2.4.4.2 整数 41 2.4.4.3 实数 42 2.4.4.4 字符 43 2.4.4.5 字符串 44 2.4.4.6 null 文本 46 2.4.5 运算符和标点符号 46 2.5 预处理指令 46 2.5.1 条件编译符号 47 2.5.2 预处理表达式 48 2.5.3 声明指令 49 2.5.4 条件编译指令 49 2.5.5 诊断指令 52 2.5.6 区域指令 52 2.5.7 行指令 53 2.5.8 Pragma 指令 53 2.5.8.1 Pragma warning 54 3. 基本概念 55 3.1 应用程序启动 55 3.2 应用程序终止 56 3.3 声明 56 3.4 成员 58 3.4.1 命名空间成员 58 3.4.2 结构成员 59 3.4.3 枚举成员 59 3.4.4 类成员 59 3.4.5 接口成员 59 3.4.6 数组成员 60 3.4.7 委托成员 60 3.5 成员访问 60 3.5.1 已声明可访问性 60 3.5.2 可访问域 61 3.5.3 实例成员的受保护访问 63 3.5.4 可访问性约束 64 3.6 签名和重载 65 3.7 范围 66 3.7.1 名称隐藏 68 3.7.1.1 通过嵌套隐藏 68 3.7.1.2 通过继承隐藏 69 3.8 命名空间和类型名称 70 3.8.1 完全限定名 72 3.9 自动内存管理 73 3.10 执行顺序 75 4. 类型 77 4.1 值类型 77 4.1.1 System.ValueType 类型 78 4.1.2 默认构造函数 78 4.1.3 结构类型 79 4.1.4 简单类型 79 4.1.5 整型 80 4.1.6 浮点型 81 4.1.7 decimal 类型 82 4.1.8 bool 类型 82 4.1.9 枚举类型 82 4.1.10 可以为 null 的类型 83 4.2 引用类型 83 4.2.1 类类型 84 4.2.2 对象类型 84 4.2.3 dynamic 类型 84 4.2.4 string 类型 85 4.2.5 接口类型 85 4.2.6 数组类型 85 4.2.7 委托类型 85 4.3 装箱和拆箱 85 4.3.1 装箱转换 85 4.3.2 拆箱转换 87 4.4 构造类型 87 4.4.1 类型实参 88 4.4.2 开放和封闭类型 88 4.4.3 绑定和未绑定类型 89 4.4.4 满足约束 89 4.5 类型形参 90 4.6 表达式树类型 91 4.7 dynamic 类型 91 5. 变量 93 5.1 变量类别 93 5.1.1 静态变量 93 5.1.2 实例变量 93 5.1.2.1 类中的实例变量 93 5.1.2.2 结构中的实例变量 94 5.1.3 数组元素 94 5.1.4 值参数 94 5.1.5 引用形参 94 5.1.6 输出形参 94 5.1.7 局部变量 95 5.2 默认值 95 5.3 明确赋值 96 5.3.1 初始已赋值变量 96 5.3.2 初始未赋值变量 97 5.3.3 确定明确赋值的细则 97 5.3.3.1 一般语句规则 98 5.3.3.2 块语句、checked 和 unchecked 语句 98 5.3.3.3 表达式语句 98 5.3.3.4 声明语句 98 5.3.3.5 if 语句 98 5.3.3.6 switch 语句 99 5.3.3.7 while 语句 99 5.3.3.8 do 语句 99 5.3.3.9 for 语句 99 5.3.3.10 break、continue 和 goto 语句 100 5.3.3.11 throw 语句 100 5.3.3.12 return 语句 100 5.3.3.13 try-catch 语句 100 5.3.3.14 try-finally 语句 100 5.3.3.15 try-catch-finally 语句 101 5.3.3.16 foreach 语句 102 5.3.3.17 using 语句 102 5.3.3.18 lock 语句 102 5.3.3.19 yield 语句 102 5.3.3.20 简单表达式的一般规则 102 5.3.3.21 带有嵌入表达式的表达式的一般规则 103 5.3.3.22 调用表达式和对象创建表达式 103 5.3.3.23 简单赋值表达式 103 5.3.3.24 && 表达式 104 5.3.3.25 || 表达式 104 5.3.3.26 ! 表达式 105 5.3.3.27 ?? 表达式 106 5.3.3.28 ?: 表达式 106 5.3.3.29 匿名函数 106 5.4 变量引用 107 5.5 变量引用的原子性 107 6. 转换 109 6.1 隐式转换 109 6.1.1 标识转换 110 6.1.2 隐式数值转换 110 6.1.3 隐式枚举转换 110 6.1.4 可以为 null 的隐式转换 110 6.1.5 null 文本转换 111 6.1.6 隐式引用转换 111 6.1.7 装箱转换 111 6.1.8 隐式动态转换 112 6.1.9 隐式常量表达式转换 112 6.1.10 涉及类型形参的隐式转换 112 6.1.11 用户定义的隐式转换 113 6.1.12 匿名函数转换和方法组转换 113 6.2 显式转换 113 6.2.1 显式数值转换 114 6.2.2 显式枚举转换 115 6.2.3 可以为 null 的显式转换 115 6.2.4 显式引用转换 116 6.2.5 拆箱转换 117 6.2.6 显式动态转换 117 6.2.7 涉及类型形参的显式转换 118 6.2.8 用户定义的显式转换 118 6.3 标准转换 119 6.3.1 标准隐式转换 119 6.3.2 标准显式转换 119 6.4 用户定义的转换 119 6.4.1 允许的用户定义转换 119 6.4.2 提升转换运算符 119 6.4.3 用户定义转换的计算 120 6.4.4 用户定义的隐式转换 120 6.4.5 用户定义的显式转换 121 6.5 匿名函数转换 122 6.5.1 匿名函数转换为委托类型的计算 123 6.5.2 匿名函数转换为表达式树类型的计算 124 6.5.3 实现示例 124 6.6 方法组转换 126 7. 表达式 129 7.1 表达式的分类 129 7.1.1 表达式的值 130 7.2 静态和动态绑定 130 7.2.1 绑定时间 131 7.2.2 动态绑定 131 7.2.3 构成表达式的类型 131 7.3 运算符 131 7.3.1 运算符的优先级和顺序关联性 132 7.3.2 运算符重载 133 7.3.3 一元运算符重载决策 134 7.3.4 二元运算符重载决策 134 7.3.5 候选用户定义运算符 134 7.3.6 数值提升 135 7.3.6.1 一元数值提升 135 7.3.6.2 二元数值提升 135 7.3.7 提升运算符 136 7.4 成员查找 137 7.4.1 基类型 138 7.5 函数成员 138 7.5.1 实参列表 140 7.5.1.1 对应形参 141 7.5.1.2 实参列表的运行时计算 142 7.5.2 类型推断 143 7.5.2.1 第一阶段 144 7.5.2.2 第二阶段 144 7.5.2.3 输入类型 144 7.5.2.4 输出类型 145 7.5.2.5 依赖 145 7.5.2.6 输出类型推断 145 7.5.2.7 参数类型显式推断 145 7.5.2.8 精确推断 145 7.5.2.9 下限推断 145 7.5.2.10 上限推断 146 7.5.2.11 固定 147 7.5.2.12 推断返回类型 147 7.5.2.13 方法组转换的类型推断 148 7.5.2.14 查找一组表达式的最通用类型 148 7.5.3 重载决策 149 7.5.3.1 适用函数成员 149 7.5.3.2 更好的函数成员 150 7.5.3.3 表达式的更佳转换 151 7.5.3.4 类型的更佳转换 151 7.5.3.5 更佳转换目标 151 7.5.3.6 泛型类中的重载 151 7.5.4 动态重载决策的编译时检查 152 7.5.5 函数成员调用 152 7.5.5.1 已装箱实例上的调用 153 7.6 基本表达式 154 7.6.1 文本 154 7.6.2 简单名称 154 7.6.2.1 块中的固定含义 155 7.6.3 带括号的表达式 156 7.6.4 成员访问 157 7.6.4.1 相同的简单名称和类型名称 158 7.6.4.2 语法多义性 159 7.6.5 调用表达式 159 7.6.5.1 方法调用 160 7.6.5.2 扩展方法调用 161 7.6.5.3 委托调用 163 7.6.6 元素访问 164 7.6.6.1 数组访问 164 7.6.6.2 索引器访问 165 7.6.7 this 访问 165 7.6.8 基访问 166 7.6.9 后缀增量和后缀减量运算符 166 7.6.10 new 运算符 167 7.6.10.1 对象创建表达式 168 7.6.10.2 对象初始值设定项 169 7.6.10.3 集合初始值设定项 171 7.6.10.4 数组创建表达式 172 7.6.10.5 委托创建表达式 174 7.6.10.6 匿名对象创建表达式 175 7.6.11 typeof 运算符 177 7.6.12 checked 和 unchecked 运算符 178 7.6.13 默认值表达式 180 7.6.14 匿名方法表达式 181 7.7 一元运算符 181 7.7.1 一元加运算符 181 7.7.2 一元减运算符 181 7.7.3 逻辑否定运算符 182 7.7.4 按位求补运算符 182 7.7.5 前缀增量和减量运算符 182 7.7.6 强制转换表达式 183 7.8 算术运算符 184 7.8.1 乘法运算符 184 7.8.2 除法运算符 185 7.8.3 余数运算符 186 7.8.4 加法运算符 187 7.8.5 减法运算符 189 7.9 移位运算符 190 7.10 关系和类型测试运算符 192 7.10.1 整数比较运算符 192 7.10.2 浮点比较运算符 193 7.10.3 小数比较运算符 194 7.10.4 布尔相等运算符 194 7.10.5 枚举比较运算符 194 7.10.6 引用类型相等运算符 194 7.10.7 字符串相等运算符 196 7.10.8 委托相等运算符 196 7.10.9 相等运算符和 null 197 7.10.10 is 运算符 197 7.10.11 as 运算符 197 7.11 逻辑运算符 198 7.11.1 整数逻辑运算符 199 7.11.2 枚举逻辑运算符 199 7.11.3 布尔逻辑运算符 199 7.11.4 可以为 null 的布尔逻辑运算符 199 7.12 条件逻辑运算符 200 7.12.1 布尔条件逻辑运算符 200 7.12.2 用户定义的条件逻辑运算符 201 7.13 空合并运算符 201 7.14 条件运算符 202 7.15 匿名函数表达式 203 7.15.1 匿名函数签名 204 7.15.2 匿名函数体 205 7.15.3 重载决策 205 7.15.4 匿名函数与动态绑定 206 7.15.5 外层变量 206 7.15.5.1 捕获的外层变量 206 7.15.5.2 局部变量实例化 207 7.15.6 匿名函数表达式计算 209 7.16 查询表达式 209 7.16.1 查询表达式的多义性 210 7.16.2 查询表达式转换 210 7.16.2.1 带继续符的 select 和 groupby 子句 211 7.16.2.2 显式范围变量类型 211 7.16.2.3 退化查询表达式 212 7.16.2.4 from、let、where、join 和 orderby 子句 212 7.16.2.5 select 子句 216 7.16.2.6 Groupby 子句 216 7.16.2.7 透明标识符 216 7.16.3 查询表达式模式 218 7.17 赋值运算符 219 7.17.1 简单赋值 219 7.17.2 复合赋值 221 7.17.3 事件赋值 222 7.18 表达式 222 7.19 常量表达式 223 7.20 布尔表达式 224 8. 语句 225 8.1 结束点和可到达性 225 8.2 块 227 8.2.1 语句列表 227 8.3 空语句 228 8.4 标记语句 228 8.5 声明语句 229 8.5.1 局部变量声明 229 8.5.2 局部常量声明 230 8.6 表达式语句 231 8.7 选择语句 231 8.7.1 if 语句 231 8.7.2 switch 语句 232 8.8 迭代语句 236 8.8.1 while 语句 236 8.8.2 do 语句 236 8.8.3 for 语句 237 8.8.4 foreach 语句 238 8.9 跳转语句 240 8.9.1 break 语句 241 8.9.2 continue 语句 242 8.9.3 goto 语句 242 8.9.4 return 语句 243 8.9.5 throw 语句 244 8.10 try 语句 245 8.11 checked 语句和 unchecked 语句 247 8.12 lock 语句 248 8.13 using 语句 248 8.14 yield 语句 250 9. 命名空间 253 9.1 编译单元 253 9.2 命名空间声明 253 9.3 Extern 别名 254 9.4 using 指令 255 9.4.1 using 别名指令 256 9.4.2 Using 命名空间指令 258 9.5 命名空间成员 260 9.6 类型声明 260 9.7 命名空间别名限定符 261 9.7.1 别名的唯一性 262 10. 类 263 10.1 类声明 263 10.1.1 类修饰符 263 10.1.1.1 抽象类 264 10.1.1.2 密封类 264 10.1.1.3 静态类 264 10.1.2 分部修饰符 265 10.1.3 类型形参 265 10.1.4 类基本规范 266 10.1.4.1 基类 266 10.1.4.2 接口实现 267 10.1.5 类型形参约束 268 10.1.6 类体 272 10.2 分部类型 272 10.2.1 特性 272 10.2.2 修饰符 273 10.2.3 类型形参和约束 273 10.2.4 基类 273 10.2.5 基接口 274 10.2.6 成员 274 10.2.7 分部方法 275 10.2.8 名称绑定 277 10.3 类成员 277 10.3.1 实例类型 278 10.3.2 构造类型的成员 279 10.3.3 继承 280 10.3.4 new 修饰符 280 10.3.5 访问修饰符 281 10.3.6 构成类型 281 10.3.7 静态成员和实例成员 281 10.3.8 嵌套类型 282 10.3.8.1 完全限定名 282 10.3.8.2 已声明可访问性 282 10.3.8.3 隐藏 283 10.3.8.4 this 访问 283 10.3.8.5 对包含类型的私有和受保护成员的访问 284 10.3.8.6 泛型类中的嵌套类型 285 10.3.9 保留成员名称 286 10.3.9.1 为属性保留的成员名称 286 10.3.9.2 为事件保留的成员名称 287 10.3.9.3 为索引器保留的成员名称 287 10.3.9.4 为析构函数保留的成员名称 287 10.4 常量 287 10.5 字段 289 10.5.1 静态字段和实例字段 290 10.5.2 只读字段 291 10.5.2.1 对常量使用静态只读字段 291 10.5.2.2 常量和静态只读字段的版本控制 291 10.5.3 可变字段 292 10.5.4 字段初始化 293 10.5.5 变量初始值设定项 293 10.5.5.1 静态字段初始化 294 10.5.5.2 实例字段初始化 295 10.6 方法 296 10.6.1 方法形参 298 10.6.1.1 值参数 299 10.6.1.2 引用形参 299 10.6.1.3 输出形参 300 10.6.1.4 形参数组 301 10.6.2 静态方法和实例方法 303 10.6.3 虚方法 304 10.6.4 重写方法 305 10.6.5 密封方法 307 10.6.6 抽象方法 308 10.6.7 外部方法 309 10.6.8 分部方法 310 10.6.9 扩展方法 310 10.6.10 方法体 311 10.6.11 方法重载 311 10.7 属性 311 10.7.1 静态属性和实例属性 312 10.7.2 访问器 313 10.7.3 自动实现的属性 317 10.7.4 可访问性 318 10.7.5 虚、密封、重写和抽象访问器 319 10.8 事件 321 10.8.1 类似字段的事件 323 10.8.2 事件访问器 324 10.8.3 静态事件和实例事件 325 10.8.4 虚、密封、重写和抽象访问器 325 10.9 索引器 326 10.9.1 索引器重载 329 10.10 运算符 329 10.10.1 一元运算符 331 10.10.2 二元运算符 331 10.10.3 转换运算符 332 10.11 实例构造函数 334 10.11.1 构造函数初始值设定项 335 10.11.2 实例变量初始值设定项 336 10.11.3 构造函数执行 336 10.11.4 默认构造函数 338 10.11.5 私有构造函数 338 10.11.6 可选的实例构造函数形参 339 10.12 静态构造函数 339 10.13 析构函数 341 10.14 迭代器 343 10.14.1 枚举器接口 343 10.14.2 可枚举接口 343 10.14.3 产生类型 343 10.14.4 枚举器对象 343 10.14.4.1 MoveNext 方法 344 10.14.4.2 Current 属性 345 10.14.4.3 Dispose 方法 345 10.14.5 可枚举对象 345 10.14.5.1 GetEnumerator 方法 346 10.14.6 实现示例 346 11. 结构 353 11.1 结构声明 353 11.1.1 结构修饰符 353 11.1.2 分部修饰符 353 11.1.3 结构接口 354 11.1.4 结构体 354 11.2 结构成员 354 11.3 类和结构的区别 354 11.3.1 值语义 355 11.3.2 继承 355 11.3.3 赋值 356 11.3.4 默认值 356 11.3.5 装箱和拆箱 356 11.3.6 this 的含义 358 11.3.7 字段初始值设定项 358 11.3.8 构造函数 358 11.3.9 析构函数 359 11.3.10 静态构造函数 359 11.4 结构示例 360 11.4.1 数据库整数类型 360 11.4.2 数据库布尔类型 361 12. 数组 365 12.1 数组类型 365 12.1.1 System.Array 类型 366 12.1.2 数组和泛型 IList 接口 366 12.2 数组创建 366 12.3 数组元素访问 367 12.4 数组成员 367 12.5 数组协变 367 12.6 数组初始值设定项 367 13. 接口 369 13.1 接口声明 369 13.1.1 接口修饰符 369 13.1.2 分部修饰符 369 13.1.3 Variant 类型形参列表 370 13.1.3.1 变化安全性 370 13.1.3.2 变化转换 371 13.1.4 基接口 371 13.1.5 接口体 372 13.2 接口成员 372 13.2.1 接口方法 373 13.2.2 接口属性 373 13.2.3 接口事件 374 13.2.4 接口索引器 374 13.2.5 接口成员访问 374 13.3 完全限定接口成员名 376 13.4 接口实现 376 13.4.1 显式接口成员实现 377 13.4.2 所实现接口的唯一性 379 13.4.3 泛型方法实现 380 13.4.4 接口映射 381 13.4.5 接口实现继承 383 13.4.6 接口重新实现 385 13.4.7 抽象类和接口 386 14. 枚举 387 14.1 枚举声明 387 14.2 枚举修饰符 387 14.3 枚举成员 388 14.4 System.Enum 类型 390 14.5 枚举值和运算 390 15. 委托 391 15.1 委托声明 391 15.2 委托兼容性 393 15.3 委托实例化 393 15.4 委托调用 394 16. 异常 397 16.1 导致异常的原因 397 16.2 System.Exception 类 397 16.3 异常的处理方式 397 16.4 公共异常类 398 17. 特性 399 17.1 特性类 399 17.1.1 特性用法 399 17.1.2 定位和命名参数 400 17.1.3 特性参数类型 401 17.2 特性说明 401 17.3 特性实例 406 17.3.1 特性的编译 406 17.3.2 特性实例的运行时检索 406 17.4 保留特性 407 17.4.1 AttributeUsage 特性 407 17.4.2 Conditional 特性 408 17.4.2.1 条件方法 408 17.4.2.2 条件特性类 410 17.4.3 Obsolete 特性 411 17.5 互操作的特性 412 17.5.1 与 COM 和 Win32 组件的互操作 412 17.5.2 与其他 .NET 语言的互操作 412 17.5.2.1 IndexerName 特性 412 18. 不安全代码 413 18.1 不安全上下文 413 18.2 指针类型 415 18.3 固定和可移动变量 418 18.4 指针转换 418 18.4.1 指针数组 419 18.5 表达式中的指针 420 18.5.1 指针间接寻址 420 18.5.2 指针成员访问 421 18.5.3 指针元素访问 422 18.5.4 address-of 运算符 422 18.5.5 指针递增和递减 423 18.5.6 指针算术运算 423 18.5.7 指针比较 424 18.5.8 sizeof 运算符 425 18.6 fixed 语句 425 18.7 固定大小缓冲区 429 18.7.1 固定大小缓冲区的声明 429 18.7.2 表达式中的固定大小缓冲区 430 18.7.3 明确赋值检查 431 18.8 堆栈分配 431 18.9 动态内存分配 432 A. 文档注释 435 A.1 简介 435 A.2 建议的标记 436 A.2.1 437 A.2.2

 437
A.2.3  437
A.2.4  438
A.2.5  438
A.2.6  439
A.2.7  440
A.2.8  440
A.2.9  441
A.2.10  441
A.2.11  442
A.2.12  442
A.2.13  442
A.2.14  443
A.2.15

目录 1. 简介 ... 1 2. 词法结构 ... 31 2.1 程序 ... 31 2.2 文法 ... 31 2.2.1 文法表示法 31 2.2.2 词法文法... 32 2.2.3 句法文法... 32 2.3 词法分析 .. 32 2.3.1 行结束符... 33 2.3.2 注释... 33 2.3.3 空白... 34 2.4 标记 ... 34 iv C#语言规范 2.4.1 Unicode 字符转义序列 ... 35 2.4.2 标识符. 35 2.4.3 关键字. 37 2.4.4 文本... 37 2.4.4.1 布尔值 .. 37 2.4.4.2 整数 ... 38 2.4.4.3 实数 ... 39 2.4.4.4 字符 ... 39 2.4.4.5 字符串 .. 40 2.4.4.6 null 文本 ... 42 2.4.5 运算符和标点符号... 42 2.5 预处理指令 42 2.5.1 条件编译符号... 43 2.5.2 预处理表达式... 43 2.5.3 声明指令... 44 2.5.4 条件编译指令... 45 2.5.5 诊断指令... 47 2.5.6 区域指令... 47 2.5.7 行指令. 48 2.5.8 Pragma 指令 ... 48 2.5.8.1 Pragma warning .. 49 3. 基本概念 ... 50 3.1 应用程序启动 ... 50 3.2 应用程序终止 ... 50 3.3 声明 ... 51 3.4 成员 ... 53 3.4.1 命名空间成员... 53 3.4.2 结构成员... 53 3.4.3 枚举成员... 53 3.4.4 类成员. 53 3.4.5 接口成员... 54 3.4.6 数组成员... 54 3.4.7 委托成员... 54 3.5 成员访问 .. 54 3.5.1 已声明可访问性. 54 3.5.2 可访问域... 55 3.5.3 实例成员的受保护访问 57 3.5.4 可访问性约束... 58 3.6 签名和重载 59 3.7 范围 ... 60 3.7.1 名称隐藏... 62 3.7.1.1 通过嵌套隐藏 ... 62 3.7.1.2 通过继承隐藏 ... 63 3.8 命名空间和类型名称 64 目录 3.8.1 完全限定名 66 3.9 自动内存管理 ... 66 3.10 执行顺序 69 4. 类型 ... 71 4.1 值类型 . 71 4.1.1 System.ValueType 类型 ... 72 4.1.2 默认构造函数... 72 4.1.3 结构类型... 73 4.1.4 简单类型... 73 4.1.5 整型... 74 4.1.6 浮点型. 75 4.1.7 decimal 类型 ... 76 4.1.8 bool 类型... 76 4.1.9 枚举类型... 76 4.1.10 可以为 null 的类型.. 76 4.2 引用类型 .. 77 4.2.1 类类型. 78 4.2.2 对象类型... 78 4.2.3 string 类型.. 78 4.2.4 接口类型... 78 4.2.5 数组类型... 78 4.2.6 委托类型... 78 4.3 装箱和拆箱 79 4.3.1 装箱转换... 79 4.3.2 拆箱转换... 80 4.4 构造类型 .. 81 4.4.1 类型实参... 81 4.4.2 开放和封闭类型. 82 4.4.3 绑定和未绑定类型... 82 4.4.4 满足约束... 82 4.5 类型形参 .. 83 4.6 表达式目录树类型 .. 84 5. 变量 ... 85 5.1 变量类别 .. 85 5.1.1 静态变量... 85 5.1.2 实例变量... 85 5.1.2.1 类中的实例变量 .. 85 5.1.2.2 结构中的实例变量 ... 85 5.1.3 数组元素... 86 5.1.4 值参数. 86 5.1.5 引用形参... 86 5.1.6 输出形参... 86 5.1.7 局部变量... 86 5.2 默认值 . 87 vi C#语言规范 5.3 明确赋值 .. 87 5.3.1 初始已赋值变量. 88 5.3.2 初始未赋值变量. 88 5.3.3 确定明确赋值的细则 88 5.3.3.1 一般语句规则 ... 89 5.3.3.2 块语句、checked 和 unchecked 语句 . 89 5.3.3.3 表达式语句 . 89 5.3.3.4 声明语句 ... 90 5.3.3.5 if 语句.. 90 5.3.3.6 switch 语句. 90 5.3.3.7 while 语句 ... 90 5.3.3.8 do 语句 . 90 5.3.3.9 for 语句 91 5.3.3.10 break、continue 和 goto 语句 91 5.3.3.11 throw 语句 91 5.3.3.12 return 语句 91 5.3.3.13 try-catch 语句 ... 92 5.3.3.14 try-finally 语句 ... 92 5.3.3.15 try-catch-finally 语句 92 5.3.3.16 foreach 语句 93 5.3.3.17 using 语句 . 93 5.3.3.18 lock 语句 ... 93 5.3.3.19 yield 语句 .. 94 5.3.3.20 简单表达式的一般规则 94 5.3.3.21 带有嵌入表达式的表达式的一般规则 . 94 5.3.3.22 调用表达式和对象创建表达式 ... 94 5.3.3.23 简单赋值表达式 95 5.3.3.24 && 表达式 95 5.3.3.25 || 表达式 ... 96 5.3.3.26 ! 表达式... 96 5.3.3.27 ?? 表达式 .. 97 5.3.3.28 ?: 表达式 ... 97 5.3.3.29 匿名函数 ... 97 5.4 变量引用 .. 98 5.5 变量引用的原子性 .. 98 6. 转换 ... 99 6.1 隐式转换 .. 99 6.1.1 标识转换... 99 6.1.2 隐式数值转换... 99 6.1.3 隐式枚举转换. 100 6.1.4 可以为 null 的隐式转换... 100 6.1.5 null 文本转换 .. 100 6.1.6 隐式引用转换. 100 6.1.7 装箱转换.. 101 目录 6.1.8 隐式常量表达式转换... 101 6.1.9 涉及类型形参的隐式转换. 101 6.1.10 用户定义的隐式转换 102 6.1.11 匿名函数转换和方法组转换 ... 102 6.2 显式转换 102 6.2.1 显式数值转换. 102 6.2.2 显式枚举转换. 104 6.2.3 可以为 null 的显式转换. 104 6.2.4 显式引用转换. 105 6.2.5 拆箱转换.. 105 6.2.6 涉及类型形参的显式转换. 105 6.2.7 用户定义的显式转换... 106 6.3 标准转换 106 6.3.1 标准隐式转换. 106 6.3.2 标准显式转换. 107 6.4 用户定义的转换 ... 107 6.4.1 允许的用户定义转换... 107 6.4.2 提升转换运算符... 107 6.4.3 用户定义转换的计算... 107 6.4.4 用户定义的隐式转换... 108 6.4.5 用户定义的显式转换... 109 6.5 匿名函数转换 . 110 6.5.1 匿名函数转换为委托类型的计算 111 6.5.2 匿名函数转换为表达式目录树类型的计算 111 6.5.3 实现示例.. 111 6.6 方法组转换 ... 114 7. 表达式 ... 116 7.1 表达式的分类 . 116 7.1.1 表达式的值... 117 7.2 通过调用索引器的 get-accessor 来获取索引器访问表达式的值。... 117 7.3 运算符 ... 117 7.3.1 运算符的优先级和顺序关联性 ... 117 7.3.2 运算符重载... 118 7.3.3 一元运算符重载决策... 119 7.3.4 二元运算符重载决策... 119 7.3.5 候选用户定义运算符... 120 7.3.6 数值提升.. 120 7.3.6.1 一元数值提升 ... 120 7.3.6.2 二元数值提升 ... 121 7.3.7 提升运算符... 121 7.4 成员查找 122 7.4.1 基类型... 123 7.5 函数成员 123 7.5.1 实参列表.. 125 viii C#语言规范 7.5.2 类型推断.. 127 7.5.2.1 第一阶段 ... 128 7.5.2.2 第二阶段 ... 128 7.5.2.3 输入类型 ... 129 7.5.2.4 输出类型 ... 129 7.5.2.5 依赖 ... 129 7.5.2.6 输出类型推断 ... 129 7.5.2.7 参数类型显式推断 ... 129 7.5.2.8 精确推断 ... 129 7.5.2.9 下限推断 ... 129 7.5.2.10 固定 .. 130 7.5.2.11 推断返回类型 .. 130 7.5.2.12 方法组转换的类型推断 131 7.5.2.13 查找一组表达式的最通用类型 .. 131 7.5.3 重载决策.. 131 7.5.3.1 适用函数成员 ... 132 7.5.3.2 更好的函数成员 132 7.5.3.3 表达式的更佳转换 ... 133 7.5.3.4 类型的更佳转换 134 7.5.3.5 泛型类中的重载 134 7.5.4 函数成员调用. 135 7.5.4.1 已装箱实例上的调用 ... 136 7.6 基本表达式 ... 136 7.6.1 文本. 137 7.6.2 简单名称.. 137 7.6.2.1 块中的固定含义 138 7.6.3 带括号的表达式... 139 7.6.4 成员访问.. 139 7.6.4.1 相同的简单名称和类型名称 . 141 7.6.4.2 语法多义性 . 141 7.6.5 调用表达式... 142 7.6.5.1 方法调用 ... 142 7.6.5.2 扩展方法调用 ... 143 7.6.5.3 委托调用 ... 146 7.6.6 元素访问.. 146 7.6.6.1 数组访问 ... 146 7.6.6.2 索引器访问 . 147 7.6.7 this 访问 147 7.6.8 base 访问 148 7.6.9 后缀增量和后缀减量运算符.. 148 7.6.10 new 运算符 ... 149 7.6.10.1 对象创建表达式 ... 149 7.6.10.2 对象初始值设定项 . 150 7.6.10.3 集合初始值设定项 . 152 7.6.10.4 数组创建表达式 ... 153 目录 7.6.10.5 委托创建表达式 ... 155 7.6.10.6 匿名对象创建表达式 .. 156 7.6.11 typeof 运算符 157 7.6.12 checked 和 unchecked 运算符 159 7.6.13 默认值表达式. 161 7.6.14 匿名方法表达式... 161 7.7 一元运算符 ... 162 7.7.1 一元加运算符. 162 7.7.2 一元减运算符. 162 7.7.3 逻辑否定运算符... 163 7.7.4 按位求补运算符... 163 7.7.5 前缀增量和减量运算符... 163 7.7.6 强制转换表达式... 164 7.8 算术运算符 ... 164 7.8.1 乘法运算符... 165 7.8.2 除法运算符... 165 7.8.3 余数运算符... 166 7.8.4 加法运算符... 167 7.8.5 减法运算符... 169 7.9 移位运算符 ... 170 7.10 关系和类型测试运算符 ... 171 7.10.1 整数比较运算符... 172 7.10.2 浮点比较运算符... 173 7.10.3 小数比较运算符... 173 7.10.4 布尔相等运算符... 173 7.10.5 枚举比较运算符... 174 7.10.6 引用类型相等运算符 174 7.10.7 字符串相等运算符... 175 7.10.8 委托相等运算符... 176 7.10.9 相等运算符和 null.. 176 7.10.10 is 运算符 ... 176 7.10.11 as 运算符 ... 177 7.11 逻辑运算符 ... 178 7.11.1 整数逻辑运算符... 178 7.11.2 & 运算符 178 7.11.3 枚举逻辑运算符... 178 7.11.4 布尔逻辑运算符... 178 7.11.5 可以为 null 的布尔逻辑运算符 ... 179 7.12 条件逻辑运算符 .. 179 7.12.1 布尔条件逻辑运算符 180 7.12.2 用户定义的条件逻辑运算符 ... 180 7.13 空合并运算符 ... 180 7.14 条件运算符 ... 181 7.15 匿名函数表达式 .. 182 7.15.1 匿名函数签名. 183 x C#语言规范 7.15.2 匿名函数体... 183 7.15.3 重载决策 184 7.15.4 外层变量 185 7.15.4.1 捕获的外层变量 ... 185 7.15.4.2 局部变量实例化 ... 186 7.15.5 匿名函数表达式的计算 188 7.16 查询表达式 ... 188 7.16.1 查询表达式中的多义性 189 7.16.2 查询表达式转换... 189 7.16.2.1 带有延续部分的 Select 和 groupby 子句 ... 190 7.16.2.2 显式范围变量类型 . 190 7.16.2.3 简并查询表达式 ... 191 7.16.2.4 From、let、where、join 和 orderby 子句 191 7.16.2.5 Select 子句 194 7.16.2.6 Groupby 子句 ... 195 7.16.2.7 透明标识符 ... 195 7.16.3 查询表达式模式... 196 7.17 赋值运算符 ... 197 7.17.1 简单赋值 198 7.17.2 复合赋值 200 7.17.3 事件赋值 201 7.18 表达式 .. 201 7.19 常量表达式 ... 201 7.20 布尔表达式 ... 202 8. 语句 .. 204 8.1 结束点和可到达性 204 8.2 块 205 8.2.1 语句列表.. 206 8.3 空语句 ... 206 8.4 标记语句 207 8.5 声明语句 207 8.5.1 局部变量声明. 207 8.5.2 局部常量声明. 209 8.6 表达式语句 ... 209 8.7 选择语句 209 8.7.1 if 语句 210 8.7.2 switch 语句 ... 210 8.8 迭代语句 213 8.8.1 while 语句 . 213 8.8.2 do 语句... 214 8.8.3 for 语句 ... 214 8.8.4 foreach 语句... 215 8.9 跳转语句 218 8.9.1 break 语句 . 218 目录 8.9.2 continue 语句 ... 219 8.9.3 goto 语句.. 219 8.9.4 return 语句 220 8.9.5 throw 语句 221 8.10 try 语句 . 221 8.11 checked 语句和 unchecked 语句.. 224 8.12 lock 语句 224 8.13 using 语句... 225 8.14 yield 语句 ... 226 9. 命名空间 . 229 9.1 编译单元 229 9.2 命名空间声明 . 229 9.3 Extern 别名... 230 9.4 using 指令 231 9.4.1 using 别名指令 231 9.4.2 Using 命名空间指令 234 9.5 命名空间成员 . 235 9.6 类型声明 236 9.7 命名空间别名限定符 ... 236 9.7.1 别名的唯一性. 237 10. 类 ... 239 10.1 类声明 .. 239 10.1.1 类修饰符 239 10.1.1.1 抽象类 ... 239 10.1.1.2 密封类 ... 240 10.1.1.3 静态类 ... 240 10.1.2 分部修饰符... 241 10.1.3 类型形参 241 10.1.4 类基本规范... 241 10.1.4.1 基类 .. 242 10.1.4.2 接口实现 . 243 10.1.5 类型形参约束. 243 10.1.6 类体. 246 10.2 分部类型 247 10.2.1 属性. 247 10.2.2 修饰符... 247 10.2.3 类型形参和约束... 247 10.2.4 基类. 248 10.2.5 基接口... 248 10.2.6 成员. 249 10.2.7 分部方法 249 10.2.8 名称绑定 251 10.3 类成员 .. 252 10.3.1 实例类型 253 xii C#语言规范 10.3.2 构造类型的成员... 253 10.3.3 继承. 254 10.3.4 new 修饰符 ... 255 10.3.5 访问修饰符... 255 10.3.6 构成类型 255 10.3.7 静态成员和实例成员 255 10.3.8 嵌套类型 256 10.3.8.1 完全限定名 ... 256 10.3.8.2 已声明可访问性 ... 257 10.3.8.3 隐藏 .. 257 10.3.8.4 this 访问 .. 258 10.3.8.5 对包含类型的私有和受保护成员的访问 .. 259 10.3.8.6 泛型类中的嵌套类型 .. 260 10.3.9 保留成员名称. 260 10.3.9.1 为属性保留的成员名称 261 10.3.9.2 为事件保留的成员名称 261 10.3.9.3 为索引器保留的成员名称 ... 261 10.3.9.4 为析构函数保留的成员名称 ... 262 10.4 常量 . 262 10.5 字段 . 263 10.5.1 静态字段和实例字段 264 10.5.2 只读字段 265 10.5.2.1 对常量使用静态只读字段 ... 265 10.5.2.2 常量和静态只读字段的版本控制 266 10.5.3 可变字段 266 10.5.4 字段初始化... 267 10.5.5 变量初始值设定项... 268 10.5.5.1 静态字段初始化 ... 268 10.5.5.2 实例字段初始化 ... 270 10.6 方法 . 270 10.6.1 方法形参 272 10.6.1.1 值形参 ... 273 10.6.1.2 引用形参 . 273 10.6.1.3 输出形参 . 274 10.6.1.4 形参数组 . 274 10.6.2 静态方法和实例方法 277 10.6.3 虚方法... 277 10.6.4 重写方法 279 10.6.5 密封方法 281 10.6.6 抽象方法 281 10.6.7 外部方法 283 10.6.8 分部方法 283 10.6.9 扩展方法 283 10.6.10 方法体.. 284 10.6.11 方法重载... 285 目录 10.7 属性 . 285 10.7.1 静态属性和实例属性 286 10.7.2 访问器... 286 10.7.3 自动实现的属性... 291 10.7.4 可访问性 291 10.7.5 虚、密封、重写和抽象访问器 .. 292 10.8 事件 . 294 10.8.1 类似字段的事件... 296 10.8.2 事件访问器... 297 10.8.3 静态事件和实例事件 298 10.8.4 虚、密封、重写和抽象访问器 .. 298 10.9 索引器 .. 299 10.9.1 索引器重载... 302 10.10 运算符 302 10.10.1 一元运算符. 304 10.10.2 二元运算符. 304 10.10.3 转换运算符. 305 10.11 实例构造函数 ... 307 10.11.1 构造函数初始值设定项. 308 10.11.2 实例变量初始值设定项. 308 10.11.3 构造函数执行... 308 10.11.4 默认构造函数... 310 10.11.5 私有构造函数... 311 10.11.6 可选的实例构造函数形参.. 311 10.12 静态构造函数 ... 312 10.13 析构函数 ... 314 10.14 迭代器 315 10.14.1 枚举器接口. 315 10.14.2 可枚举接口. 315 10.14.3 产生类型... 316 10.14.4 枚举器对象. 316 10.14.4.1 MoveNext 方法 ... 316 10.14.4.2 Current 属性 ... 317 10.14.4.3 Dispose 方法 .. 317 10.14.5 可枚举对象. 318 10.14.5.1 GetEnumerator 方法 .. 318 10.14.6 实现示例... 318 11. 结构 325 11.1 结构声明 325 11.1.1 结构修饰符... 325 11.1.2 分部修饰符... 325 11.1.3 结构接口 325 11.1.4 结构体... 326 11.2 结构成员 326 xiv C#语言规范 11.3 类和结构的区别 .. 326 11.3.1 值语义... 326 11.3.2 继承. 327 11.3.3 赋值. 327 11.3.4 默认值... 328 11.3.5 装箱和取消装箱... 328 11.3.6 this 的含义 ... 330 11.3.7 字段初始值设定项... 330 11.3.8 构造函数 330 11.3.9 析构函数 331 11.3.10 静态构造函数... 331 11.4 结构示例 331 11.4.1 数据库整数类型... 332 11.4.2 数据库布尔类型... 333 12. 数组 336 12.1 数组类型 336 12.1.1 System.Array 类型. 336 12.1.2 数组和泛型 IList 接口 337 12.2 数组创建 337 12.3 数组元素访问 ... 337 12.4 数组成员 337 12.5 数组协变 338 12.6 数组初始值设定项 338 13. 接口 341 13.1 接口声明 341 13.1.1 接口修饰符... 341 13.1.2 分部修饰符... 341 13.1.3 基接口... 341 13.1.4 接口体... 342 13.2 接口成员 342 13.2.1 接口方法 343 13.2.2 接口属性 343 13.2.3 接口事件 344 13.2.4 接口索引器... 344 13.2.5 接口成员访问. 344 13.3 完全限定接口成员名 ... 346 13.4 接口实现 346 13.4.1 显式接口成员实现... 347 13.4.2 所实现接口的唯一性 349 13.4.3 泛型方法的实现... 350 13.4.4 接口映射 350 13.4.5 接口实现继承. 353 13.4.6 接口重新实现. 354 13.4.7 抽象类和接口. 356 目录 14. 枚举 357 14.1 枚举声明 357 14.2 枚举修饰符 ... 357 14.3 枚举成员 358 14.4 System.Enum 类型 . 360 14.5 枚举值和运算 ... 360 15. 委托 361 15.1 委托声明 361 15.2 委托兼容性 ... 363 15.3 委托实例化 ... 363 15.4 委托调用 364 16. 异常 367 16.1 导致异常的原因 .. 367 16.2 System.Exception 类 ... 367 16.3 异常的处理方式 .. 367 16.4 公共异常类 ... 368 17. 属性 369 17.1 属性类 .. 369 17.1.1 属性用法 369 17.1.2 定位和命名参数... 370 17.1.3 属性参数类型. 371 17.2 属性说明 371 17.3 属性实例 376 17.3.1 属性的编译... 376 17.3.2 属性实例的运行时检索 376 17.4 保留属性 377 17.4.1 AttributeUsage 属性 ... 377 17.4.2 Conditional 属性 ... 378 17.4.2.1 条件方法 . 378 17.4.2.2 条件属性类 ... 380 17.4.3 Obsolete 属性 381 17.5 交互操作的属性 .. 382 17.5.1 与 COM 和 Win32 组件的交互操作 ... 382 17.5.2 与其他 .NET 语言的交互操作 . 382 17.5.2.1 IndexerName 属性 .. 382 18. 不安全代码 383 18.1 不安全上下文 ... 383 18.2 指针类型 385 18.3 固定和可移动变量 388 18.4 指针转换 388 18.5 表达式中的指针 .. 389 18.5.1 指针间接寻址. 389 xvi C#语言规范 18.5.2 指针成员访问. 390 18.5.3 指针元素访问. 391 18.5.4 address-of 运算符 ... 391 18.5.5 指针递增和递减... 392 18.5.6 指针算术运算. 392 18.5.7 指针比较 393 18.5.8 sizeof 运算符 . 393 18.6 fixed 语句 ...

"^The": 匹配以 "The"开头的字符串; "of despair$": 匹配以 "of despair" 结尾的字符串; "^abc$": 匹配以abc开头和以abc结尾的字符串，实际上是只有abc与之匹配 "notice": 匹配包含notice的字符串你可以看见如果你没有用我们提到的两个字符（最后一个例子），就是说模式（正则表达式）可以出现在被检验字符串的任何地方，你没有把他锁定到两边这里还有几个字符 '*', '+',和 '?', 他们用来表示一个字符可以出现的次数或者顺序. 他们分别表示："zero or more", "one or more", and "zero or one." 这里是一些例子: "ab*": 匹配字符串a和0个或者更多b组成的字符串("a", "ab", "abbb", etc.); "ab+": 和上面一样，但最少有一个b ("ab", "abbb", etc.); "ab?":匹配0个或者一个b; "a?b+$": 匹配以一个或者0个a再加上一个以上的b结尾的字符串. 你也可以在大括号里面限制字符出现的个数，比如 "ab{2}": 匹配一个a后面跟两个b（一个也不能少）("abb"); "ab{2,}": 最少更两个b("abb", "abbbb", etc.); "ab{3,5}": 2－5个b("abbb", "abbbb", or "abbbbb"). 你还要注意到你必须总是指定 (i.e, "{0,2}", not "{,2}").同样，你必须注意到, '*', '+', 和'?' 分别和一下三个范围标注是一样的，"{0,}", "{1,}", 和 "{0,1}"。现在把一定数量的字符放到小括号里，比如： "a(bc)*": 匹配 a 后面跟0个或者一个"bc"; "a(bc){1,5}": 一个到5个 "bc." 还有一个字符 '│', 相当于OR 操作: "hi│hello": 匹配含有"hi" 或者 "hello" 的字符串; "(b│cd)ef": 匹配含有 "bef" 或者 "cdef"的字符串; "(a│b)*c": 匹配含有这样 - 多个（包括0个）a或b，后面跟一个c 的字符串的字符串; 一个点('.')可以代表所有的单一字符: "a.[0-9]": 一个a跟一个字符再跟一个数字的（含有这样一个字符串的字符串将被匹配，以后省略此括号） "^.{3}$": 以三个字符结尾 . 中括号括住的内容只匹配一个单一的字符 "[ab]": 匹配单个的 a 或者 b ( 和 "a│b" 一样); "[a-d]": 匹配'a' 到'd'的单个字符 (和"a│b│c│d" 还有 "[abcd]"效果一样); "^[a-zA-Z]": 匹配以字母开头的字符串 "[0-9]%": 匹配含有形如 x％的字符串 ",[a-zA-Z0-9]$": 匹配以逗号在加一个数字或字母结尾的字符串你也可以把你不想要得字符列在中括号里，你只需要在总括号里面使用'^' 作为开头 (i.e., "%[^a-zA-Z]%" 匹配含有两个百分号里面有一个非字母的字符串). 为了能够解释，但"^.[$()│*+?{\"作为有特殊意义的字符的时候，你必须在这些字符面前加'', 还有在php3中你应该避免在模式的最前面使用\, 比如说,正则表达式 "(\$│?[0-9]+" 应该这样调用 ereg("(\\$│?[0-9]+", $str) (不知道php4是不是一样) 不要忘记在中括号里面的字符是这条规路的例外—在中括号里面, 所有的特殊字符，包括(''), 都将失去他们的特殊性质(i.e., "[*\+?{}.]"匹配含有这些字符的字符串). 还有,正如regx的手册告诉我们: "如果列表里含有 ']', 最好把它作为列表里的第一个字符(可能跟在'^'后面). 如果含有'-', 最好把它放在最前面或者最后面, or 或者一个范围的第二个结束点(i.e. [a-d-0-9]中间的‘-’将有效. 为了完整, 我应该涉及到 collating sequences, character classes, 同埋 equivalence classes. 但我在这些方面不想讲的太详细, 这些在下面的文章仲都不需要涉及到. 你们可以在regex man pages 那里得到更多消息. 如何构建一个模式来匹配货币数量的输入好了，现在我们要用我们所学的来干一些有用的事：构建一个匹配模式去检查输入的信息是否为一个表示money的数字。我们认为一个表示money的数量有四种方式： "10000.00" 和 "10,000.00",或者没有小数部分, "10000" and "10,000". 现在让我们开始构建这个匹配模式: ^[1-9][0-9]*$ 这是所变量必须以非0的数字开头.但这也意味着单一的 "0" 也不能通过测试. 以下是解决的方法: ^(0│[1-9][0-9]*)$ "只有0和不以0开头的数字与之匹配"，我们也可以允许一个负号再数字之前: ^(0│-?[1-9][0-9]*)$ 这就是: "0 或者一个以0开头可能有一个负号在前面的数字." 好了, 好了现在让我们别那么严谨，允许以0开头.现在让我们放弃负号 , 因为我们在表示钱币的时候并不需要用到. 我们现在指定模式用来匹配小数部分: ^[0-9]+(\.[0-9]+)?$ 这暗示匹配的字符串必须最少以一个阿拉伯数字开头. 但是注意，在上面模式中 "10." 是不匹配的, 只有 "10" 和 "10.2" 才可以. （你知道为什么吗） ^[0-9]+(\.[0-9]{2})?$ 我们上面指定小数点后面必须有两位小数.如果你认为这样太苛刻,你可以改成: ^[0-9]+(\.[0-9]{1,2})?$ 这将允许小数点后面有一到两个字符. 现在我们加上用来增加可读性的逗号（每隔三位）, 我们可以这样表示: ^[0-9]{1,3}(,[0-9]{3})*(\.[0-9]{1,2})?$ 不要忘记加号 '+' 可以被乘号 '*' 替代如果你想允许空白字符串被输入话 (为什么?). 也不要忘记反斜杆 ’\’ 在php字符串中可能会出现错误 (很普遍的错误). 现在，我们已经可以确认字符串了, 我们现在把所有逗号都去掉 str_replace(",", "", $money) 然后在把类型看成 double然后我们就可以通过他做数学计算了. 构造检查email的正则表达式好,让我们继续讨论怎么验证一个email地址. 在一个完整的email地址中有三个部分: POP3 用户名 (在 '@' 左边的一切), '@', 服务器名(就是剩下那部分). 用户名可以含有大小写字母阿拉伯数字,句号 ('.'), 减号('-'), and 下划线 ('_'). 服务器名字也是符合这个规则,当然下划线除外. 现在, 用户名的开始和结束都不能是句点. 服务器也是这样. 还有你不能有两个连续的句点他们之间至少存在一个字符，好现在我们来看一下怎么为用户名写一个匹配模式: ^[_a-zA-Z0-9-]+$ 现在还不能允许句号的存在. 我们把它加上: ^[_a-zA-Z0-9-]+(\.[_a-zA-Z0-9-]+)*$ 上面的意思就是说: "以至少一个规范字符（除.意外）开头,后面跟着0个或者多个以点开始的字符串." 简单化一点, 我们可以用 eregi()取代 ereg().eregi()对大小写不敏感, 我们就不需要指定两个范围 "a-z" 和 "A-Z" – 只需要指定一个就可以了: ^[_a-z0-9-]+(\.[_a-z0-9-]+)*$ 后面的服务器名字也是一样,但要去掉下划线: ^[a-z0-9-]+(\.[a-z0-9-]+)*$ Done. 现在只需要用”@”把两部分连接: ^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$ 这就是完整的email认证匹配模式了,只需要调用 eregi(‘^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$ ’,$eamil) 就可以得到是否为email了正则表达式的其他用法提取字符串 ereg() and eregi() 有一个特性是允许用户通过正则表达式去提取字符串的一部分(具体用法你可以阅读手册). 比如说,我们想从 path/URL 提取文件名 – 下面的代码就是你需要: ereg("([^\\/]*)$", $pathOrUrl, $regs); echo $regs[1]; 高级的代换 ereg_replace() 和 eregi_replace()也是非常有用的: 假如我们想把所有的间隔负号都替换成逗号: ereg_replace("[ \n\r\t]+", ",", trim($str)); PHP被大量的应用于Web的后台CGI开发，通常是在用户数据数据之后得出某种结果，但是如果用户输入的数据不正确，就会出现问题，比如说某人的生日是"2月30日"！那应该怎么样来检验暑假是否正确呢？在PHP中加入了正则表达式的支持，让我们可以十分方便的进行数据匹配。 2 什么是正则表达式：简单的说，正则表达式是一种可以用于模式匹配和替换的强大工具。在几乎所有的基于UNIX/LINUX系统的软件工具中找到正则表达式的痕迹，例如：Perl或PHP脚本语言。此外，JavaScript这种客户端的脚本语言也提供了对正则表达式的支持，现在正则表达式已经成为了一个通用的概念和工具，被各类技术人员所广泛使用。在某个Linux网站上面有这样的话："如果你问一下Linux爱好者最喜欢什么，他可能会回答正则表达式；如果你问他最害怕什么，除了繁琐的安装配置外他肯定会说正则表达式。" 正如上面说的，正则表达式看起来非常复杂，让人害怕，大多数的PHP初学者都会跳过这里，继续下面的学习，但是PHP中的正则表达式有着可以利用模式匹配找到符合条件的字符串、判断字符串是否合乎条件或者用指定的字符串来替代符合条件的字符串等强大的功能，不学实在太可惜了…… 3 正则表达式的基本语法：一个正则表达式，分为三个部分：分隔符，表达式和修饰符。分隔符可以是除了特殊字符以外的任何字符（比如"/ !"等等），常用的分隔符是"/"。表达式由一些特殊字符（特殊字符详见下面）和非特殊的字符串组成，比如"[a-z0-9_-]+@[a-z0-9_-.]+"可以匹配一个简单的电子邮件字符串。修饰符是用来开启或者关闭某种功能/模式。下面就是一个完整的正则表达式的例子： /hello.+?hello/is 上面的正则表达式"/"就是分隔符，两个"/"之间的就是表达式，第二个"/"后面的字符串"is"就是修饰符。在表达式中如果含有分隔符，那么就需要使用转义符号"\"，比如"/hello.+?\/hello/is"。转义符号除了用于分隔符外还可以执行特殊字符，全部由字母构成的特殊字符都需要"\"来转义，比如"\d"代表全体数字。 4 正则表达式的特殊字符：正则表达式中的特殊字符分为元字符、定位字符等等。元字符是正则表达式中一类有特殊意义的字符，用来描述其前导字符（即元字符前面的字符）在被匹配的对象中出现的方式。元字符本身是一个个单一的字符，但是不同或者相同的元字符组合起来可以构成大的元字符。元字符：大括号：大括号用来精确指定匹配元字符出现的次数，例如"/pre{1,5}/"表示匹配的对象可以是"pre"、"pree"、"preeeee"这样在"pr"后面出现1个到5个"e"的字符串。或者"/pre{,5}/"代表pre出现0此到5次之间。加号："+"字符用来匹配元字符前的字符出现一次或者多次。例如"/ac+/"表示被匹配的对象可以是"act"、"account"、"acccc"等在"a"后面出现一个或者多个"c"的字符串。"+"相当于"{1,}"。星号："*"字符用来匹配元字符前的字符出现零次或者多次。例如"/ac*/"表示被匹配的对象可以是"app"、"acp"、"accp"等在"a"后面出现零个或者多个"c"的字符串。"*"相当于"{0,}"。问号："?"字符用来匹配元字符前的字符出现零次或者1次。例如"/ac?/"表示匹配的对象可以是"a"、"acp"、"acwp"这样在"a"后面出现零个或者1个"c"的字符串。"?"在正则表达式中还有一个非常重要的作用，即"贪婪模式"。还有两个很重要的特殊字符就是"[ ]"。他们可以匹配"[]"之中出现过的字符，比如"/[az]/"可以匹配单个字符"a"或者"z"；如果把上面的表达式改成这样"/[a-z]/"，就可以匹配任何单个小写字母，比如"a"、"b"等等。如果在"[]"中出现了"^"，代表本表达式不匹配"[]"内出现的字符，比如"/[^a-z]/"不匹配任何小写字母！并且正则表达式给出了几种"[]"的默认值： [:alpha:]：匹配任何字母 [:alnum:]：匹配任何字母和数字 [:digit:]：匹配任何数字 [:space:]：匹配空格符 [:upper:]：匹配任何大写字母 [:lower:]：匹配任何小写字母 [:punct:]：匹配任何标点符号 [:xdigit:]：匹配任何16进制数字另外下面这些特殊字符在转义符号"\"转义后代表的含义如下： s：匹配单个的空格符 S：用于匹配除单个空格符之外的所有字符。 d：用于匹配从0到9的数字，相当于"/[0-9]/"。 w：用于匹配字母，数字或下划线字符，相当于"/[a-zA-Z0-9_]/"。 W：用于匹配所有与w不匹配的字符，相当于"/[^a-zA-Z0-9_]/"。 D：用于匹配任何非10进制的数字字符。 .：用于匹配除换行符之外的所有字符，如果经过修饰符"s"的修饰，"."可以代表任意字符。利用上面的特殊字符可以很方便的表达一些比较繁琐的模式匹配。例如"/\d0000/"利用上面的正则表达式可以匹配万以上，十万一下的整数字符串。定位字符：定位字符是正则表达式中又一类非常重要的字符，它的主要作用是用于对字符在匹配对象中的位置进行描述。 ^：表示匹配的模式出现在匹配对象的开头（和在"[]"里面不同） $：表示匹配的模式出现在匹配对象的末尾空格：表示匹配的模式出现在开始和结尾的两个边界之一 "/^he/"：可以匹配以"he"字符开头的字符串，比如hello、height等等； "/he$/"：可以匹配以"he"字符结尾的字符串即she等； "/ he/"：空格开头，和^的作用一样，匹配以he开头的字符串； "/he /"：空格结束，和$的作用一样，匹配以he结尾的字符串； "/^he$/"：表示只和字符串"he"匹配。括号：正则表达式除了可以用户匹配，还可以用括号"()"来记录需要的信息，储存起来，给后面的表达式读取。比如： /^([a-zA-Z0-9_-]+)@([a-zA-Z0-9_-]+)(.[a-zA-Z0-9_-])$/ 就是记录邮件地址的用户名，和邮件地址的服务器地址（形式为username@server.com之类的），在后面如果想要读取记录下来的字符串，只是需要用"转义符＋记录的次序"来读取。比如"\1"就相当于第一个"[a-zA-Z0-9_-]+"，"\2"相当于第二个([a-zA-Z0-9_-]+)，"\3"就是第三个(.[a-zA-Z0-9_-])。但是在PHP中，"\"是一个特殊的字符，需要转义，所以""到了PHP的表达式中就应该写成"\\1"。其他特殊符号： "|"：或符号"|"和PHP里面的或一样，不过是一个"|"，而不是PHP的两个"||"！意思就是可以是某个字符或者另一个字符串，比如"/abcd|dcba/"可能匹配"abcd"或者"dcba"。 5 贪婪模式：前面在元字符中提到过"?"还有一个重要的作用，即"贪婪模式"，什么是"贪婪模式"呢？比如我们要匹配以字母"a"开头字母"b"结尾的字符串，但是需要匹配的字符串在"a"后面含有很多个"b"，比如"a bbbbbbbbbbbbbbbbb"，那正则表达式是会匹配第一个"b"还是最后一个"b"呢？如果你使用了贪婪模式，那么会匹配到最后一个"b"，反之只是匹配到第一个"b"。使用贪婪模式的表达式如下： /a.+?b/ /a.+b/U 不使用贪婪模式的如下： /a.+b/ 上面使用了一个修饰符U，详见下面的部分。 6 修饰符：在正则表达式里面的修饰符可以改变正则的很多特性，使得正则表达式更加适合你的需要（注意：修饰符对于大小写是敏感的，这意味着"e"并不等于"E"）。正则表达式里面的修饰符如下： i ：如果在修饰符中加上"i"，则正则将会取消大小写敏感性，即"a"和"A" 是一样的。 m：默认的正则开始"^"和结束"$"只是对于正则字符串如果在修饰符中加上"m"，那么开始和结束将会指字符串的每一行：每一行的开头就是"^"，结尾就是"$"。 s：如果在修饰符中加入"s"，那么默认的"."代表除了换行符以外的任何字符将会变成任意字符，也就是包括换行符！ x：如果加上该修饰符，表达式中的空白字符将会被忽略，除非它已经被转义。 e：本修饰符仅仅对于replacement有用，代表在replacement中作为PHP代码。 A：如果使用这个修饰符，那么表达式必须是匹配的字符串中的开头部分。比如说"/a/A"匹配"abcd"。 E：与"m"相反，如果使用这个修饰符，那么"$"将匹配绝对字符串的结尾，而不是换行符前面，默认就打开了这个模式。 U：和问号的作用差不多，用于设置"贪婪模式"。 7 PCRE相关的正则表达式函数： PHP的Perl兼容正则表达式提供的多个函数，分为模式匹配，替换和匹配数目等等： 1、preg_match ：函数格式：int preg_match(string pattern, string subject, array [matches]); 这个函数会在string中使用pattern表达式来匹配，如果给定了[regs]，就会将string记录到[regs][0]中，[regs][1]代表使用括号"（）"记录下来的第一个字符串，[regs][2]代表记录下来的第二个字符串，以此类推。preg如果在string中找到了匹配的pattern，就会返回"true"，否则返回"false"。 2、preg_replace ：函数格式：mixed preg_replace(mixed pattern, mixed replacement, mixed subject); 这个函数会使用将string中符合表达式pattern的字符串全部替换为表达式replacement。如果replacement中需要包含pattern的部分字符，则可以使用"()"来记录，在replacement中只是需要用"\1"来读取。 3、preg_split ：函数格式：array preg_split(string pattern, string subject, int [limit]); 这个函数和函数split一样，区别仅在与split可以使用简单正则表达式来分割匹配的字符串，而preg_split使用完全的Perl兼容正则表达式。第三个参数limit代表允许返回多少个符合条件的值。 4、preg_grep ：函数格式：array preg_grep(string patern , array input); 这个函数和preg_match功能基本上，不过preg_grep可以将给定的数组input中的所有元素匹配，返回一个新的数组。下面举一个例子，比如我们要检查Email地址的格式是否正确： <?php function emailIsRight($email) { if (preg_match("^[_\.0-9a-z-]+@([0-9a-z][0-9a-z-]+\.)+[a-z]{2,3}$",$email)) { return 1; } return 0; } if(emailIsRight('y10k@963.net')) echo '正确
'; if(!emailIsRight('y10k@fffff')) echo '不正确
'; ?> 上面的程序会输出"正确
不正确"。 8.PHP中的Perl兼容正则表达式和Perl/Ereg正则表达式的区别：虽然叫做“Perl兼容正则表达式”，但是和Perl的正则表达式相比，PHP的还是由一些不同，比如修饰符“G”在Perl里面代表全部匹配，但是在PHP中没有加入对这个修饰符的支持。还有就是和ereg系列函数的区别，ereg也是PHP中提供的正则表达式函数，不过和preg相比，要弱上很多。 1、ereg里面是不需要也不能使用分隔符和修饰符的，所以ereg的功能比preg要弱上不少。 2、关于"."：点在正则里面一般是除了换行符以外的全部字符，但是在ereg里面的"."是任意字符，即包括换行符！如果在preg里面希望"."能够包括换行符，可以在修饰符中加上"s"。 3、ereg默认使用贪婪模式，并且不能修改，这个给很多替换和匹配带来麻烦。 4、速度：这个或许是很多人关心的问题，会不会preg功能强大是以速度来换取的？不用担心，preg的速度要远远比ereg快，笔者做了一个程序测试： time test: PHP代码: <?php echo "Preg_replace used time:"; $start = time(); for($i=1;$i<=100000;$i++) { $str = "ssssssssssssssssssssssssssss"; preg_replace("/s/","",$str); } $ended = time()-$start; echo $ended; echo " ereg_replace used time:"; $start = time(); for($i=1;$i<=100000;$i++) { $str = "ssssssssssssssssssssssssssss"; ereg_replace("s","",$str); } $ended = time()-$start; echo $ended; echo " str_replace used time:"; $start = time(); for($i=1;$i<=100000;$i++) { $str = "sssssssssssssssssssssssssssss"; str_replace("s","",$str); } $ended = time()-$start; echo $ended; ?> 结果： Preg_replace used time:5 ereg_replace used time:15 str_replace used time:2 str_replace因为不需要匹配所以速度非常快，而preg_replace的速度比ereg_replace要快上不少。 9.关于PHP3.0对于preg的支持：在PHP 4.0中默认加入了preg支持，但是在3.0中确没有。如果在3.0中希望使用preg函数，必须加载php3_pcre.dll文件，只要在php.ini的extension部分设置加入"extension = php3_pcre.dll"然后从新启动PHP就可以了！其实正则表达式还常用于UbbCode的实现，很多PHP论坛都使用了这个方法（比如zForum zphp.com或者vB vbullent.com），但是具体的代码比较长。本文来自http://blog.csdn.net/kkobebryant/archive/2005/01/25/267527.aspx

110,535

社区成员

642,575

社区内容

发帖

与我相关

我的任务

社区管理员

加入社区

近7日
近30日
至今

加载中

查看更多榜单

社区公告

让您成为最强悍的C#开发者

试试用AI创作助手写篇文章吧

+ 用AI写文章