易学C#PDF电子书下载

预备课：学习从这里开始 1

1．软件＝程序＋文档 1

2．程序起什么作用 2

3．为何要面向对象 2

4．什么是UML 3

5．.NET与C＃ 4

谈微软公司的．NET战略 4

C＃的产生与特点 5

C＃与．NET的关系 6

6．开启C＃的钥匙——兴趣与正确的学习方法 7

7．习题练习 8

第1部分　C＃与UML基础第1章 开篇经典——“Hello,World” 11

1.1 Hello,World 11

1.2　程序的结构分析 13

1.2.1　命名空间 13

1.2.2　类和类的方法 13

1.2.3　程序的输入输出 14

1.3　程序的执行起点——Main函数 14

1.4　控制台的输入和输出 14

1.4.1　控制台的输入：Read和ReadLine 15

1.4.2　控制台的输出：Write和WriteLine 15

1.5　程序的注释 15

1.5.1　模块（类）注释规范 16

1.5.2　类属性注释规范 16

1.5.3　方法注释规范 16

1.5.4　代码间注释规范 16

1.6　习题练习 17

第2章　数据类型和表达式 18

2.1　数据类型简介 18

2.2　值类型 19

2.2.1　简单类型 19

2.2.2　结构类型 22

2.2.3　枚举类型 23

2.3　引用类型 24

2.4 null和void 24

2.4.1 null 24

2.4.2 void 24

2.5　变量和常量 25

2.5.1　变量 25

2.5.2　常量 29

2.6 运算处理 29

2.6.1　算术运算 30

2.6.2　赋值运算 32

2.6.3　关系运算 32

2.6.4　逻辑运算 33

2.6.5　位运算 33

2.6.6　条件运算 35

2.6.7　其他运算符 36

2.6.8　运算符的优先级别 36

2.7　指针类型 37

2.7.1　指针的定义与声明 37

2.7.2　指针的内容 37

2.7.3　指针的运算 38

2.7.4　指针的使用 40

2.8　习题练习 41

第3章　数据类型转换 43

3.1　装箱和拆箱 43

3.1.1　装箱（Boxing） 43

3.1.2　拆箱（Unboxing） 44

3.2　隐式数据类型转换 45

3.2.1　隐式数值类型转换 45

3.2.2　隐式枚举类型转换 46

3.2.3　隐式引用类型转换 47

3.3　显式数据类型转换 48

3.3.1　显式数值类型转换 48

3.3.2　显式枚举类型转换 50

3.3.3　显式引用类型转换 50

3.4　习题练习 51

第4章　计算控制——结构化程序设计 53

4.1　如果——条件语句 53

4.1.1　如果，那么——if 53

4.1.2　如果，那么；否则——if,else 55

4.1.3　如果中的如果——嵌套if,else 56

4.1.4　如果，那么；否则的另一种表达方式——？： 57

4.1.5　多条件选择——switch 58

4.2　会转圈的语句——循环语句 60

4.2.1 for循环 60

4.2.2 while循环 63

4.2.3 do/while循环 65

4.2.4 foreach循环 66

4.3　跳出循环——跳转语句 67

4.3.1 使用break和continue语句的区别 67

4.3.2　饱受争议的goto语句 68

4.3.3 return语句的使用 70

4.4 C＃预处理器指令 70

4.4.1　使用预处理指令——＃define和＃undef 70

4.4.2　条件编译——＃if、＃elif、＃else和＃endif 71

4.4.3　警告与错误信息——＃warning和＃error 72

4.4.4 可视编辑器提示——＃region和＃endregion 72

4.4.5　指定行号——＃line 72

4.4.6　关闭警告消息——＃pragma 72

4.5　程序员加油站——递归法 73

4.5.1　递归法概述 73

4.5.2　递归的精髓——求解汉诺塔问题 73

4.6 习题练习 75

第5章　字符串、数组与集合 77

5.1　理解字符串 77

5.1.1　字符串类型定义 77

5.1.2　字符串类型应用实例 79

5.1.3 string与String的区别 82

5.2　存储盒子的“仓库”——数组 82

5.2.1　数组的定义 82

5.2.2　二维数组 85

5.2.3　多维数组和交错数组 87

5.3　程序员加油站——数组的应用 88

5.3.1　把数组作为参数传递给方法 88

5.3.2　使用数组模拟栈操作 89

5.3.3　数据的排序与冒泡排序算法 91

5.4　一个与数组相似的新类型——集合 92

5.4.1　集合的概述 93

5.4.2　集合类的使用实例 93

5.4.3　集合与数组的区别 97

5.5　习题练习 97

第6章　C＃程序员UML建模基础 100

6.1　为什么要建模 100

6.2 UML概述 101

6.3 用例建模 101

6.3.1　用例图 101

6.3.2　用例描述 102

6.3.3 用例建模实例 102

6.4　类图 103

6.4.1　绘制类图 104

6.4.2　类图中的各种关系 105

6.5　活动图 107

6.6 状态图 107

6.7　序列图 108

6.8　习题练习 109

第2部分　C＃与面向对象程序设计第7章　初识面向对象程序设计 113

7.1　万物皆为对象 113

7.2　初识封装 114

7.3　类和对象 114

7.3.1　类的声明 114

7.3.2　类的成员 115

7.3.3　类的成员的可见性 116

7.3.4 对象的创建与使用 117

7.3.5　静态成员与非静态成员 118

7.3.6 this关键字 118

7.4　对象的创建与销毁 119

7.4.1　构造函数 120

7.4.2　静态构造函数 122

7.4.3　析构函数 124

7.5　类的执行工具——方法 124

7.5.1　方法的声明 125

7.5.2　方法的返回值 125

7.5.3　方法的参数 126

7.5.4　方法的重载 127

7.6　域、属性和索引指示器 128

7.6.1 域 128

7.6.2　属性 131

7.6.3　索引指示器 133

7.7　再论封装 134

7.7.1 用传统的读、写方法封装 134

7.7.2　用属性来实现封装 135

7.8　命名空间 135

7.8.1　命名空间的声明 136

7.8.2 成员与类型声明 137

7.8.3　使用指示符 137

7.9　习题练习 140

第8章　复用现有的代码——继承与多重继承 142

8.1 继承的意义 142

8.1.1 继承的引入 142

8.1.2　为何要使用继承 143

8.2 用UML图描述继承 144

8.3　父与子——类的继承 145

8.3.1　基类与派生类 145

8.3.2　继承中的构造函数 151

8.3.3　访问和隐藏基类方法 152

8.3.4　虚方法与重写方法 153

8.3.5　抽象类和抽象方法 154

8.3.6　密封类和密封方法 155

8.4　继承与访问修饰符 156

8.4.1 可见性访问修饰符 156

8.4.2　其他访问修饰符 157

8.5 双亲与子——多重继承 157

8.5.1　水陆两用汽车的类图设计 157

8.5.2　用接口实现多重继承 158

8.5.3　用扩展方法实现多重继承 160

8.6 C＃的继承规则 161

8.7　再论继承与封装的关系 161

8.8　程序员加油站——又论冒泡排序算法 162

8.9　习题练习 166

第9章　改写对象的行为——多态 169

9.1　笔与其派生类的写方法 169

9.2　多态的类型 170

9.2.1　编译时的多态性 170

9.2.2 运行时的多态性 170

9.3　多态的实现 172

9.3.1　通过接口实现的多态性 172

9.3.2 通过继承实现的多态性 174

9.3.3 通过抽象类实现的多态性 174

9.4　程序员加油站——经典的图形游戏 176

9.4.1　类图分析 176

9.4.2　代码实现与分析 177

9.4.3　游戏的客户端 181

9.5　习题练习 183

第10章　多功能的运算符——运算符重载 184

10.1　引入运算符重载 184

10.2 运算符重载的规则 185

10.3　一元运算符的重载 186

10.4　二元运算符的重载 188

10.5 比较运算符的重载 190

10.6　习题练习 191

第11章　软件模块之间的协定——接口 192

11.1　打印机程序的困惑 192

11.2　接口的意义 193

11.2.1　软件的多层设计思考 193

11.2.2　组件与接口 193

11.2.3 组件化程序设计思考 194

11.3　接口的定义 195

11.4　接口的成员 195

11.5　在UML中对接口的描述 197

11.6　接口的继承与多重继承 198

11.7　接口成员访问 199

11.8　接口的实现 200

11.8.1　在类中实现接口 201

11.8.2　显式实现接口成员 203

11.8.3　显式与隐式实现接口成员的区别 205

11.8.4　接口映射 205

11.8.5　接口的重实现 209

11.9　抽象类与接口 210

11.9.1　在抽象类中实现接口 210

11.9.2　抽象与接口的区别 210

11.9.3　抽象与接口的使用 211

11.10　接口作为返回值与参数 211

11.11　程序员加油站——打印机程序的设计 214

11.12　习题练习 216

第12章　面向对象设计原则与UML描述 218

12.1　腐化的软件设计 218

12.1.1　设计的臭味 218

12.1.2　软件为何会腐化 220

12.2　简单就是美——单一职责原则（SRP） 220

12.2.1　从Communication类的设计来看待单一职责原则 221

12.2.2　分离耦合的职责 222

12.3　修改封闭扩展开放——开放—封闭原则（OCP） 222

12.3.1 开封—封闭原则概述 222

12.3.2 银行储蓄业务的分析与设计 223

12.4　子类型替换基类型——Liskov替换原则（LSP） 226

12.4.1 Liskov替换原则概述 226

12.4.2　违反Liskov替换原则的场景 226

12.4.3　用提取公共部分的方法来代替继承 228

12.5　依赖于抽象——依赖倒置原则（DIP） 229

12.5.1　依赖倒置原则概述 229

12.5.2　再论银行储蓄业务的设计 230

12.6　分离接口——接口隔离原则（ISP） 232

12.6.1　接口污染 232

12.6.2　分离客户就是分离接口 234

12.6.3　使用委托分离接口 235

12.6.4　使用多重继承分离接口 235

12.7　习题练习 236

第3部分　C＃语言高级特性第13章　程序的体检医生——异常处理 239

13.1　异常处理概述 239

13.2 C＃异常处理类 240

13.3 try、catch和finally 241

13.3.1 try和catch的用法 241

13.3.2 finally的用法 244

13.4　把异常传给调用者 245

13.4.1　调用者处理 245

13.4.2　抛出异常 245

13.4.3　重发异常 246

13.4.4　添加异常信息 247

13.5　用户自定义异常 248

13.5.1　定义自己的异常类 248

13.5.2　从自己的代码中抛出异常 248

13.6　细说异常使用 249

13.6.1　何时考虑抛出异常 249

13.6.2　在异常处理程序中做什么 249

13.6.3　在何处放置异常处理程序 250

13.6.4　异常与返回错误代码的对比 250

13.6.5　永远不要预测bug造成的后果能够被异常处理程序所捕获 250

13.7 习题练习 250

第14章　房屋中介与租房——委托与事件 252

14.1　从房屋中介与租房看待委托与事件 252

14.2 又论“Hello,World” 253

14.3　委托的概述 254

14.3.1　委托的声明 254

14.3.2 将方法绑定到委托 256

14.4　事件 257

14.4.1　引入事件 258

14.4.2　声明事件 260

14.4.3　使用事件 260

14.4.4　访问器形式的事件 261

14.4.5　在接口中声明事件 263

14.5　多播委托 264

14.6　委托中的协变和逆变 266

14.7　匿名方法 268

14.7.1　什么是匿名方法 268

14.7.2　匿名方法的参数与返回值 268

14.7.3　匿名方法块规则 269

14.7.4　匿名方法的外部变量 269

14.8　习题练习 272

第15章　程序集与反射 274

15.1　再论“Hello,World” 274

15.1.1　创建“Hello,World”的业务逻辑类库 274

15.1.2　详解C＃程序集版本控制文件 275

15.1.3　创建“Hello,World”应用层 277

15.2　反射的概述 278

15.2.1　什么是反射 278

15.2.2　反射的作用 279

15.3　反射的实际使用 280

15.3.1　反射AppDomain的程序集 280

15.3.2　利用反射获取类型信息 281

15.3.3　通过反射创建类型的实例 282

15.3.4　利用反射动态调用类成员 284

15.4　反射的性能 286

15.5　习题练习 286

第16章　序列化与反序列化 287

16.1　序列化的概述 287

16.1.1　从权限系统来看待序列化和反序列化 287

16.1.2　序列化的作用 288

16.1.3　为序列化配置对象 289

16.2　序列化和反序列化方式 290

16.3　使用BinaryFormatter进行序列化 291

16.4　使用SoapFormatter进行序列化 293

16.5　使用XmlSerializer进行序列化 295

16.6　自定义序列化 297

16.6.1　使用ISerializable自定义序列化 298

16.6.2　使用特性自定义序列化 301

16.7　序列化过程中的步骤 302

16.8　序列化准则 303

16.9　习题练习 303

第17章　项目小组和程序员——进程和线程 304

17.1　进程与线程概述 304

17.1.1　从打印工资报表看待进程与线程 304

17.1.2　进程与线程的关系 306

17.2　.NET平台下与进程进行交互 306

17.2.1 Process类简介 306

17.2.2　简单的进程操作实例 307

17.3　初识多线程操作 310

17.3.1 System.Threading概述 310

17.3.2　一个简单的线程例子 312

17.3.3 ThreadStart的使用 313

17.3.4　线程的并行操作 314

17.3.5　终止线程 316

17.3.6　前台线程与后台线程 318

17.3.7　线程的优先级 319

17.4　线程中存在的问题 321

17.4.1　竞争条件 321

17.4.2　锁定 323

17.5　线程同步 325

17.5.1　没有同步的情况 325

17.5.2 lock语句 326

17.5.3 Monitor类 328

17.5.4　使用lock与Monitor来解决生产者与消费者的问题 330

17.5.5 Events类 333

17.5.6 互斥对象 336

17.6　多线程的自动管理 336

17.6.1　线程池 337

17.6.2　定时器 340

17.7　习题练习 343

第18章　万能模板——泛型 345

18.1　泛型的引入 345

18.1.1　为什么要使用泛型 345

18.1.2　创建和使用泛型 347

18.1.3　命名规则 348

18.2　泛型类 348

18.2.1 声明泛型类 348

18.2.2　类型参数 349

18.2.3　泛型类的继承 350

18.2.4　泛型类的成员 350

18.2.5　泛型类中的静态变量 351

18.2.6　泛型类中的静态构造函数 351

18.2.7　访问受保护的成员 352

18.2.8　泛型类中的方法重载 352

18.2.9　创建泛型类的注意事项 353

18.3　泛型接口 353

18.3.1　实现接口的惟一性 353

18.3.2　显式接口成员实现 354

18.4　泛型委托 355

18.5　泛型方法 355

18.5.1　创建和使用泛型方法 355

18.5.2 abstract、irtual和override泛型方法 356

18.5.3　泛型静态方法 357

18.5.4　类型实参推断 358

18.6　参数约束 358

18.7　习题练习 360

第19章　C# 3.0语言新特性 364

19.1　隐式类型 364

19.1.1　隐式类型局部变量的声明与使用 364

19.1.2　隐式类型数组 365

19.1.3　隐式类型局部变量的使用限制 366

19.1.4　隐式类型局部变量的使用注意事项 366

19.2　匿名类型 367

19.2.1　引入匿名类型 367

19.2.2　创建和使用匿名类型 368

19.2.3　匿名类型与隐式类型变量的区别 369

19.3　扩展方法 369

19.3.1　定义扩展方法 369

19.3.2　导入扩展方法 370

19.3.3　调用扩展方法 370

19.3.4　扩展方法使用注意事项 372

19.4 对象和集合初始化器 372

19.4.1　引入对象初始化器 372

19.4.2　在初始化语法中调用自定义构造函数 374

19.4.3　初始化内部类型 375

19.4.4　集合初始化器 376

19.5 Lambda表达式 377

19.5.1　创建Lambda表达式 377

19.5.2 Lambda表达式转换 378

19.5.3　类型推断 379

19.5.4　重载抉择 381

19.5.5　表达式树 381

19.6　习题练习 382

第4部分　基于UML的面向对象分析与设计过程第20章　基于UML的面向对象分析与设计过程 384

20.1　细说需求分析 384

20.1.1　需求分析流程 385

20.1.2　基于Web通用框架的需求描述 387

20.2　构造业务用例图 387

20.2.1　确定系统的参与者 387

20.2.2　确定系统的业务用例 388

20.2.3　绘制业务用例图 389

20.3　使用活动图来描述业务用例 389

20.3.1　绘制操作子系统插件菜单的活动图 389

20.3.2　绘制管理用户权限的活动图 390

20.4　构造系统用例图 390

20.5　用例规约 391

20.5.1　基本流 392

20.5.2　备选流 393

20.5.3　特殊需求 393

20.5.4　前置条件与后置条件 393

20.5.5　描述用例规约实例 393

20.6　绘制业务领域类图 396

20.7　系统架构设计 397

20.8　数据库设计 398

20.8.1　数据库表设计 398

20.8.2　表关系设计 399

20.9　总体类图设计 400

20.10　模块详细设计与编码 401

20.10.1　数据库通用操作组件：IBHDataAccess 401

20.10.2　用户权限管理接口：IBHPowerMangageInterface 402

20.10.3　用户权限管理业务逻辑操作层：IBHPowerManageClass 404

20.10.4　用户权限管理页面表示层：IBHPowerManage 405

20.10.5 Web通用框架：IBHWebFramework 406

20.11 Web通用框架的部署与测试 408

20.12　习题练习 410