C#函数式编程 编写更优质的C#代码PDF电子书下载

第Ⅰ部分 核心概念 3

第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

第Ⅱ部分 函数式风格 119

第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

第Ⅲ部分 高级技术 251

第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