登入帳戶  | 訂單查詢  | 購物車/收銀台( 0 ) | 在線留言板  | 付款方式  | 聯絡我們  | 運費計算  | 幫助中心 |  加入書簽
會員登入 新註冊 | 新用戶登記
HOME新書上架暢銷書架好書推介特價區會員書架精選月讀2023年度TOP分類閱讀雜誌 香港/國際用戶
最新/最熱/最齊全的簡體書網 品種:超過100萬種書,正品正价,放心網購,悭钱省心 送貨:速遞 / EMS,時效:出貨後2-3日

2024年03月出版新書

2024年02月出版新書

2024年01月出版新書

2023年12月出版新書

2023年11月出版新書

2023年10月出版新書

2023年09月出版新書

2023年08月出版新書

2023年07月出版新書

2023年06月出版新書

2023年05月出版新書

2023年04月出版新書

2023年03月出版新書

2023年02月出版新書

『簡體書』Visual C#从入门到精通(第8版)

書城自編碼: 2845231
分類: 簡體書→大陸圖書→計算機/網絡程序設計
作者: John Sharp著 周靖译
國際書號(ISBN): 9787302435273
出版社: 清华大学出版社
出版日期: 2016-06-01
版次: 1 印次: 1
頁數/字數: 672/899000
書度/開本: 16开 釘裝: 平装

售價:NT$ 968

我要買

share:

** 我創建的書架 **
未登入.



新書推薦:
边界之外:海外社会研究(第一辑)
《 边界之外:海外社会研究(第一辑) 》

售價:NT$ 386.0
好销售,不违心:在你的舒适区内拿订单
《 好销售,不违心:在你的舒适区内拿订单 》

售價:NT$ 330.0
阿富汗史:骑驰在风暴中的国度
《 阿富汗史:骑驰在风暴中的国度 》

售價:NT$ 549.0
背影2
《 背影2 》

售價:NT$ 386.0
她的罪名
《 她的罪名 》

售價:NT$ 279.0
巨变与突围:碰撞中的清帝国:1644—1840
《 巨变与突围:碰撞中的清帝国:1644—1840 》

售價:NT$ 437.0
变态心理揭秘
《 变态心理揭秘 》

售價:NT$ 279.0
非洲三万里(2024版)
《 非洲三万里(2024版) 》

售價:NT$ 381.0

建議一齊購買:

+

NT$ 490
《 新东方 SAT II数学 Level 2 》
+

NT$ 490
《 透视画法基础:视觉研究(第6版) 》
+

NT$ 468
《 精通LabVIEW教程——由浅入深的范例学习(第二版) 》
+

NT$ 1110
《 Head First C#(第三版) 》
+

NT$ 960
《 中文版Excel 2016宝典(第9版) 》
編輯推薦:
通过本书,读者将掌握新版本Visual Studio 2015与Visual C#的基础编程知识。经验丰富的软件开发人员,可以通过本书的所有编程指导、练习和代码,着手开发响应速度快、扩展性强的Windows 10和Universal Windows Platform应用程序。
本书重要主题:
? 使用Visual Studio 2015快速开始创建Visual C#代码和项目
? 探索变量、操作符、表达式和方法的使用
? 运用决策和迭代语句来控制程序流程
? 运用错误、异常和资源管理来构建更健壮的app
? 掌握Visual C#的面向对象编程基础
? 掌握枚举、结构、泛型、索引器和其他高级特性的用法
? 用LINQ查询表达式来创建内存数据查询
? 通过异步方法来提升应用程序的吞吐量和响应时间
? 解耦应用程序逻辑和事件处理
? 用新增app模板来进行流水开发
? 模型-视图-视图模型(MVVM)的实现
? 构建可以无缝适应PC,平板和Windows手机的Universal Windows Platform app
? 集成Microsoft Azure云端
內容簡介:
C#作为微软的旗舰编程语言,深受程序员喜爱,是编写高效应用程序的首选语言。Visual C# 2015提供了大量新功能,本书围绕语言的基础知识和这些新功能全面介绍了如何利用Visual Studio 2015和.NET Framework 4.6编写C#应用程序。本书沿袭深受读者欢迎的Step by Step风格,通过合理的练习引导读者逐步构建在Windows 10上运行的应用程序、访问SQL Server数据库以及开发多线程应用等。
全书共27章,结构清晰,叙述清楚。所有练习均在Visual Studio 2015简体中文版上进行过全面演练。无论是刚开始接触面向对象编程的新手,还是打算迁移到C#的C、C 或Java程序员,都可以从本书汲取到新的知识。迅速掌握C#编程技术。
關於作者:
作者:John Sharp 资深技术作家,Content
Master(英国CM集团的分支机构)的首席技术专家。John拥有伦敦帝国理工学院的计算机荣誉学士学位。过去27年,他一直致力于软件开发和培训教程与课程的写作。John拥有丰富的技术资历,精通数据库系统、UNIX、C、C 和C#应用开发。他还开发过Java和JavaScript应用,用Windows Azure设计企业级方案。
译者:周靖 翻译风格严谨、准确、朴实、流畅,深受读者欢迎。代表译著有《Visual C#从入门到精通》系列版本、《C#本质论》、《CLR via C#》系列版本和Walter Savitch教授的经典教材《C 程序设计》系列版本。
目錄
目 录
第I部分 Visual C#和Visual
Studio 2015概述
第1章 欢迎进入C#编程世界 3
1.1 开始在Visual
Studio 2015环境中
编程 3
1.2 写第一个程序 7
1.3 使用命名空间 11
1.4 创建图形应用程序 14
1.4.1 探索通用Windows平台应用
程序 20
1.4.2 向图形应用程序添加代码 23
小结 25
第1章快速参考 25
第2章 使用变量、操作符和表达式 27
2.1 理解语句 27
2.2 使用标识符 27
2.3 使用变量 29
2.3.1 命名变量 29
2.3.2 声明变量 29
2.4 使用基元数据类型 30
2.4.1 未赋值的局部变量
31
2.4.2 显示基元数据类型的值
31
2.5 使用算术操作符 36
2.5.1 操作符和类型 36
2.5.2 深入了解算术操作符
38
2.5.3 控制优先级 42
2.5.4 使用结合性对表达式进行
求值 43
2.5.5 结合性和赋值操作符
43
2.6 变量递增和递减 44
2.7 声明隐式类型的局部变量
45
小结 46
第2章快速参考 47
第3章 方法和作用域 48
3.1 创建方法 48
3.1.1 声明方法 48
3.1.2 从方法返回数据 49
3.1.3 使用表达式主体方法
50
3.1.4 调用方法 51
3.2 使用作用域 53
3.2.1 定义局部作用域 54
3.2.2 定义类作用域 54
3.2.3 重载方法 55
3.3 编写方法 56
3.4 使用可选参数和具名参数
63
3.4.1 定义可选参数 64
3.4.2 传递具名参数 64
3.4.3 消除可选参数和具名参数的
歧义 65
小结 69
第3章快速参考 70
第4章 使用判断语句 72
4.1 声明布尔变量 72
4.2 使用布尔操作符 72
4.2.1 理解相等和关系操作符
73
4.2.2 理解条件逻辑操作符
73
4.2.3 短路求值 74
4.2.4 操作符的优先级和结合性
总结 74
4.3 使用if语句做出判断 75
4.3.1 理解if语句的语法 75
4.3.2 使用代码块分组语句
76
4.3.3 嵌套if语句 77
4.4 使用switch语句 82
4.4.1 理解switch语句的语法 83
4.4.2 遵守switch语句的规则 84
小结 87
第4章快速参考 87
第5章 使用复合赋值和循环语句 89
5.1 使用复合赋值操作符 89
5.2 使用while语句 90
5.3 编写for语句 94
5.4 编写do语句 96
小结 103
第5章快速参考 104
第6章 管理错误和异常 105
6.1 处理错误 105
6.2 尝试执行代码和捕捉异常
105
6.2.1 未处理的异常 107
6.2.2 使用多个catch处理程序 108
6.2.3 捕捉多个异常 108
6.2.4 传播异常 113
6.3 使用checked和unchecked整数
运算 115
6.3.1 编写checked语句 115
6.3.2 编写checked表达式 116
6.4 抛出异常 118
6.5 使用finally块 122
小结 123
第6章快速参考 124
第II部分 理解C#对象模型
第7章 创建并管理类和对象 127
7.1 理解分类 127
7.2 封装的目的 127
7.3 定义并使用类 128
7.4 控制可访问性 129
7.4.1 使用构造器 130
7.4.2 重载构造器 131
7.5 理解静态方法和数据
138
7.5.1 创建共享字段 139
7.5.2 使用const关键字创建静态
字段 140
7.5.3 理解静态类 140
7.5.4 静态using语句 140
7.5.5 匿名类 143
小结 144
第7章快速参考 144
第8章 理解值和引用 146
8.1 复制值类型的变量和类
146
8.2 理解null值和可空类型 151
8.2.1 使用可空类型 153
8.2.2 理解可空类型的属性
154
8.3 使用ref和out参数 154
8.3.1 创建ref参数 155
8.3.2 创建out参数 156
8.4 计算机内存的组织方式
158
8.5 System.Object类 160
8.6 装箱 160
8.7 拆箱 161
8.8 数据的安全转型 162
8.8.1 is操作符 163
8.8.2 as操作符 163
小结 165
第8章快速参考 165
第9章 使用枚举和结构创建值类型 167
9.1 使用枚举 167
9.1.1 声明枚举 167
9.1.2 使用枚举 167
9.1.3 选择枚举字面值
168
9.1.4 选择枚举的基础类型
169
9.2 使用结构 171
9.2.1 声明结构 173
9.2.2 理解结构和类的区别
174
9.2.3 声明结构变量 175
9.2.4 理解结构的初始化
175
9.2.5 复制结构变量 179
小结 183
第9章快速参考 183
第10章 使用数组 185
10.1 声明和创建数组 185
10.1.1 声明数组变量
185
10.1.2 创建数组实例
186
10.1.3 填充和使用数组
186
10.1.4 创建隐式类型的数组
187
10.1.5 访问单独的数组元素
188
10.1.6 遍历数组 189
10.1.7 数组作为方法参数和返回值
传递 190
10.1.8 复制数组 191
10.1.9 使用多维数组
192
10.1.10 创建交错数组
193
小结 202
第10章快速参考 202
第11章 理解参数数组 204
11.1 回顾重载 204
11.2 使用数组参数 205
11.2.1 声明参数数组
206
11.2.2 使用params
object[] 208
11.2.3 使用参数数组
209
11.3 比较参数数组和可选参数
211
小结 213
第11章快速参考 214
第12章 使用继承 215
12.1 什么是继承 215
12.2 使用继承 216
12.2.1 复习System.Object类 217
12.2.2 调用基类构造器
218
12.2.3 类的赋值 219
12.2.4 声明新方法 220
12.2.5 声明虚方法 221
12.2.6 声明重写方法
222
12.2.7 理解受保护的访问
225
12.3 理解扩展方法 230
小结 234
第12章快速参考 234
第13章 创建接口和定义抽象类 236
13.1 理解接口 236
13.1.1 定义接口 237
13.1.2 实现接口 237
13.1.3 通过接口来引用类
239
13.1.4 使用多个接口
239
13.1.5 显式实现接口
240
13.1.6 接口的限制 242
13.1.7 定义和使用接口
242
13.2 抽象类 250
13.3 密封类 252
13.3.1 密封方法 252
13.3.2 实现并使用抽象类
253
小结 258
第13章快速参考 259
第14章 使用垃圾回收和资源管理 260
14.1 对象的生存期 260
14.1.1 编写析构器 261
14.1.2 为什么要使用垃圾回收器 262
14.1.3 垃圾回收器的工作原理 264
14.1.4 慎用析构器 264
14.2 资源管理 265
14.2.1 资源清理方法
265
14.2.2 异常安全的资源清理
266
14.2.3 using语句和IDisposable
接口 266
14.2.4 从析构器中调用Dispose
方法 268
14.3 实现异常安全的资源清理
270
小结 276
第14章快速参考 277
第III部分 用C#定义可扩展类型
第15章 实现属性以访问字段 281
15.1 使用方法实现封装
281
15.2 什么是属性 283
15.2.1 使用属性 285
15.2.2 只读属性 285
15.2.3 只写属性 286
15.2.4 属性的可访问性
286
15.3 理解属性的局限性
287
15.4 在接口中声明属性
288
15.5 生成自动属性 294
15.6 用属性初始化对象
296
小结 299
第15章快速参考 300
第16章 使用索引器 302
16.1 什么是索引器 302
16.1.1 不用索引器的例子
302
16.1.2 同一个例子改用索引器 304
16.1.3 理解索引器的访问器
306
16.1.4 对比索引器和数组
306
16.2 接口中的索引器 308
16.3 在Windows应用程序中使用
索引器 309
小结 315
第16章快速参考 315
第17章 泛型概述 317
17.1 object的问题
317
17.2 泛型解决方案 320
17.2.1 对比泛型类和常规类
322
17.2.2 泛型和约束 323
17.3 创建泛型类 323
17.3.1 二叉树理论 323
17.3.2 使用泛型构造二叉树类 326
17.4 创建泛型方法 334
17.5 可变性和泛型接口
337
17.5.1 协变接口 338
17.5.2 逆变接口 340
小结 342
第17章快速参考 342
第18章 使用集合 344
18.1 什么是集合类 344
18.1.1 ListT集合类 345
18.1.2 LinkedListT集合类 347
18.1.3 QueueT集合类 349
18.1.4 StackT集合类 350
18.1.5 DictionaryTKey, TValue
集合类 351
18.1.6 SortedListTKey, TValue
集合类 352
18.1.7 HashSetT集合类 353
18.2 使用集合初始化器
355
18.3 Find方法、谓词和Lambda
表达式 356
18.4 比较数组和集合 359
小结 363
第18章快速参考 363
第19章 枚举集合 366
19.1 枚举集合中的元素
366
19.1.1 手动实现枚举器
367
19.1.2 实现IEnumerable接口 371
19.2 用迭代器实现枚举器
373
19.2.1 一个简单的迭代器
373
19.2.2 使用迭代器为TreeTItem类
定义枚举器 375
小结 377
第19章快速参考 378
第20章 分离应用程序逻辑并处理
事件 379
20.1 理解委托 379
20.1.1 .NET Framework类库的委托
例子 380
20.1.2 自动化工厂的例子
382
20.1.3 不用委托实现工厂控制
系统 382
20.1.4 用委托实现工厂控制
系统 383
20.1.5 声明和使用委托
385
20.2 Lambda表达式和委托 392
20.3 启用事件通知 393
20.3.1 声明事件 394
20.3.2 订阅事件 395
20.3.3 取消订阅事件
395
20.3.4 引发事件 395
20.4 理解用户界面事件
396
小结 403
第20章快速参考 403
第21章 使用查询表达式来查询内存
中的数据 406
21.1 什么是LINQ 406
21.2 在C#应用程序中使用LINQ 407
21.2.1 选择数据 408
21.2.2 筛选数据 411
21.2.3 排序、分组和聚合数据 411
21.2.4 联接数据 413
21.2.5 使用查询操作符
415
21.2.6 查询TreeTItem对象中的
数据 417
21.2.7 LINQ和推迟求值
422
小结 425
第21章快速参考 425
第22章 操作符重载 428
22.1 理解操作符 428
22.1.1 操作符的限制
428
22.1.2 重载的操作符
429
22.1.3 创建对称操作符
430
22.2 理解复合赋值 432
22.3 声明递增和递减操作符
433
22.4 比较结构和类中的操作符
434
22.5 定义成对的操作符
434
22.6 实现操作符 435
22.7 理解转换操作符 441
22.7.1 提供内建转换
441
22.7.2 实现用户自定义的转换
操作符 442
22.7.3 再论创建对称操作符
443
22.7.4 添加隐式转换操作符
444
小结 446
第22章快速参考 446
第IV部分 用C#构建UWP应用
第23章 使用任务提高吞吐量 451
23.1 使用并行处理执行多任务处理 451
23.2 用.NET Framework实现多任务
处理 452
23.2.1 任务、线程和线程池
453
23.2.2 创建、运行和控制任务 454
23.2.3 使用Task类实现并行处理 457
23.2.4 使用Parallel类对任务进行
抽象 467
23.2.5 什么时候不要使用
Parallel类 471
23.3 取消任务和处理异常
473
23.3.1 协作式取消的原理
473
23.3.2 为Canceled和Faulted任务
使用延续 485
小结 485
第23章快速参考 486
第24章 通过异步操作提高响应速度 489
24.1 实现异步方法 490
24.1.1 定义异步方法:问题
490
24.1.2 定义异步方法:解决方案 492
24.1.3 定义返回值的异步方法 497
24.1.4 异步方法注意事项
498
24.1.5 异步方法和Windows
Runtime API 499
24.2 用PLINQ进行并行数据访问 502
24.2.1 用PLINQ增强遍历集合时的
性能 502
24.2.2 取消PLINQ查询 506
24.3 同步对数据的并发访问
506
24.3.1 锁定数据 509
24.3.2 用于协调任务的同步基元 510
24.3.3 取消同步 512
24.3.4 并发集合类 512
24.3.5 使用并发集合和锁实现线程
安全的数据访问 513
小结 522
第24章快速参考 522
第25章 实现UWP应用的用户界面 525
25.1 UWP应用的特点
526
25.2 使用空白模板构建UWP应用 528
25.2.1 实现可伸缩的用户界面 530
25.2.2 向用户界面应用样式
556
小结 565
第25章快速参考 566
第26章 在UWP应用中显示和搜索
数据 567
26.1 实现Model-View-ViewModel
模式 567
26.1.1 通过数据绑定显示数据 568
26.1.2 通过数据绑定修改数据 573
26.1.3 为ComboBox控件使用数据
绑定 577
26.1.4 创建ViewModel
579
26.1.5 向ViewModel添加命令 583
26.2 用Cortana搜索数据 592
小结 606
第26章快速参考 606
第27章 在UWP应用中访问远程
数据库 608
27.1 从数据库获取数据
608
27.1.1 创建实体模型
613
27.1.2 创建和使用REST
Web
服务 620
27.2 通过REST Web服务插入、更新
和删除数据 634
小结 651
第27章快速参考 651
译者后记 653
內容試閱
第I部分
Visual C#和Visual Studio 2015概述
这是本书的概述部分,介绍C#语言的基础知识,展示如何开始用Visual Studio 2015构建应用程序。
第I部分要学习如何在Visual Studio中新建项目、声明变量、用操作符创建值、调用方法以及写许多语句来实现C#程序。还要学习如何处理异常,以及如何使用Visual Studio调试器调试代码,找出可能妨碍应用程序正常工作的问题。





第1章 欢迎进入C#编程世界
学习目标:
l
使用Microsoft
Visual Studio 2015编程环境
l 创建C#控制台应用程序
l 理解命名空间的作用
l 创建一个简单的C#图形应用程序
本章是Visual
Studio 2015入门指引。Visual Studio 2015是Windows应用程序理想的编程环境。它提供了丰富的工具集,是写C#代码的好帮手。本书将循序渐进解释它的众多功能。本章用Visual Studio 2015构建简单C#应用程序,为开发高级Windows解决方案做好铺垫。
1.1 开始在Visual Studio 2015环境中编程
Visual Studio 2015编程环境提供了丰富的工具,能创建从小到大、在Windows上运行的C#项目。在创建的项目中,甚至能无缝合并用不同语言比如C ,Visual Basic和F#写的模块。第一个练习是启动Visual Studio 2015并学习如何创建一个控制台应用程序。

注意 控制台应用程序是在命令提示符窗口而非图形用户界面GUI中运行的应用程序。


在Visual Studio 2015中创建控制台应用程序

1. 单击开始,输入Visual Studio 2015并按Enter键。
将启动Visual Studio 2015并显示如下图所示的起始页取决于所用的Visual Studio 2015版本,你的起始页可能不同。


注意 首次运行Visual Studio 2015会出现对话框,提示选择默认开发环境设置。Visual Studio 2015根据首选开发语言自动调整。集成开发环境Integrated Development
Environment,IDE的各个对话框和工具将根据所选的语言创建默认设置。请从开始设置列表中选择Visual C#并单击启动Visual Studio。稍候片刻就会出现Visual Studio 2015 IDE。

2. 在文件菜单中选择新建|项目。
将出现新建项目对话框。对话框列出了一些模板。这些模板是构建应用程序的起点。模板按语言和应用程序类型进行分类。


3. 在左侧窗格展开已安装节点,展开模板,单击Visual C#。在中间窗格,验证顶部组合框显示的是.NET Framework 4.6,单击控制台应用程序。
4. 在位置文本框中输入C:\Users\YourName\Documents\Microsoft
Press\VCSBS\Chapter 1。将YourName替换成具体的Windows用户名单击Windows开始按钮最顶部显示的名称。

注意 为节省篇幅,以后将路径C:\Users\YourName\Documents简称为文档文件夹。



提示 如果指定的文件夹不存在,Visual Studio 2015将自动创建。

5. 在名称文本框中输入TestHello覆盖默认名称ConsoleApplication1。
6. 确定已勾选为解决方案创建目录复选框,单击确定按钮。
Visual Studio将使用控制台应用程序模板创建项目。如果出现以下对话框询问源码控制系统,表明你忘记清除添加到源代码管理复选框。请单击取消,从而在不使用源代码控制的情况下创建项目。

Windows将显示项目初始代码,如下图所示。

可利用屏幕顶部的菜单栏访问编程环境提供的各项功能。和其他所有Windows程序一样,菜单和命令可通过键盘或鼠标访问。菜单栏下方是工具栏,提供了一系列快捷按钮,用于执行最常用的命令。
占据IDE大部分的代码和文本编辑器窗口显示了源代码文件的内容。编辑含有多个文件的项目时,每个源文件都有自己的标签,标签显示的是文件名。单击标签,即可在代码和文本编辑器中显示对应的源文件。
最右侧是解决方案资源管理器,如下图所示。

解决方案资源管理器显示了项目相关文件的名称以及其他内容。双击文件名即可在代码和文本编辑器中显示该文件的内容。
写代码之前,先了解一下解决方案资源管理器列出的文件,它们是作为项目的一部分由Visual Studio 2015创建的。
l
解决方案TestHello 解决方案文件位于最顶级。每个应用程序都包含单个解决方案文件。解决方案则可包含一个或多个项目,Visual Studio 2015利用该解决方案文件对项目进行组织。在文件资源管理器中查看文档文件夹下的Microsoft Press\VCSBS\Chapter
1\TestHello文件夹,会发现该文件的实际名称是TestHello.sln。
l
TestHello 这是C#项目文件。每个项目文件都引用一个或多个包含项目源代码以及其他内容比如图片的文件。一个项目的所有源代码都必须使用相同的编程语言。在文件资源管理器中,该文件的实际名称是TestHello.csproj,保存在文档文件夹下的Microsoft Press\VCSBS\Chapter 1\ TestHello\TestHello子文件夹中。
l
Properties 这是TestHello项目中的一个文件夹。展开会发现AssemblyInfo.cs文件。AssemblyInfo.cs是用于为程序添加特性attribute的特殊文件,比如作者姓名和写程序的日期等。还可利用特性修改程序运行方式。具体如何使用这些特性超出了本书范围。
l 引用 该文件夹包含对已编译好的代码库的引用。C#代码编译时会转换成库,并获得唯一名称。Microsoft .NET Framework将这种库称为程序集assembly。开发人员利用程序集打包自己开发的有用功能,并分发给其他程序员,以便他们在自己的程序中使用。展开引用文件夹会看到Visual Studio 2015在项目中添加的一组默认程序集引用。利用这些程序集可访问.NET Framework的大量常用功能。本书将通过练习帮助你熟悉这些程序集。
l App.config 应用程序配置文件。由于是可选的,所以并非肯定存在该文件。可在其中指定设置,让应用程序在运行时修改其行为,比如修改运行应用程序的.NET Framework版本。以后将更深入地探讨该文件。
l
Program.cs C#源代码文件。项目最初创建时,代码和文本编辑器显示的就是该文件,稍后要在该文件中为控制台应用程序编写代码。它包含Visual Studio 2015自动生成的一些代码,稍后将详细讨论。
1.2 写第一个程序
Program.cs文件定义了Program类,其中包含Main方法。C#的所有可执行代码都必须在方法中定义,而方法必须从属于类或结构。将在第7章讨论类,在第9章讨论结构。
Main方法指定程序入口。必须像本例的Program类那样把它定义成静态方法,否则应用程序运行时,.NET Framework可能不把它视为起点。将在第3章讨论方法,在第7章讨论静态方法。

重要提示 C#区分大小写。Main首字母必须大写。

后面的练习将写一些代码在控制台中显示消息Hello World!,将生成并运行这个Hello
World控制台应用程序,并学习如何使用命名空间对代码元素进行分区。

利用智能感知IntelliSense写代码

1. 在显示了Program.cs文件的代码和文本编辑器中,将光标定位到Main方法的左大括号{后面,按Enter键另起一行。
2. 在新行中键入单词Console,这是由应用程序引用的程序集提供的一个类。Console类提供了在控制台窗口中显示消息和读取键盘输入的方法。
键入单词Console的首字母C会显示智能感知列表。其中包含当前上下文有效的所有C#关键字和数据类型。可继续键入其他字母,也可在列表中滚动并用鼠标双击Console项。还有一个办法是,一旦键入Cons,智能感知列表就会自动定位到Console这一项,此时按Tab键或Enter键即可选中并输入它。

现在的Main方法如下所示:

static void Mainstring[] args
{
Console
}


注意 Console是内建的类。

3. 紧接着单词Console输入句点。随后会出现另一个智能感知列表,其中显示了Console类的方法、属性和字段。
4. 在列表中向下滚动,选中WriteLine并按Enter键。也继续输入字符W,r,i,t,e,L,直到WriteLine被自动选定再按Enter键。
随后,智能感知列表关闭,WriteLine方法添加到源代码文件中。现在的Main方法如下所示:

static void Mainstring[]
args
{

Console.WriteLine
}
5. 输入起始圆括号。随后出现智能感知提示。
其中显示了WriteLine方法支持的参数。WriteLine是重载方法。换言之,Console类包含多个名为WriteLine的方法,实际上有19个之多。可用WriteLine方法的不同版本输出不同类型的数据将在第3章讨论重载方法。现在的Main方法如下所示:

static void Mainstring[]
args
{

Console.WriteLine
}


提示 单击上下箭头或者按上下键切换WriteLine的不同重载版本。

6. 输入结束圆括号,再加一个分号。现在的Main方法如下所示:

static void Mainstring[]
args
{

Console.WriteLine;
}
7. 移动光标,在WriteLine后面的圆括号中输入字符串"Hello World!",引号也包括在内。现在的Main方法如下所示:

static void Mainstring[]
args
{

Console.WriteLine"Hello World!";
}


提示 好习惯是先连续输入一对匹配的字符,例如和以及{和},再在其中填写内容。先填写内容容易忘记输入结束字符。






















智能感知图标
在类名后输入句点,智能感知将显示类的每个成员的名称。每个成员名称左侧有一个指示成员类型的图标。下表总结了图标及其代表的类型。






图标


含义







方法第3章







属性第15章







类第7章







结构第9章







枚举第9章







扩展方法第12章







接口第13章







委托第17章







事件 第17章







命名空间本章下一节





在不同上下文中输入代码,可能看到其他智能感知图标。

一些代码包含两个正斜杠,后跟一些文本,这称为注释。它们会被编译器忽略,但对开发人员来说非常有用,因为可以用注释来记录代码实际采取的操作。例如:

Console.ReadLine; 等待用户按Enter键
从两个正斜杠到行末的所有文本都被编译器忽略。也可用*添加多行注释。编译器将跳过它之后的一切内容,直到遇到*可能出现在多行之后。建议尽量使用详细的注释对自己的代码进行编档。

生成并运行控制台应用程序

1. 在生成菜单中,选择生成解决方案。
这样会编译C#代码并生成可运行的程序。在代码和文本编辑器下方会显示输出窗口。

提示 如果输出窗口没有出现,请在视图菜单中选择输出。

输出窗口显示如下所示的消息,告诉你程序的编译过程。

1------ 已启动生成: 项目: TestHello, 配置: Debug Any
CPU ------
1
TestHello - C:\Users\zj2012\Documents\Microsoft Press\VCSBSChapter
1\TestHello\TestHello\bin\Debug\TestHello.exe
========== 生成: 成功 1 个,失败 0 个,最新 0 个,跳过 0 个 ==========
程序错误在错误列表窗口中显示。下图显示了忘记在WriteLine语句的Hello World!文本后输入结束引号的后果。注意,一个错误有时可能导致多个编译错误。



提示 在错误列表窗口中双击错误,光标会移到导致错误的代码行。另外,输入一行不能编译的代码,Visual Studio会在其下方显示一条红色波浪线。

仔细按前面的步骤操作,就不应出现任何错误或警告,程序应成功生成。

提示 生成前不必存盘,生成解决方案命令会自动存盘。在代码和文本编辑器的标签中,文件名后的星号表明自上次存盘以来文件内容已被修改。

2. 在调试菜单中,选择开始执行不调试。
随即打开命令窗口,程序开始运行。显示Hello World!消息,程序等待用户按任意键继续如下图所示。



注意 请按任意键继续提示由Visual Studio自动生成,不必专门为此写代码。如果使用调试菜单中的开始调试命令运行程序,应用程序也会运行,但命令窗口在显示Hello World!后立即关闭,不会停下来等着按键。

3. 确认当前焦点是这个命令窗口,按Enter键或其他任意键。
命令窗口关闭,并返回Visual
Studio。
4. 在解决方案资源管理器中单击TestHello项目而不是解决方案,然后单击解决方案资源管理器工具栏中的显示所有文件按钮如下图所示。如果看不到该按钮,单击按钮找到它。

随后,Program.cs文件的上方会显示bin和obj。这两项直接对应于项目文件夹\Microsoft Press\VCSBS\Chapter 1\TestHello\TestHello中的bin和obj文件夹。这些文件夹在生成应用程序时由Visual Studio创建,包含应用程序的可执行版本,以及用于生成和调试应用程序的其他文件。
5. 在解决方案资源管理器中展开bin文件夹。
随后显示另一个名为Debug的文件夹。

注意 也许还会看到一个名为Release的文件夹。

6. 在解决方案资源管理器中展开Debug文件夹。
随后显示更多子项,其中TestHello.exe是编译好的程序。在调试菜单中选择开始执行不调试运行的就是它。其他文件包含用调试模式运行程序在调试菜单中选择开始调试时要由Visual
Studio 2015使用的信息。
1.3 使用命名空间
前面的例子只是很小的程序,但小程序可能很快变成大程序。程序规模扩大带来两个问题。首先,代码越多,就越难理解和维护。其次,更多代码通常意味着更多类和方法,要求你跟踪更多名称。随着名称越来越多,极有可能因为两个或多个名称冲突而造成项目无法生成。例如,可能试图创建两个同名的类。如果程序引用了其他开发人员写的程序集,后者同样使用了大量名称,这个问题将变得更严重。
过去,程序员通过为名称添加某种形式的限定符前缀来解决名称冲突问题。但这并不是好的方案,因为它不具扩展性。名称变长后,打字时间就增多了,还要花更多时间来反复阅读令人费解的长名字,真正花在写软件上的时间就少了。
命名空间namespace可解决这个问题,它为类这样的项创建容器。同名类在不同命名空间中不会混淆。可用namespace关键字在TestHello命名空间中创建Greeting类,如下所示:

namespace TestHello
{

class Greeting

{

...

}
}
然后在自己的程序中使用TestHello.Greeting引用Greeting
类。如果有人在不同命名空间例如NewNamespace中也创建了Greeting类,并把它安装到你的机器上,你的程序仍能正常工作,因为程序使用的是TestHello.Greeting类。另一名开发者的Greeting类要用NewNamespace.Greeting进行引用。
作为好习惯,所有类都应该在命名空间中定义,Visual Studio 2015环境默认使用项目名称作为顶级命名空间。.NET Framework类库FCL也遵循这个约定,它的每个类都在一个命名空间中。例如,Console类在System命名空间中。这意味着它的全名实际是System.Console。
当然,如果每次都必须写类的全名,似乎还不如添加限定符前缀,或者就用SystemConsole之类的全局唯一名称来命名类。幸好,可在程序中使用using指令解决该问题。返回Visual Studio 2015中的TestHello程序,观察代码和文本编辑器窗口中的Program.cs文件,会注意到文件顶部的以下语句:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
这些是using指令,用于将某个命名空间引入作用域。同一文件的后续代码不再需要用命名空间限定对象。由于这5个命名空间包含的类很常用,所以每次新建项目,Visual Studio 2015都自动添加这些using指令。可在源代码文件的顶部添加更多using指令。
以下练习演示了命名空间的概念。

使用完全限定名称

1. 在代码和文本编辑器窗口中注释掉Program.cs文件顶部第一个using指令:

using System;
2. 在生成菜单中,选择生成解决方案。
生成失败,错误列表窗口显示以下错误信息:

当前上下文中不存在名称"Console"
3. 在错误列表窗口中双击错误消息。
在Program.cs源代码文件中,导致错误的标识符将添加红色波浪线。
4. 在代码和文本编辑器窗口中编辑Main方法以使用完全限定名称,即System.Console。Main方法现在如下所示:

static void Mainstring[]
args
{

System.Console.WriteLine"Hello World!";
}

注意 在System后键入句点时,智能感知列表将显示System命名空间中的所有项的名称。

5. 在生成菜单中,选择生成解决方案。
项目应成功生成。否则请核实Main的代码是否与上述代码完全一致并重试。
6. 在调试菜单中选择开始执行不调试命令来运行应用程序,确定它仍能正常工作。
7. 程序运行并显示Hello World!,在控制台窗口中按Enter键返回Visual Studio。
命名空间和程序集
using将某个命名空间的项引入作用域,这样在代码中就不必对类名进行完全限定。类编译到程序集中。程序集通常是.dll文件。但严格地说,.exe可执行文件也是程序集。
一个程序集可包含许多类。构成.NET Framework类库的那些类比如System.Console是在和Visual Studio一起安装的程序集中提供的。.NET Framework类库包含数量众多的类。如果都放到同一个程序集中,这个程序集必将变得过于臃肿,很难管理。想象一下,假如Microsoft更新了一个类中的一个方法,就必须将整个类库分发给所有开发人员。
因此,.NET Framework类库被分解成多个程序集,具体按其中包含的类的功能加以划分。例如,核心程序集mscorlib.dll包含所有常用类,System.Console便是其中之一。另外还有其他许多程序集,它们包含的类分别用于处理数据库、访问Web服务以及构建GUI等。要使用某个程序集中的类,必须在项目中添加对该程序集的引用,还要在代码中添加using语句,指定使用该程序集中的某个命名空间中的项。
注意,程序集和命名空间并非肯定一对一。程序集中可能包含多个命名空间的类,而一个命名空间可能跨越多个程序集。这点最初会让人觉得困惑,但习惯之后就好了。
使用Visual Studio新建应用程序时,所选的模板自动包含对适当程序集的引用。例如在TestHello项目的解决方案资源管理器中展开引用文件夹,会发现控制台应用程序自动包含对Microsoft.CSharp,System,System.Core,System.Data,System.Data.DataSetExtensions,System.Net.Http,System.Xml和System.Xml.Linq等程序集的引用。核心库mscorlib.dll之所以没有包含在其中,是因为所有.NET Framework应用程序必须使用它因其包含最基本的运行时功能。引用文件夹只列出可选程序集,可根据需要在此文件夹中增删程序集。
要添加对其他程序集的引用,右击引用文件夹并选择添加引用。稍后的练习将执行这个任务。要删除程序集,右击并选择删除命令即可。
1.4 创建图形应用程序
前面使用Visual
Studio 2015创建并运行了一个基本的控制台应用程序。Visual Studio 2015编程环境还包含创建Windows 10图形应用程序所需的一切。这些模板称为通用Windows平台Universal Windows Platform,UWP,因其创建的应用能在所有Windows设备上运行,比如台式机、平板和手机。可交互式设计Windows应用程序的用户界面UI。Visual Studio 2015自动生成代码来实现界面。
Visual Studio 2015允许用两个视图查看图形应用程序:设计视图和代码视图。可在代码和文本编辑器窗口中修改和维护图形应用程序的代码和逻辑;设计视图窗口则用于布置图形用户界面。两个视图可自由切换。
以下练习演示如何使用Visual
Studio 2015创建图形应用程序。程序显示一个简单窗体。其中有用于输入姓名的文本框,还有一个按钮,单击按钮弹出一个消息框来显示个性化的欢迎辞。
关于具体如何开发UWP应用,第IV部分最后几章提供了更多的细节和指引。

在Visual Studio 2015中创建图形应用程序

1. 如果Visual
Studio 2015 尚未运行,就启动它。
2. 选择文件|新建|项目。
随后出现新建项目对话框。
3. 在左侧窗格展开已安装|模板|Visual C#|Windows|通用。如果没有安装,就选择UAF,并在中间窗格选择安装通用Windows工具。单击确定并按提示安装。
4.
在中间窗格单击空白应用通用Windows图标。

注意 XAML全称是Extensible Application Markup Language,即可扩展应用程序标记语言,通用Windows平台应用通过它定义GUI布局。通过本书的练习会学到更多XAML相关知识。

5.
确定位置文本框内填写的是你的文档文件夹中的\Microsoft Press\VCSBS\Chapter 1子文件夹。
6. 在名称文本框中输入Hello。
7. 确定已勾选为解决方案创建目录,单击确定。
首次创建UWP应用会提示启用Windows 10开发人员模式如下图所示。取决于Windows 10设备和版本,也许能也许不能通过用户界面启用开发人员模式。请访问https:msdn.microsoft.comlibrarywindowsappsxamldn706236.aspx进一步了解如何启用开发人员模式。



注意 该对话框可能在新建UWP应用或者在Visual Studio中首次运行一个UWP应用时出现。

8. 创建好应用之后,看一下解决方案资源管理器。
不要被模板名称给骗了。虽然叫空白应用程序,但该模板实际提供了大量文件,并包含数量可观的代码。例如,展开MainPage.xaml文件夹,会发现名为MainPage.xaml.cs的C#文件。你的代码将添加于此。加载了MainPage.xaml文件所定义的UI后,就会开始运行这些代码。
9. 在解决方案资源管理器中双击MainPage.xaml。
该文件包含UI布局。如下图所示,设计视图显示了该文件的两种形式。

顶部默认是模拟的5英寸手机屏幕。底部是屏幕内容的XAML描述。XAML类似于XML。UWP应用通过它定义窗体布局和内容。会用XML,XAML也不难。
下个练习将在设计视图中添加3个控件。还要探讨Visual Studio 2015实现这些控件时自动生成的C#代码。

提示 关闭输出和错误列表窗口,腾出更多的空间来显示设计视图。



注意 有必要澄清一下术语。在传统Windows应用程序中,UI由一个或多个窗口构成,而在通用Windows平台应用中,对应术语是页或页面page。为简洁起见,本书用窗体form统称两者。但是,仍然用窗口window一词指代Visual Studio 2015开发环境的界面元素,比如设计视图窗口。


创建用户界面

1. 单击设计视图左侧的工具箱标签。
随后出现工具箱,显示了可放到窗体上的各种组件和控件。
2. 展开常用XAML控件区域。
该区域显示了大多数图形应用程序都要使用的控件。

提示 所有XAML控件区域显示了更完整的控件列表。

3. 在常用XAML控件区域单击TextBlock,将TextBlock控件拖放到设计视图显示的窗体。

提示 确定选择的是TextBlock控件而非TextBox控件。如果将错误的控件拖放到窗体,单击它并按Delete键即可删除。

这样便在窗体上添加了一个TextBlock控件稍后要把它移到正确位置。工具箱从视图中消失。

提示 如果希望工具箱始终可见,同时不想它遮住窗体的任何部分,可以单击工具箱标题栏右侧的自动隐藏按钮看起来像一枚图钉。这样工具箱将固定在Visual Studio 2015窗口左侧,设计视图会相应收缩,以适应新的窗口布局。但是,如果屏幕分辨率较低,这样可能会损失不少空间。再次单击自动隐藏按钮,工具箱将再次消失。

4. 窗体上的TextBlock控件可能不在理想的地方。可以单击并拖动来重新定位。把TextBlock控件定位到窗体左上角本例不要求特别精准。注意,可能要先在控件外点击,再重新单击它,才能在设计视图中移动。
在底部窗格中,窗体的XAML描述现在包含了TextBlock控件及其属性。其中,Margin属性指定位置,Text属性指定控件上显示的默认文本,HorizontalAlignment和VerticalAlignment属性指定这些文本的对齐方式,TextWrapping属性指定这些文本是否自动换行。
TextBlock的XAML代码如下所示你的Margin属性值会有所区别,具体取决于控件在表单上的位置。

TextBlock
x:Name="textBlock" HorizontalAlignment="Left"
Margin="10,10,0,0"
TextWrapping="Wrap"
Text="TextBlock" VerticalAlignment="Top"
XAML窗格和设计视图相互影响。也可在XAML窗格中编辑值,更改会在设计视图中反映。例如,可直接修改Margin属性值来改变TextBlock控件的位置。
5. 在视图菜单中选择属性窗口。
属性窗口会出现在屏幕右下角,位于解决方案资源管理器的下方。可以利用设计视图下方的XAML窗格来编辑控件属性,但属性窗口提供了一种更简便的方式来修改窗体上的各个项以及程序项目中的其他项的属性。
属性窗口上下文关联;换言之,它总是显示当前选定项的属性。单击窗体任意位置TextBlock控件除外,属性窗口将显示Grid元素的属性。观察XAML窗格,会发现TextBlock控件包含在Grid元素中。所有窗体都包含一个Grid元素,它控制要显示的各个项的布局。例如,可在Grid上添加行和列来定义表格布局。
6. 单击窗体上的TextBlock控件,属性窗口显示它的属性。
7. 在属性窗口中展开文本。如下图所示,将FontSize属性更改为20 pt,然后按Enter键。该属性在字体名称下拉列表框旁边。



注意 pt后缀表明字号单位是磅,1磅等于172英寸。

8. 在设计视图底部的XAML窗格中,检查TextBlock控件的定义代码。滚动到行末,会看到FontSize="26.667"。这是磅换算成像素之后的约值3磅大致等于4像素,但精确换算取决于你的屏幕大小和分辨率。在属性窗口中进行的任何更改都自动反映到XAML定义中,反之亦然。
在XAML窗格中将FontSize属性值更改为24。注意,在设计视图和属性窗口中,TextBlock文本字号都会改变。
9. 在属性窗口中检查TextBlock控件的其他属性。随便修改以体验效果。注意发生更改的属性会添加到XAML窗格的TextBlock定义中。添加到窗体的每个控件都有一组默认属性。除非值被更改,否则在XAML窗格中不显示。
10. 将TextBlock控件的Text属性从默认的TextBlock更改为Please enter your name。可直接在XAML窗格中编辑Text属性,也可在属性窗口中编辑该属性在公共区域。注意,在设计视图中,TextBlock控件的文本相应地改变。
11. 在设计视图中单击窗体的空白区域。
12. 从工具箱将一个TextBox控件拖放到窗体上,移至TextBlock控件下方。

注意 在窗体上拖动控件时,假如控件与其他控件在水平和垂直方向对齐,就会自动显示对齐线。可据此判断控件是否对齐。

13.
在设计视图中,将鼠标放到TextBox控件右侧边线。指针应变成双向箭头,表明现在能更改控件大小。拖动边线,直到和上方的TextBlock控件右侧边线对齐。两个边线对齐会自动显示指示线。
14. 在选定TextBox控件的前提下,在属性窗口的顶部,将Name属性的值从textBox更改为userName,如下图所示。



注意 第2章会详细讲解控件和变量的命名约定。

15. 再次打开工具箱,将一个Button控件拖放到窗体,定位到TextBox右侧,使按钮和文本框的底部水平对齐。
16. 使用属性窗口,将Button控件的Name属性更改为ok,将Content属性在公共区域更改为OK。验证窗体上的按钮文本相应地发生了变化。
现在的窗体如下图所示。



注意 可利用设计视图左上角的下拉列表观察窗体在不同屏幕大小和分辨率下的渲染情况。本例的默认视图是分辨率为1920 x 1080的5英寸手机屏幕。可利用下拉列表右侧的两个按钮切换横向和纵向视图。本书以后的项目会使用13.3英寸桌面视图作为设计平面。

17. 在生成菜单中选择生成解决方案,验证项目成功生成。
18. 如下图所示,确定调试目标下拉列表选定的是本地计算机。可能默认是设备并试图连接Windows手机设备,导致生成失败。然后在调试菜单中选择开始调试。

应用程序将运行并显示窗体,如下图所示。



注意 以调试模式运行通用Windows平台应用,屏幕左上角会显示两组数字。它们代表应用程序的帧频,开发人员可根据它们判断应用程序在什么时候响应变得不如平常灵敏表明可能存在性能问题。帧频仅在调试模式中出现。对这些数字的完整描述超出了本书的范围,暂时可以忽略它们。

可在文本框中删除TextBox字样,输入自己的名字,然后单击OK按钮。但目前什么都不会发生。还要添加代码处理单击OK按钮之后所发生的事情,这是下一步的任务。
19. 返回Visual Studio 2015,在调试菜单中单击停止调试。还可单击窗体右上角的X按钮来关闭窗体、停止调试并返回Visual Studio。
没写一行代码就成功创建了一个图形应用程序。现在,这个程序还没有多大用处很快就要自己写代码了,但Visual Studio 2015实际已经自动生成了大量代码,这些代码执行所有图形应用程序都必须执行的常规任务,例如启动和显示窗口。写自己的代码之前,有必要知道Visual Studio自动生成了哪些代码。
1.4.1 探索通用Windows平台应用程序
在解决方案资源管理器中展开MainPage.xaml节点。双击MainPage.xaml.cs文件,窗体的代码就会出现在代码和文本编辑窗口中,如下所示:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using
Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

空白页项模板在
http:go.microsoft.comfwlink?LinkId=402352clcid=0x409 上有介绍

namespace Hello
{

summary

可用于自身或导航至 Frame 内部的空白页

summary

public sealed partial class MainPage : Page

{

public MainPage

{

this.InitializeComponent;

}

}
}
除了大量using指令用于引入大多数UWP应用都要用到的命名空间,文件还包含MainPage类的定义,但别的就没有什么了。MainPage类包含一个构造器来调用InitializeComponent方法。构造器是和类同名的特殊方法,在创建类的实例时执行,包含用于初始化实例的代码。第7章将详细介绍构造器。
类包含的代码实际比MainPage.xaml.cs显示的多得多。但大多数代码都是根据窗体的XAML描述来自动生成的,已自动隐藏。这些代码执行的操作包括创建和显示窗体,以及创建和定位窗体上的各个控件等。

提示 显示设计视图时,可从视图菜单选择代码或者按功能键F7,立即查看该页的C#代码。

你可能会想,Main方法去哪里了?应用程序运行时,窗体如何显示?控制台应用程序是由Main定义程序入口。图形应用程序则稍有不同。
在解决方案资源管理器中,还会注意到另一个源代码文件,即App.xaml。展开该文件的节点会看到App.xaml.cs文件。在UWP应用中,App.xaml文件提供了应用程序的入口。双击App.xaml.cs会看到如下所示的代码。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using
System.Runtime.InteropServices.WindowsRuntime;
using Windows.ApplicationModel;
using
Windows.ApplicationModel.Activation;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using
Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

namespace Hello
{

summary

提供特定于应用程序的行为,以补充默认的应用程序类。

summary

sealed partial class App : Application

{

summary

初始化单实例应用程序对象。这是执行的创作代码的第一行,

逻辑上等同于 main 或 WinMain。

summary

public App

{

Microsoft.ApplicationInsights.WindowsAppInitializer.InitializeAsync

Microsoft.ApplicationInsights.WindowsCollectors.Metadata |

Microsoft.ApplicationInsights.WindowsCollectors.Session;
this.InitializeComponent;
this.Suspending = OnSuspending;

}


summary

在应用程序由最终用户正常启动时进行调用。

将在启动应用程序以打开特定文件等情况下使用。

summary

param name="e"有关启动请求和过程的详细信息。param
protected override void
OnLaunchedLaunchActivatedEventArgs e
{

#if DEBUG
if System.Diagnostics.Debugger.IsAttached
{

this.DebugSettings.EnableFrameRateCounter = true;
}
#endif

Frame rootFrame =
Window.Current.Content as Frame;

不要在窗口已包含内容时重复应用程序初始化,
只需确保窗口处于活动状态
if rootFrame == null
{
创建要充当导航上下文的框架,并导航到第一页
rootFrame = new Frame;

rootFrame.NavigationFailed =
OnNavigationFailed;

if e.PreviousExecutionState ==
ApplicationExecutionState.Terminated
{
TODO: 从之前挂起的应用程序加载状态
}

将框架放在当前窗口中
Window.Current.Content =
rootFrame;
}

if rootFrame.Content == null
{
当导航堆栈尚未还原时,导航到第一页,
并通过将所需信息作为导航参数传入来配置
参数

rootFrame.NavigatetypeofMainPage, e.Arguments;
}
确保当前窗口处于活动状态
Window.Current.Activate;
}


summary

导航到特定页失败时调用

summary

param name="sender"导航失败的框架param

param name="e"有关导航失败的详细信息param

void OnNavigationFailedobject sender, NavigationFailedEventArgs e

{
throw new Exception"Failed to
load Page " e.SourcePageType.FullName;

}


summary

在将要挂起应用程序执行时调用。 在不知道应用程序

无需知道应用程序会被终止还是会恢复,

并让内存内容保持不变。

summary

param name="sender"挂起的请求的源。param

param name="e"有关挂起请求的详细信息。param

private void OnSuspendingobject sender, SuspendingEventArgs e

{
var deferral =
e.SuspendingOperation.GetDeferral;
TODO: 保存应用程序状态并停止任何后台活动
deferral.Complete;

}

}
}
以上代码大多数都是注释以开头,其他语句现在不需要理解。最关键的是加粗的OnLaunched方法。该方法在应用程序启动时运行,它的代码导致应用程序新建一个Frame对象,在这个frame中显示MainPage窗体并激活它。目前不要求掌握代码具体如何工作以及具体的语法,只需记住它决定着应用程序启动时如何显示窗体。
1.4.2 向图形应用程序添加代码
了解图形应用程序的结构之后,接着写代码让程序干点儿实事。

为OK按钮写代码

1. 在解决方案资源管理器中双击MainPage.xaml在设计视图中打开。
2. 在设计视图中单击OK按钮选定它。
3. 如下图所示,在属性窗口中单击选定元素的事件处理程序按钮闪电图标。

属性窗口显示Button控件的事件列表。自己写代码来响应某个事件。
4. 在Click事件旁边的文本框中输入okClick,按Enter键。
将打开MainPage.xaml.cs,并在MainPage类中自动添加okClick方法,如下所示。

private
void okClickobject sender, RoutedEventArgs e
{
}
现在不理解代码的语法没有关系,第3章会详细讲解。
5. 在文件顶部添加以下加粗的using语句,省略号代表省略的语句。

using System;
...
using
Windows.UI.Xaml.Navigation;
using
Windows.UI.Popups;
6. 在okClick方法中添加以下加粗的代码。

void
okClickobject sender, RoutedEventArgs e
{
MessageDialog msg = new
MessageDialog"Hello " userName.Text;
msg.ShowAsync;
}
单击OK按钮将运行上述代码。同样,语法目前无需深究只需确定输入的和显示的一致,具体将在接着的几章学习。只需理解第一个语句创建MessageDialog对象,向它传递消息Hello YourName,其中YourName是你在TextBox中输入的姓名。第二个语句实际显示该MessageDialog,使它在屏幕上出现。MessageDialog类在Windows.UI.Popups命名空间中定义,所以才要在步骤5添加它。

注意 Visual Studio 2015在刚才键入的最后一行代码下方添加了绿色波浪线。鼠标移到上方,会显示警告消息:由于此调用不会等待,因此在此调用完成之前将会继续执行当前方法。请考虑将 "await" 运算符应用于调用结果。简单地说,这表明尚未充分利用.NET Framework提供的异步功能。目前可安全忽略该警告。

7. 单击窗口上方的MainPage.xaml标签重新显示设计视图。
8. 在底部的XAML描述中检查Button元素,但不要进行任何改动。注意它现在包含Click元素,该元素引用okClick方法,如下所示:

Button x:Name="ok" ... Click="okClick"

9. 在调试菜单中选择开始调试命令。
10. 在随后出现的窗体中,在文本框内输入自己的名字,然后单击OK按钮。
随后将显示一条消息来欢迎你,如下图所示。

11. 单击关闭来关闭消息框。
12. 返回Visual Studio 2015,在调试菜单中选择停止调试。
小 结
本章讲述了如何使用Visual
Studio 2015创建、生成和运行应用程序;创建了控制台应用程序,在控制台窗口中显示输出;还创建了具有简单GUI的图形应用程序。
l
如果希望继续学习下一章,请继续运行Visual Studio 2015,然后阅读第2章。
l
如果希望现在就退出Visual Studio 2015,请选择文件|退出。如果看到保存对话框,请单击是按钮保存项目。
第1章快速参考





目标


操作




使用Visual Studio
2015新建控制台应用程序


选择文件|新建|项目打开新建项目对话框。在左侧窗格展开已安装|模板|Visual C#。在中间窗格单击控制台应用程序。在位置文本框中为项目文件选择目录。输入项目名称。单击确定按钮






续表





目标


操作




使用Visual
Studio 2015新建通用Windows平台应用


选择文件|新建|项目打开新建项目对话框。在左侧窗格展开已安装|模板|Visual C#|Windows|通用。在中间窗格单击空白应用通用Windows。在位置框中为项目文件选择目录。输入项目名称。单击确定按钮




生成应用程序


选择生成|生成解决方案




以调试模式运行应用程序


选择调试|开始调试




运行应用程序而不调试


选择调试|开始运行不调试








第2章 使用变量、操作符和表达式
学习目标:
l 理解语句、标识符和关键字
l 使用变量存储信息
l 使用基元数据类型
l 使用 和-以及其他算术操作符
l 变量递增递减
第1章讲述了如何用Microsoft Visual Studio 2015编程环境生成和运行控制台应用程序和图形应用程序。本章将学习Microsoft Visual C#的语法和语义元素,包括语句、关键字和标识符;学习C#语言内建的基元数据类型以及每种类型所容纳的值的特征;学习如何声明和使用局部变量只存在于方法或其他小节内的变量;学习C#算术操作符;学习如何使用操作符来处理值;还将学习如何控制含有两个或更多操作符的表达式。
2.1 理 解 语 句
语句是执行操作的命令,如计算值,存储结果,或者向用户显示消息。我们组合各种语句来创建方法。第3章将更详细地介绍方法。目前暂时将方法视为具名的语句序列。第1章介绍过的Main就是方法的例子。
C#语句遵循良好定义的规则集。这些规则描述语句的格式和构成,统称为语法。对应地,描述语句做什么的规范统称为语义。最简单也是最重要的一个C#语法规则是:所有语句都必须以分号终止。例如,第1章演示过假如没有终止分号,以下语句不能编译:

Console.WriteLine"Hello World!";


提示
C#是自由格式语言,意味着所有空白如空格字符或换行符仅充当分隔符,除此之外毫无意义。换言之,可采取自己喜欢的任意样式安排语句布局。简单的、统一的布局样式使程序更易阅读和理解。

学好语言的窍门是先了解其语法和语义,采用自然的、符合语言习惯的方式使用语言。这会使程序变得更易理解和修改。本书为很多非常重要的C#语句提供了实际的例子。
2.2 使用标识符
标识符是对程序中的各个元素进行标识的名称。这些元素包括命名空间、类、方法和变量后面很快就会讲到变量。在C#语言中选择标识符时必须遵循以下语法规则:
l
只能使用字母大写和小写、数字和下划线
l
标识符必须以字母或下划线开头
例如,result, _score,footballTeam和plan9是有效标识符;result%,footballTeam$和9plan则不是。

重要提示 C#大小写敏感。例如,footballTeam和FootballTeam是不同的标识符。

认识关键字
C#语言保留77个标识符供自己使用,程序员不可出于自己的目的而重用这些标识符。这些标识符称为关键字,每个关键字都有特定含义。关键字的例子包括class、namespace和using等。随着本书讨论的深入,将学习大多数关键字的含义。下面列出了这些关键字。






abstract


do


in


protected


true




as


double


int


public


try




base


else


interface


readonly


typeof




bool


enum


internal


ref


uint




break


event


is


return


ulong




byte


explicit


lock


sbyte


unchecked




case


extern


long


sealed


unsafe




catch


false


namespace


short


ushort




char


finally


new


sizeof


using




checked


fixed


null


stackalloc


virtual




class


float


object


static


void




const


for


operator


string


volatile




continue


foreach


out


struct


while




decimal


goto


override


switch







default


if


params


this







delegate


implicit


private


throw










提示 C#在代码和文本编辑器窗口中,输入的关键字默认自动显示成蓝色。

C#还使用了以下标识符。这些不是C#保留关键字,可作为自己方法、变量和类的名称使用,但尽量避免这样做。

add get remove
alias global select
ascending group set
async into value
await join var
descending let where
dynamic orderby yield
from partial
2.3 使 用 变 量
变量是容纳值的一个存储位置。可将变量想象成计算机内存中容纳临时信息的容器。程序每个变量在其使用范围内都必须有无歧义名称。我们用该名称引用变量容纳的值。例如,存储商品价格可创建cost变量,并将价格存储到该变量。以后引用cost变量,获取的值就是之前存储的价格。
2.3.1 命名变量
为变量采用恰当的命名规范来避免混淆。作为开发团队的一员,这一点尤其重要。统一的命名规范有助于减少bug。下面是一些常规建议。
l
不要以下划线开头。虽然在C#中合法,但限制了和其他语言如Visual Basic的代码的互操作性。
l
不要创建仅大小写不同的标识符。例如,不要同时使用myVariable和MyVariable变量,它们很易混淆。而且在Visual Basic这样不区分大小写的语言中,类的重用性也会受限。
l
名称以小写字母开头。
l
在包含多个单词的标识符中,从第二个单词起,每个单词都首字母大写称为camelCase记号法。
l
不要使用匈牙利记号法。Microsoft Visual C 开发人员熟悉这种记号法。不明白匈牙利记号法也不必深究。
例如,score,footballTeam,_score和FootballTeam都是有效变量名,但后两个不推荐。
2.3.2 声明变量
变量容纳值。C#能存储和处理许多类型的值,包括整数、浮点数和字符串等。声明变量时,必须指定它要容纳的数据的类型。
变量类型和名称在声明语句中声明。例如,以下语句声明age变量来容纳int值。记住所有语句必须以分号终止:

int age;
int是C#基元数据类型之一后面会讲到其他基元数据类型。

注意 Visual Basic程序员注意,C#不允许隐式变量声明。所有变量在使用之前必须先进行明确声明。

变量声明好后就可以赋值。以下语句将值42赋给age。同样,最后的分号必不可少:

age = 42;
等号=是赋值操作符,作用是将右侧值赋给左侧变量。赋值后可在代码中使用名称age来引用其容纳的值。以下语句将变量age的值写到控制台:

Console.WriteLineage;

提示 在Visual Studio 2015的代码和文本编辑器窗口中,鼠标放到变量名上会提示变量类型。

2.4 使用基元数据类型
C#内建许多基元数据类型[①]。下表总结了C#最常用的基元数据类型及其取值范围。






数据类型


描述


大小位


范围


示例




int


整数


32


231~231 1


int count;
count = 42;




long


整数更大范围


64


263~2631


long wait;
wait = 42L;




float


浮点数


32


1.5 10-45~3.4 1038


float away;
away = 0.42F;




double


双精度更精确浮点数


64


5.0 10-324~1.7 10308


double
trouble;
trouble =
0.42;




decimal


货币值具有比double更高的精度和更小的范围


128


7.9 1028 ~ 7.9 1028 100~28


decimal coin;
coin = 0.42M;




string


字符序列


每字符16位


不适用


string vest;
vest = "fortytwo";




char


单字符


16


0 ~2161


char grill;
grill = ''x'';




bool


布尔值


8


true或false


bool teeth;
teeth = false;







2.4.1 未赋值的局部变量
变量声明时包含随机值,直至被明确赋值。C和C 程序的许多bug都是由于误用了未赋值变量。C#不允许使用未赋值变量。变量只有赋值后才能使用,否则程序无法编译。这就是所谓的明确赋值规则。例如,以下语句造成编译错误,因为age尚未赋值:

int age;
Console.WriteLineage; 编译错误
2.4.2 显示基元数据类型的值
以下练习使用名为PrimitiveDataTypes的C#程序演示几种基元数据类型的工作方式。

显示基元数据类型的值

1. 如果还没有运行Visual
Studio 2015,请启动它。
2. 选择文件|打开|项目解决方案。
随后将出现打开项目对话框。
3. 切换到文档文件夹下的\Microsoft Press\VCSBS\Chapter 2\PrimitiveDataTypes子文件夹。

4. 选择解决方案文件PrimitiveDataTypes,单击打开。
随后将加载解决方案。解决方案资源管理器将显示PrimitiveDataTypes项目。

注意 解决方案文件使用.sln扩展名,例如PrimitiveDataTypes.sln。解决方案可包含一个或多个项目。项目文件使用.csproj扩展名。如果打开项目而不是解决方案,Visual Studio 2015自动为它创建新的解决方案文件。不注意的话可能造成困扰,你可能不慎为同一个项目生成多个解决方案。


5. 在调试菜单中选择开始调试。
可能在Visual
Studio中看到一些警告。暂时忽略警告将在下个练习纠正。将显示下图所示的页面。

6. 在Choose a data
type选择数据类型列表中单击string类型。
forty two这个值会出现在Sample value示例值文本框中。
7. 单击列表中的int类型。
Sample value文本框显示值to
do,表明用于显示int值的语句还没有写好。
8. 单击列表中的每种数据类型。确定用于double和bool类型的代码都还没有实现。
9. 返回Visual
Studio 2015,选择调试|停止调试。也可关闭窗口来停止调试。

在代码中使用基元数据类型

1. 在解决方案资源管理器中展开PrimitiveDataTypes项目,双击MainPage.xaml文件。
应用程序的窗体将出现在设计视图窗口中。

提示 如屏幕不够大,窗体显示不完全,可用快捷键Ctrl Alt =和Ctrl Alt -或Ctrl 鼠标滚轮放大缩小窗体,或从设计视图左下角的下拉列表中选择显示比例。

2. 在XAML窗格向下滚动,找到ListBox控件的标记。该控件在窗体左侧显示数据类型列表,其代码如下省略了一些属性:

ListBox
x:Name="type" ... SelectionChanged="typeSelectionChanged"
ListBoxItemintListBoxItem
ListBoxItemlongListBoxItem
ListBoxItemfloatListBoxItem
ListBoxItemdoubleListBoxItem
ListBoxItemdecimalListBoxItem
ListBoxItemstringListBoxItem
ListBoxItemcharListBoxItem
ListBoxItemboolListBoxItem
ListBox
ListBox控件将每个数据类型显示成单独的ListBoxItem。应用程序运行时单击列表项会发生SelectionChanged事件有点像第1章描述的单击按钮时发生Click事件。本程序是在发生该事件时调用MainPage.xaml.cs文件中定义的typeSelectionChanged方法。
3. 选择视图|代码或者按功能键F7。
将在代码和文本编辑器窗口中显示MainPage.xaml.cs文件的内容。

注意 记住可用解决方案资源管理器访问代码,展开MainPage.xaml后双击MainPage.xaml.cs。

4. 在文件中找到typeSelectionChanged方法。

提示 要在当前项目查找特定内容,可在编辑菜单中选择查找和替换|快速查找Ctrl F。随后会打开搜索框。输入要查找的某一项的名称,单击查找下一个按钮,如下图所示。
默认不区分大小写。要区分大小写,单击搜索框下方的区分大小写按钮Aa。也可以不用编辑菜单,直接按快捷键Ctrl F进行快速查找,按快捷键Ctrl H进行快速替换。
除了快速查找,还可利用代码和文本编辑器窗口上方的类成员下拉列表查找方法。列表显示了类定义的所有方法、变量和其他项以后会详细讲述。从列表中选择typeSelectionChanged。光标便会直接跳至该方法,如下图所示。


如果有其语言的编程经验,或许已猜到typeSelectionChanged方法的工作原理。如果没有,第4章会详细讲解这些代码。目前只需理解当单击ListBox控件中的列表项时,那一项的细节传给该方法。方法据此决定接着要做什么。例如,单击float,方法会调用showFloatValue方法。
5. 向下滚动代码,找到showFloatValue方法,如下所示:

private void showFloatValue
{

float floatVar;

floatVar = 0.42F;

value.Text = floatVar.ToString;
}
方法主体包含三个语句。第一个声明float类型的变量floatVar。
第二个将值0.42F赋给变量floatVar。

重要提示 F是类型后缀,指出值0.42应被当作float值。如忘记添加F后缀,值0.42默认被当作double值。这样程序将无法编译,因为如果不写额外的代码,就不能将一种类型的值赋给另一种类型的变量。C#在这方面很严格。

第三个语句在窗体的value文本框显示该变量的值。多留意一下该语句。第1章说过,文本框要显示内容须设置其Text属性。第1章是用XAML来做,但还可像本例那样采用编程方式。注意是用以前介绍的用于运行方法的点记号法访问对象的属性。还记得第1章介绍的Console.WriteLine方法?。另外,为Text属性提供的数据必须是字符串而不能是数字。将数字赋给Text属性,程序将无法编译。幸好,.NET Framework通过ToString方法提供了帮助。
.NET Framework的所有数据类型都有ToString方法,用于将对象转换成字符串形式。showFloatValue方法使用float类型的floatVar变量的ToString方法生成该变量的值的字符串形式。字符串可安全赋给value文本框的Text属性。自己创建数据类型和类时,可实现ToString方法指定如何用字符串表示类的对象。将在第7章学习如何自己创建类。
6. 在代码和文本编辑器窗口中找到如下所示的showIntValue方法:

private void showIntValue
{
value. Text =
"to do";
}
在列表框中单击int类型时会调用showIntValue方法。
7. 在showIntValue方法开头起始大括号后另起一行输入以下加粗的两个语句:

private void showIntValue
{
int intVar;
intVar = 42;
value.Text = "to
do";
}
第一个语句创建变量intVar来容纳int值。第二个将值42赋给变量。
8. 在方法的原始语句中,将字符串"to do"改成intVar.ToString。方法现在像下面这样:

private void showIntValue
{
int intVar;
intVar = 42;
value.Text =
intVar.ToString;
}
9. 在调试菜单中选择开始调试。
窗体将再次出现。
10. 从列表框中选择int类型。确定Sample value框显示值42。
11. 返回Visual Studio 2015,在调试菜单中选择停止调试命令。
12. 在代码和文本编辑器窗口中找到showDoubleValue方法。
13. 编辑showDoubleValue方法,添加加粗的代码:

private void showDoubleValue
{
double doubleVar;
doubleVar = 0.42;
value.Text = doubleVar.ToString;
}
代码和showIntValue方法相似,只是创建double变量doubleVar,赋值0.42。
14. 在代码和文本编辑器窗口中找到showBoolValue方法。
15. 编辑showBoolValue方法:

private void showBoolValue
{
bool boolVar;
boolVar = false;
value.Text =
boolVar.ToString;
}
代码和之前的例子相似,不过boolVar变量只能容纳布尔值true或false。本例赋值false。
16. 在调试菜单中选择开始调试。
17. 从Choose a data type列表中选择int、double和bool类型。在每一种情况下,都验证Sample value框中显示的是正确的值。
18. 返回Visual Studio 2015,在调试菜单中选择停止调试。
2.5 使用算术操作符
C#支持我们在孩提时代学过的常规算术操作符:加号 、减号-、星号*和正斜杠分别执行加、减、乘、除。它们称为操作符或运算符,对值进行操作或运算来生成新值。在下例中,moneyPaidToConsultant变量最终容纳的是值750每天的费用和值20天数的乘积,结果就是要付给顾问的钱。

long moneyPaidToConsultant;
moneyPaidToConsultant = 750 * 20;


注意 操作符或运算符操作运算的是操作数或运算子[②]。在表达式750
* 20中,*是操作符,750和20是操作数。

2.5.1 操作符和类型
不是所有操作符都适合所有数据类型。操作符能不能应用于某个值要取决于值的类型。例如,可对char,int,long,float,double或decimal类型的值使用任何算术操作符。但除了加法操作符 ,不能对string类型的值使用其他任何算术操作符。对于bool类型的值,则什么算术操作符都不能用。所以以下语句是不允许的,因为string类型不支持减法操作符从一个字符串减另一个字符串没有意义:

编译时错误
Console.WriteLine"Gillingham"
- "Forest Green Rovers";
操作符 可用于连接字符串值。使用需谨慎,因为可能得到出乎意料的结果。例如,以下语句在控制台中写入"431"而不是"44":

Console.WriteLine"43"
"1";

提示 .NET Framework提供了Int32.Parse方法。要对作为字符串存储的值执行算术运算,可先用Int32.Parse将其转换成整数值。

字符串插值
C#
6的一项新功能是字符串插值string interpolation,有了它就基本上不用 操作符连接字符串了。
连接字符串通常是为了生成包含变量值的字符串。第1章创建图形应用程序时演示过一个例子。okClick方法添加过下面这行代码:
MessageDialog msg
= new MessageDialog"Hello " userName.Text;
字符串插值则允许改用以下语法:
MessageDialog msg
= new MessageDialog$"Hello {userName.Text}";
开头的$符号表明这是插值字符串,{和}之间的任何表达式都需求值并置换。没有前置的$符号,字符串{username.Text}将按字面处理。
字符串插值比 操作符高效得多。由于.NET Framework处理字符串的方式,用 来连接字符串可能消耗大量内存。字符串插值还更具可读性和减少犯错机会虽然这一点有争议。
还要注意,算术运算的结果类型取决于操作数类型。例如,表达式5.0
2.0的值是2.5。两个操作数的类型均是double,结果也是double。在C#中,带小数点的字面值[③]肯定是double值,而不是float值,目的是保留尽量高的精度。然而,表达式5
2的结果是2。两个操作数的类型均是int,结果也是int。C#在这种情况下总是对值进行向下取整。另外,混用不同的操作数类型,情况会变得更加复杂。例如,表达式5
2.0包含int值和double值。C#编译器检测到这种不一致的情况,自动生成代码将int转换成double再执行计算。所以,以上表达式的结果是double值2.5。虽然写法有效,但通常不建议。
C#还支持你或许不太熟悉的一个算术操作符,即取模余数操作符。它用百分号%表示。x
% y的结果就是用x除以y所得的余数。例如,9
% 2结果是1,因为9除以2,结果是4余1。

注意 如熟悉C和C ,就知道它们不允许对float和double值使用取模操作符。但C#允许。取模操作符适用于所有数值类型,而且结果不一定为整数。例如,表达式7.0
% 2.4结果是2.2。

数值类型和无穷大
C#语言的数字还有另两个特性是你必须了解的。例如,任何数除以0所得的结果是无穷大,不在int,long和decimal类型的范围内。所以,计算5
0这样的表达式会出错。但是,double和float类型实际上有一个可以表示无穷大的特殊值,因此表达式5.0
0.0的值是Infinity无穷大。这个规则的唯一例外是表达式0.0 0.0。通常,如果0除以任何数,结果都是0,但任何数除以0结果是无穷大。表达式0.0
0.0会陷入一种自相矛盾的境地:值既是0,又是无穷大。针对这种情况,C#语言提供了另一个值NaN,即not a number。所以,如果计算表达式0.0
0.0,则结果为NaN。NaN和Infinity可在表达式中使用。计算10 NaN,结果是NaN。计算10
Infinity,结果是Infinity。规则的唯一例外是Infinity * 0,结果是0。而NaN
* 0的结果仍是NaN。
2.5.2 深入了解算术操作符
以下练习演示如何对int类型的值使用算术操作符。

运行MathsOperators项目

1. 如果还没有运行Visual
Studio 2015,请启动它。
2. 打开MathsOperators项目。该项目位于文档文件夹下的\Microsoft
Press\VCSBS\Chapter 2\MathsOperators子文件夹中。
3. 在调试菜单中选择开始调试命令。
随后将显示如下图所示的窗体。

4. 在Left Operand左操作数框中输入54。
5. 在Right
Operand右操作数框中输入13。
随后,可以向两个文本框中的值应用任意操作符。
6. 单击Subtraction减单选钮,再单击Calculate计算按钮。
Expression表达式框中的文本变成54-13,Result结果框显示0。这明显是错的。
7. 单击 Division除,再单击Calculate。
Expression框中的文本变成54
13,Result框再次显示0。
8. 单击% Remainder取模,再单击Calculate。
Expression框中的文本变成54 %
13,Result框再次显示0。测试其他数字和操作符组合,证实目前结果都显示0。

注意 输入任何非整数的操作数,应用程序检测到错误并显示消息Input string was not in a correct format.。第6章将介绍如何捕捉和处理错误异常。

9. 返回Visual
Studio并选择调试|停止调试。
MathsOperators应用程序目前没有实现任何计算。下个练习将进行改进。

在MathsOperators应用程序中执行计算

1. 在设计视图窗口中显示MainPage.xaml窗体,如有必要,在解决方案资源管理器的MathsOperators项目中双击MainPage.xaml。
2. 选择视图|其他窗口|文档大纲。
随后将打开如下图所示的文档大纲窗口,其中列出了窗体上各个控件的名称和类型。文档大纲窗口提供了一个简单的方式在复杂的窗体中定位并选择控件。控件分级显示,最顶级的是构成窗体的Page。如第1章所述,UWP应用的页包含一个Grid控件,其他控件都放在该Grid中。在文档大纲中展开Grid节点就会看到其他控件。其他控件以另一个Grid开始外层Grid作为frame使用,内层Grid包含窗体上出现的控件。展开内层Grid将列出窗体上的所有控件。

单击任何控件,对应元素在设计视图中突出显示。类似地,在设计视图中选中控件,对应控件在文档大纲窗口中突出显示。单击文档大纲窗口右上角的图钉按钮来固定窗口,更好地体验这个功能。
3. 在窗体上单击供用户输入数字的两个TextBox控件。在文档大纲窗口中,确认它们分别命名为lhsOperand和rhsOperand。
窗体运行时,每个控件的Text属性都容纳了用户输入的值。
4. 在窗体底部,确认用于显示表达式的TextBlock控件命名为expression,用于显示计算结果的TextBlock控件命名为result。
5. 关闭文档大纲窗口。
6. 选择视图|代码,在代码和文本编辑器窗口中显示MainPage.xaml.cs文件的代码。
7. 在代码和文本编辑器窗口中找到addValues方法,如下所示:

private void
addValues
{
int lhs = int.ParselhsOperand.Text;
int rhs = int.ParserhsOperand.Text;
int outcome = 0;
TODO: Add rhs to lhs and store the result
in outcome
expression.Text = $"{lhsOperand.Text}
{rhsOperand.Text}";
result.Text = outcome.ToString;
}
第一个语句声明名为int变量lhs,初始化为用户在lhsOperand框中输入的整数。记住TextBox控件的Text属性包含字符串,但lhs是int,所以必须先将字符串转换为整数,然后才能赋给lhs。int数据类型提供了int.Parse方法来执行这个转换。
第二个语句声明int变量rhs。rhsOperand框中的值转换为int之后赋给它。
第三个语句声明int变量outcome。
一条注释指出要将lhs和rhs加到一起,结果存储到outcome中。这将在下个步骤实现。
第五个语句利用字符串插值构造一个字符串来显示要执行的计算,并将结果赋给expression.Text属性,导致字符串在窗体的expression框中显示。
最后一个语句将计算结果赋给result框的Text属性以显示。记住Text属性的值是字符串,而计算结果是int,所以必须先转换成字符串才能赋给Text属性。这正是int类型的ToString方法的作用。
8. 在addValues方法中部的注释下添加以下加粗显示的语句:

private void
addValues
{
int lhs = int.ParselhsOperand.Text;
int rhs = int.ParserhsOperand.Text;
int outcome=0;
TODO: Add rhs to lhs and store the result
in outcome
outcome = lhs rhs;
expression.Text = $"{lhsOperand.Text}
{rhsOperand.Text}";
result.Text = outcome.ToString;
}
该语句对表达式lhs
rhs进行求值,结果存储到outcome中。
9. 检查subtractValues方法。该方法遵循相似的模式,需要添加语句计算从lhs减去rhs的结果,并存储到outcome中。在方法中添加以下加粗显示的语句:

private void
subtractValues
{
int lhs = int.ParselhsOperand.Text;
int rhs = int.ParserhsOperand.Text;
int outcome=0;
TODO: Subtract rhs from lhs and store the
result in outcome
outcome = lhs - rhs;
expression.Text = $"{lhsOperand.Text} -
{rhsOperand.Text}";
result.Text = outcome.ToString;
}
10. 检查mutiplyValues,divideValues和remainderValues方法。它们同样缺失了执行指定计算的关键语句。添加缺失的语句加粗显示:

private void multiplyValues
{

int lhs = int.ParselhsOperand.Text;

int rhs = int.ParserhsOperand.Text;

int outcome = 0;

TODO: Multiply lhs by rhs and store the result in outcome

outcome = lhs * rhs;

expression.Text = $"{lhsOperand.Text} * {rhsOperand.Text}";

result.Text = outcome.ToString;
}

private void divideValues
{

int lhs = int.ParselhsOperand.Text;

int rhs = int.ParserhsOperand.Text;

int outcome = 0;

TODO: Divide lhs by rhs and store the result in outcome

outcome = lhs rhs;

expression.Text = $"{lhsOperand.Text} {rhsOperand.Text}";

result.Text = outcome.ToString;
}

private void remainderValues
{

int lhs = int.ParselhsOperand.Text;

int rhs = int.ParserhsOperand.Text;

int outcome = 0;

TODO: Work out the remainder after dividing lhs by rhs and store the
result

outcome = lhs % rhs;

expression.Text = $"{lhsOperand.Text} % {rhsOperand.Text}";

result.Text = outcome.ToString;
}

测试MathsOperators应用程序

1. 在调试菜单中选择开始调试以生成并运行应用程序。
2. 在Left Operand框中输入54,在Right Operand框中输入13。单击 Addition,单击Calculate。
Result框显示值67。
3. 单击Subtraction,单击Calculate。验证结果是41。
4. 单击*
Multiplication,单击Calculate。验证结果是702。
5. 单击 Division,单击Calculate。验证结果是4。
在现实生活中,54
13的结果应该是4.153846如此重复。但这不是现实生活;这是C#!正如前面解释的,在C#中整数除以整数结果也是整数。
6. 单击% Remainder,单击Calculate。验证结果是2。
处理整数时,54除以13,余数是2。计算机求值过程是545413
* 13 = 2。每一步都向下取整。如果我告诉数学老师,说5413
* 13不等于54,他肯定要打我!
7. 返回Visual
Studio并停止调试。
2.5.3 控制优先级
优先级控制表达式中各个操作符的求值顺序。例如以下表达式,它使用了操作符 和*:

2 3 * 4
没有优先级规则,该表达式会造成歧义。先加还是先乘?不同求值顺序造成不同结果。
l
如果先加后乘,那么加法运算2 3的结果将成为操作符*的左操作数,所以整个表达式的结果是5
* 4,即20。
l
假如先乘后加,那么乘法运算3 * 4的结果将成为操作符 的右操作数,所以整个表达式的结果是2
12,即14。
在C#中,乘法类操作符*,和%的优先级高于加法类操作符 和-。所以2
3 * 4的结果是14。以后讨论每种新操作符时,都会指出它的优先级。
可用圆括号覆盖优先级规则,强制操作数按你希望的方式绑定到操作符。例如在以下表达式中,圆括号强迫2和3绑定到操作符 得5,结果成为操作符*的左操作数,最终结果是20:

2 3 * 4


注意 本书所指圆括号是;大括号或花括号是{};方括号是[]。

2.5.4 使用结合性对表达式进行求值
操作符优先级只能解决部分问题。如果表达式中的多个操作符具有相同优先级怎么办?这就要用到结合性的概念。结合性是指操作数的求值方向向左或向右。例如,以下表达式同时使用操作符和*:

4 2 * 6
该表达式仍有可能造成歧义。是先除还是先乘?两个操作符优先级相同,但求值顺序至关重要,因为可能获得两个不同的结果。
l
如果先除,除法运算4 2的结果成为操作符*的左操作数,整个表达式的结果是
42
* 6,即12。
l
如果先乘,乘法运算的结果2 * 6成为操作符的右操作数,整个表达式的结果是42
* 6,即412。
在这种情况下,操作符的结合性决定表达式如何求值。操作符*和都具有左结合性,即操作数从左向右求值。在本例中,42在乘以6之前求值,所以正确结果是12。
2.5.5 结合性和赋值操作符
C#的等号=是赋值操作符。所有操作符都依据它们的操作数返回一个值。赋值操作符也不例外。它取两个操作数;右侧操作数被求值,结果保存到左侧操作数中。赋值操作符返回的就是赋给左操作数的值。例如,以下语句的赋值操作符返回值10,这也是赋给变量myInt的值:

int myInt;
myInt = 10; 赋值表达式的值是10
一切都甚合逻辑,但你同时也会感到不解,这到底有什么意义?意义在于,由于赋值操作符返回一个值,所以可在另一个赋值语句中使用该值,例如:

int myInt;
int myInt2;
myInt2 = myInt = 10;
赋给变量myInt2的值就是赋给myInt的值。赋值语句把同一个值赋给两个变量。要将多个变量初始化为同一个值,这个技术十分有用。它使任何读代码的人清楚理解所有变量都具有相同的值。

myInt5 = myInt4 = myInt3 = myInt2 =
myInt = 10;
通过这些讨论,你可能已推断出赋值操作符具有从右向左的结合性。最右侧的赋值最先发生,被赋的值从右向左,在各个变量之间传递。任何变量之前有过值,就用当前赋的值覆盖。
但是,使用这样的语法构造时要小心。新手C#程序员易犯的错误是试图将赋值操作符的这种用法与变量声明一起使用,例如:

int myInt, myInt2, myInt3 = 10;
语法没有错误能通过编译,但做的事情可能跟你想的不同。它实际是声明变量myInt,myInt2和myInt3,并将myInt3初始化为10。然而,不会初始化myInt或者myInt2。如果尝试在以下表达式中使用myInt或者myInt2:

myInt3 = myInt myInt2;
编译器会报告以下错误:

使用了未赋值的局部变量 "myInt"
使用了未赋值的局部变量
"myInt2"
2.6 变量递增和递减
使变量加1可以使用 操作符:

count = count 1;
然而使变量加1是C#的一个非常普遍的操作,所以专门为这个操作设计了 操作符。例如,使变量count递增1可以像下面这样写:

count ;
对应地,--操作符从变量中减1:

count--;
和--是一元操作符,即只有一个操作数。它们具有相同的优先级和左结合性。

前缀和后缀
递增 和递减--操作符与众不同之处在于,它们既可以放在变量前,也可以放在变量后。在变量前使用,称为这个操作符的前缀形式;在变量之后使用,则称为这个操作符的后缀形式。如下面几个例子所示:

count ; 后缀递增
count; 前缀递增
count--; 后缀递减
--count; 前缀递减
对于被递增或递减的变量, 或--的前缀和后缀形式没有区别。例如,count 使count的值递增1, count也会使其递增1。那么为何还要提供两种不同的形式?为了理解这个问题,必须记住一点: 和--都是操作符,而所有操作符都要返回值。count 返回递增前的count值,而 count返回递增后的count值。例如:

int x;
x = 42;
Console.WriteLinex ; 执行这个语句后,x等于43,但控制台上输出的是42
x = 42;
Console.WriteLine x; 执行这个语句后,x等于43,控制台上输出的也是43
其实很好记,只需看表达式各个元素操作符和操作数的顺序即可。在表达式x 中,变量x先出现,所以先返回它现在的值,然后再递增;在表达式 x中, 操作符先出现,所以先对x进行递增,再将新值作为表达式的值返回。
while和do语句经常利用这些操作符,第5章将详细讲述这些语句。如果只是孤立地使用递增和递减操作符[④],请统一使用后缀形式。
2.7 声明隐式类型的局部变量
本章前面通过指定数据类型和标识符来声明变量,如下所示:

int myInt;
以前说过,变量在使用前必须赋值。可在同一个语句中声明并初始化变量,如下所示:

int myInt = 99;
还可像下面这样做假定myOtherInt是已初始化的整数变量:

int myInt = myOtherInt * 99;
记住,赋给变量的值必须具有和变量相同的类型。例如,只能将int值赋给int变量。C#编译器可迅速判断变量初始化表达式的类型,如果和变量类型不符,就会明确告诉你。除此之外,还可要求C#编译器根据表达式推断变量类型,并在声明变量时自动使用该类型。为此,只需用var关键字代替类型名称,如下所示:

var myVariable = 99;
var myOtherVariable = "Hello";
两个变量myVariable和myOtherVariable称为隐式类型变量。var关键字告诉编译器根据用于变量的初始化表达式推断变量类型。在本例中,myVariable是int类型,而myOtherVariable是string类型。必须注意,var只是在声明变量时提供一些方便。但变量一经声明,就只能将编译器推断的那种类型的值赋给它。例如,不能再将float,double,string值赋给myVariable。还要注意,只有提供表达式来初始化变量,才能使用关键字var。以下声明非法,会导致编译错误:

var yetAnotherVariable; 错误 - 编译器不能推断类型

重要提示 如果用Visual Basic写过程序,就可能非常熟悉Variant类型,该类型可在变量中保存任意类型的值。这里要强调的是,应该忘记当年用VB编程时学到的有关Variant变量的一切。虽然两个关键字貌似有联系,但var和Variant完全是两码事。在C#中用var关键字声明变量之后,赋给变量的值的类型就固定下来,必须是初始化变量的值的类型,不能随便改变!

纯化论者不喜欢这个设计,质疑像C#这样优雅的语言,为什么竟然允许var这样的东西?它更像是在助长程序员偷懒,使程序变得难以理解,而且更难找出错误还容易引入新的bug。但相信我,var在C#语言中占有一席之地是有缘故的。学完后面几章就能深切体会。目前应坚持使用明确指定了类型的变量;除非万不得已,否则不要使用隐式类型变量。
小 结
本章讲述了如何创建和使用变量,讲述了C#变量的常用数据类型,还讲述了标识符的概念。本章使用许多操作符构造表达式,并探讨了操作符的优先级和结合性如何影响表达式求值顺序。
l
如果希望继续学习下一章,请继续运行Visual Studio 2015,然后阅读第3章。
l
如果希望现在就退出Visual Studio 2015,请选择文件|退出。如果看到保存对话框,请单击是按钮保存项目。

第2章快速参考





目标


操作




声明变量


按顺序写数据类型名称、变量名和分号,示例如下:

int outcome;





声明并初始化变量


按顺序写数据类型名称、变量名、赋值操作符、初始值和分号,示例如下:

int outcome = 99;





更改变量值


按顺序写变量名、赋值操作符、用于计算新值的表达式和分号,示例如下:

outcome = 42;





生成变量值的字符串形式


调用变量的ToString方法,示例如下:

int intVar = 42;
string stringVar = intVar.ToString;





将string转换成int


调用System.Int32.Parse方法。示例如下:

string stringVar = "42";
int intVar =
System.Int32.ParsestringVar;





覆盖操作符优先级


在表达式中使用圆括号强制求值顺序,示例如下:

3 4 * 5





将多个变量初始化为同一个值


使用赋值语句初始化所有变量,示例如下:

myInt4 = myInt3 = myInt2 = myInt = 10;





递增或递减变量


使用 或--操作符,示例如下:

count ;










① 译注:基元数据类型primitive data type是文档的译法。有时也称基本数据类型或原始数据类型。


[②] 译注:本书统一为操作符和操作数。


[③] 译注:字面值literal是直接在代码中输入的值,包括数字和字符串值。也称为直接量或文字常量。本书采用字面值这一译法。


① 译注:将递增或递减表达式作为单独的语句使用,例如count ;。

 

 

書城介紹  | 合作申請 | 索要書目  | 新手入門 | 聯絡方式  | 幫助中心 | 找書說明  | 送貨方式 | 付款方式 香港用户  | 台灣用户 | 海外用户
megBook.com.tw
Copyright (C) 2013 - 2024 (香港)大書城有限公司 All Rights Reserved.