C#函数式编程 编写更优质的C#代码

图书标准信息

• 作者 [美]恩里科·博南诺（Enrico Buonanno） 著；张久修 译
• 出版社 清华大学出版社
• 出版时间 2018-11
• 版次 1
• ISBN 9787302510550
• 定价 98.00元
• 装帧 其他
• 开本 16开
• 纸张 胶版纸

【内容简介】

函数式编程将改变你思考代码的方式！利用FP技术，C#开发人员可极大地提升状态管理、并发处理和事件处理能力，并更好地长期维护代码。C#提供了灵活性，使你能充分利用函数式技术的优势。《C#函数式编程
  编写更优质的C#代码》从全新视角赋予你强大力量。
  《C#函数式编程
  编写更优质的C#代码》引导你在C#语言中使用函数式思想来解决现实问题；首先介绍函数式编程的原理，分析如何借助C#语言特性实现函数式编程，然后在多个紧贴实用的示例的引导下，讲述函数组合、数据流编程、不可变数据结构以及使用LINQ构建单子组合等主题。

【作者简介】

Enrico Buonanno 毕业于哥伦比亚大学计算机科学系，是一名出色的开发人员、架构师和培训师，拥有15年的工作经验。

【目录】

目    录

第Ⅰ部分  核心概念

第1章  介绍函数式编程  3

1.1  什么是函数式编程  4

1.1.1  函数作为第一类值  4

1.1.2  避免状态突变  4

1.1.3  编写具有强力保证的程序  5

1.2  C#的函数式语言  8

1.2.1  LINQ的函数式性质  9

1.2.2  C# 6和C# 7中的函数式特性  10

1.2.3  未来的C#将更趋函数化  13

1.3  函数思维  13

1.3.1  映射函数  13

1.3.2  在C#中表示函数  14

1.4  高阶函数  18

1.4.1  依赖于其他函数的函数  18

1.4.2  适配器函数  20

1.4.3  创建其他函数的函数  20

1.5  使用HOF避免重复  21

1.5.1  将安装和拆卸封装到HOF中  23

1.5.2  将using语句转换为HOF  24

1.5.3  HOF的权衡  25

1.6  函数式编程的好处  27

练习  27

小结  28

第2章  为什么函数纯洁性很重要  29

2.1  什么是函数的纯洁性  29

2.1.1  纯洁性和副作用  30

2.1.2  管理副作用的策略  31

2.2  纯洁性和并发性  33

2.2.1  纯函数可良好地并行化  34

2.2.2  并行化不纯函数  35

2.2.3  避免状态的突变  36

2.3  纯洁性和可测性  38

2.3.1  实践：一个验证场景  39

2.3.2  在测试中引入不纯函数  40

2.3.3  为什么很难测试不纯函数  42

2.3.4  参数化单元测试  43

2.3.5  避免标头接口  44

2.4  纯洁性和计算的发展  47

练习  47

小结  48

第3章  设计函数签名和类型  49

3.1  函数签名设计  49

3.1.1  箭头符号  50

3.1.2  签名的信息量有多大  51

3.2  使用数据对象捕获数据  52

3.2.1  原始类型通常不够具体  53

3.2.2  使用自定义类型约束输入  53

3.2.3  编写“诚实的”函数  55

3.2.4  使用元组和对象来组合值  56

3.3  使用Unit为数据缺失建模  58

3.3.1  为什么void不理想  58

3.3.2  使用Unit弥合Action和Func之间的差异  59

3.4  使用Option为数据可能缺失建模  61

3.4.1  你每天都在使用糟糕的API  61

3.4.2  Option类型的介绍  62

3.4.3  实现Option  65

3.4.4  通过使用Option而不是null来获得健壮性  68

3.4.5  Option作为偏函数的自然结果类型  69

练习  73

小结  74

第4章  函数式编程中的模式  77

4.1  将函数应用于结构的内 部值  77

4.1.1  将函数映射到序列上  77

4.1.2  将函数映射到Option  79

4.1.3  Option是如何提高抽象层级的  81

4.1.4  函子  82

4.2  使用ForEach执行副作用  83

4.3  使用Bind来链接函数  85

4.3.1  将返回Option的函数结合起来  85

4.3.2  使用Bind平铺嵌套列表  87

4.3.3  实际上，这被称为单子  88

4.3.4  Return函数  88

4.3.5  函子和单子之间的关系  89

4.4  使用Where过滤值  90

4.5  使用Bind结合Option和IEnumerable  91

4.6  在不同抽象层级上编码  92

4.6.1  常规值与高级值  93

4.6.2  跨越抽象层级  94

4.6.3  重新审视Map与Bind  95

4.6.4  在正确的抽象层级上

工作  96

练习  96

小结  97

第5章  使用函数组合设计程序  99

5.1  函数组合  99

5.1.1  复习函数组合  100

5.1.2  方法链  101

5.1.3  高级值界域中的组合  101

5.2  从数据流的角度进行 思考  102

5.2.1  使用LINQ的可组合

API  102

5.2.2  编写可组合性更好的函数  103

5.3  工作流编程  105

5.3.1  关于验证的一个简单

工作流  106

5.3.2  以数据流的思想进行重构  107

5.3.3  组合带来了更大的灵活性  108

5.4  介绍函数式领域建模  109

5.5  端到端的服务器端 工作流  110

5.5.1  表达式与语句  112

5.5.2  声明式与命令式  112

5.5.3  函数式分层  113

练习  115

小结  115

第Ⅱ部分  函数式风格

第6章  函数式错误处理  119

6.1  表示输出的更安全方式  120

6.1.1  使用Either捕获错误细节  120

6.1.2  处理Either的核心函数  123

6.1.3  比较Option和Either  124

6.2  链接操作可能失败  125

6.3  验证：Either的一个完美用例  127

6.3.1  为错误选择合适的表示法  128

6.3.2  定义一个基于Either的API  129

6.3.3  添加验证逻辑  130

6.4  将输出提供给客户端应用程序  131

6.4.1  公开一个类似Option的接口  132

6.4.2  公开一个类似Either的接口  134

6.4.3  返回一个DTO结果  134

6.5  Either的变体  136

6.5.1  在不同的错误表示之间进行改变  136

6.5.2  Either的特定版本  137

6.5.3  重构Validation和Exceptional  138

6.5.4  保留异常  141

练习  142

小结  142

第7章  用函数构造一个应用程序  145

7.1  偏函数应用：逐个提供参数  146

7.1.1  手动启用偏函数应用  147

7.1.2  归纳偏函数应用  148

7.1.3  参数的顺序问题  150

7.2  克服方法解析的怪癖  150

7.3  柯里化函数：优化偏函数应用  152

7.4  创建一个友好的偏函数应用API  155

7.4.1  可文档化的类型  156

7.4.2  具化数据访问函数  157

7.5  应用程序的模块化及

组合  159

7.5.1  OOP中的模块化  160

7.5.2  FP中的模块化  162

7.5.3  比较两种方法  164

7.5.4  组合应用程序  165

7.6  将列表压缩为单个值  166

7.6.1  LINQ的Aggregate方法  166

7.6.2  聚合验证结果  168

7.6.3  收获验证错误  169

练习  170

小结  171

第8章  有效地处理多参函数  173

8.1  高级界域中的函数应用程序  174

8.1.1  理解应用式  176

8.1.2  提升函数  177

8.1.3  介绍基于属性的测试  179

8.2  函子、应用式、单子  181

8.3  单子定律  182

8.3.1  右恒等元  183

8.3.2  左恒等元  183

8.3.3  结合律  184

8.3.4  对多参函数使用Bind  185

8.4  通过对任何单子使用LINQ来提高可读性  186

8.4.1  对任意函子使用LINQ  186

8.4.2  对任意单子使用LINQ  188

8.4.3  let、where及其他LINQ子句  191

8.5  何时使用Bind或Apply  192

8.5.1  具有智能构造函数的验证  192

8.5.2  使用应用式流来收集错误  194

8.5.3  使用单子流来快速失败  195

练习  196

小结  196

第9章  关于数据的函数式思考  199

9.1  状态突变的陷阱  200

9.2  理解状态、标识及变化  202

9.2.1  有些事物永远不会变化  203

9.2.2  表示非突变的变化  205

9.3  强制不可变性  207

9.3.1  永远不可变  209

9.3.2  无样板代码的拷贝方法的可行性  210

9.3.3  利用F#处理数据类型  212

9.3.4  比较不变性的策略：一场丑陋的比赛  213

9.4  函数式数据结构简介  214

9.4.1  经典的函数式链表  215

9.4.2  二叉树  219

练习  223

小结  224

第10章  事件溯源：持久化的函数 式方法  225

10.1  关于数据存储的函数式思考  226

10.1.1  为什么数据存储只能追加  226

10.1.2  放松，并忘却存储状态  227

10.2  事件溯源的基础知识  228

10.2.1  表示事件  228

10.2.2  持久化事件  229

10.2.3  表示状态  230

10.2.4  一个模式匹配的插曲  231

10.2.5  表示状态转换  234

10.2.6  从过去的事件中重建当前状态  235

10.3  事件溯源系统的架构  236

10.3.1  处理命令  237

10.3.2  处理事件  240

10.3.3  添加验证  241

10.3.4  根据事件创建数据的视图  243

10.4  比较不可变存储的不同方法  246

10.4.1  Datomic与

Event Store  247

10.4.2  你的领域是否受事件驱动？  247

小结  248

第Ⅲ部分  高级技术

第11章  惰性计算、延续以及单子组合之美  251

11.1  惰性的优点  251

11.1.1  用于处理Option的惰性API  252

11.1.2  组合惰性计算  254

11.2  使用Try进行异常处理  256

11.2.1  表示可能失败的计算  257

11.2.2  从JSON对象中安全地提取信息  257

11.2.3  组合可能失败的计算  259

11.2.4  单子组合：是什么意思呢？  260

11.3  为数据库访问创建中间件管道  261

11.3.1  组合执行安装/拆卸的函数  261

11.3.2  逃离厄运金字塔的秘方  263

11.3.3  捕获中间件函数的本质  263

11.3.4  实现中间件的查询模式  265

11.3.5  添加计时操作的中间件  268

11.3.6  添加管理数据库事务的中间件  269

小结  271

第12章  有状态的程序和计算  273

12.1  管理状态的程序  274

12.1.1  维护所检索资源的缓存  275

12.1.2  重构可测试性和错误处理  277

12.1.3  有状态的计算  278

12.2  一种用于生成随机数据的语言  279

12.2.1  生成随机整数  280

12.2.2  生成其他基元  281

12.2.3  生成复杂的结构  282

12.3  有状态计算的通用模式  284

小结  287

第13章  使用异步计算  289

13.1  异步计算  290

13.1.1  对异步的需要  290

13.1.2  用Task表示异步操作  291

13.1.3  Task作为一个将来值的容器  292

13.1.4  处理失败  294

13.1.5  一个用于货币转换的HTTP API  296

13.1.6  如果失败，请再试几次  297

13.1.7  并行运行异步操作  297

13.2  遍历：处理高级值列表  299

13.2.1  使用单子的Traverse来验证值列表  301

13.2.2  使用应用式Traverse来收集验证错误  302

13.2.3  将多个验证器应用于单个值  304

13.2.4  将Traverse与Task一起使用以等待多个结果  305

13.2.5  为单值结构定义Traverse  306

13.3  结合异步和验证(或其他任何两个单子效果)  308

13.3.1  堆叠单子的问题  308

13.3.2  减少效果的数量  310

13.3.3  具有一个单子堆叠的LINQ表达式  311

小结  312

第14章  数据流和Reactive Extensions  315

14.1  用IObservable表示数据流  316

14.1.1  时间上的一个序列的值  316

14.1.2  订阅IObservable  317

14.2  创建IObservable  318

14.2.1  创建一个定时器  319

14.2.2  使用Subject来告知IObservable应何时发出信号  320

14.2.3  从基于回调的订阅中创建IObservable  320

14.2.4  由更简单的结构创建IObservable  321

14.3  转换和结合数据流  323

14.3.1  流的转换  323

14.3.2  结合和划分流  325

14.3.3  使用IObservable进行错误处理  327

14.3.4  融会贯通  329

14.4  实现贯穿多个事件的逻辑  330

14.4.1  检测按键顺序  330

14.4.2  对事件源作出反应  333

14.4.3  通知账户何时透支  335

14.5  应该何时使用IObservable？  337

小结  338

第15章  并发消息传递  339

15.1  对共享可变状态的需要  339

15.2  理解并发消息传递  341

15.2.1  在C#中实现代理  343

15.2.2  开始使用代理  344

15.2.3  使用代理处理并发请求  346

15.2.4  代理与角色  349

15.3 “函数式API”与“基于代理的实现”  350

15.3.1  代理作为实现细节  351

15.3.2  将代理隐藏于常规API的背后  352

15.4  LOB应用程序中的并发消息传递  353

15.4.1  使用代理来同步对账户数据的访问  354

15.4.2  保管账户的注册表  356

15.4.3  代理不是一个对象  357

15.4.4  融会贯通  359

小结  361

结束语：接下来呢？  363