C#中函数编程实战：提升代码可读性与效率

需积分: 10 173 浏览量更新于2024-07-18 1 收藏 8.89MB PDF 举报

《C#中的函数式编程》是一本实用教程，专为熟练掌握C#但没有函数式编程（FP）经验的开发者编撰。作者Enrico Buonanno，拥有丰富的计算机科学背景和15年开发、架构和培训经验，将函数式思维应用到实际问题中，引导读者通过C#语言理解和实践FP。本书的核心内容涵盖了以下几个方面： 1. **函数式编程基础**：介绍了函数式编程的基本原则，包括在C#中可用的函数式特性，如高阶函数的运用，让读者了解如何利用这些功能来编写可读且团队协作友好的代码。 2. **纯函数与副作用**：讨论了函数的纯洁性（无副作用）以及其对并发编程、测试性的影响。纯洁性有助于提升代码的可靠性和维护性。 3. **函数签名设计**：讲解了函数签名的表示和设计技巧，以及类型设计，比如使用Option类型处理可能的缺失值。 4. **核心函数的使用**：深入剖析Map、Bind、ForEach和Where等核心函数，区分常规类型与提升类型，并展示它们如何编码工作流程和构建完整的应用程序流程。 5. **错误处理**：探讨了函数式错误处理方法，如 Either 类型用于表示结果的两种可能性，以及 Exceptional 和 Validation 类型的应用。 6. **部分应用与柯里化**：介绍如何模块化和组合应用程序，通过 Aggregate 函数实现。 7. **多参数函数与 Elevated 类型**：探讨 Apply 函数和 LINQ 查询模式，这些工具对于处理多个参数和复杂查询至关重要。 8. **状态、身份与变化**：讲解了不可变类型的概念及其在数据结构中的应用，以及如何处理状态、身份和变化管理。 9. **持久化与事件源**：探讨了不可变、只读持久化的概念，以及事件驱动的架构，如事件 sourcing 的理论和实现。 10. **惰性计算与单调组合**：介绍如何利用懒计算技术，通过组合函数来创建更复杂的计算逻辑，以及 continuations 的运用。 11. **状态ful 程序**：虽然这本书主要关注 FP，但也触及了状态ful 计算，让读者理解这两种编程范式的界限和融合之处。《C#中的函数式编程》不仅教授理论知识，还提供了大量实践案例，使读者能够逐步掌握这一编程范式，并将其应用于日常项目中，从而提高代码的组织性、可读性和长期维护性。通过购买印刷版书籍，读者还将获得免费的电子书资源，包括PDF、Kindle和ePub格式。

CONTENTS

xiv

11.3 Creating a middleware pipeline for DB access 268

Composing functions that perform setup/teardown 268

■

A recipe

against the pyramid of doom 270

■

Capturing the essence of a

middleware function 270

■

Implementing the query pattern for

middleware 272

■

Adding middleware that times the operation 275

Adding middleware that manages a DB transaction 276

Stateful programs and stateful computations 279

12.1 Programs that manage state 280

Maintaining a cache of retrieved resources 281

■

Refactoring for

testability and error handling 283

■

Stateful computations 285

12.2 A language for generating random data 285

Generating random integers 287

■

Generating other

primitives 287

■

Generating complex structures 289

12.3 A general pattern for stateful computations 291

Working with asynchronous computations 295

13.1 Asynchronous computations 296

The need for asynchrony 296

■

Representing asynchronous

operations with Task 297

■

Task as a container for a future

value 298

■

Handling failure 300

■

An HTTP API for

currency conversion 302

■

If it fails, try a few more times 303

Running asynchronous operations in parallel 304

13.2 Traversables: working with lists of elevated values 306

Validating a list of values with monadic Traverse 307

Harvesting validation errors with applicative Traverse 309

Applying multiple validators to a single value 311

■

Using

Traverse with Task to await multiple results 312

■

Defining

Traverse for single-value structures 313

13.3 Combining asynchrony and validation (or any other two

monadic effects) 315

The problem of stacked monads 315

■

Reducing the number of

effects 316

■

LINQ expressions with a monad stack 318

Data streams and the Reactive Extensions 320

14.1 Representing data streams with IObservable 321

A sequence of values in time 321

■

Subscribing to an IObservable 322

14.2 Creating IObservables 324

Creating a timer 324

■

Using Subject to tell an IObservable when it

should signal 325

■

Creating IObservables from callback-based

subscriptions 326

■

Creating IObservables from simpler structures 327

PREFACE

xviii

These shortcomings posed major stumbling blocks in my own path to learning FP.

After tossing aside the n-th book that explained something known as currying by show-

ing how the

add

function can be curried with the number 3, creating a function that

can add 3 to any number (can you think of any application where this would be even

remotely useful?), I decided to pursue my own research path. This involved learning

half a dozen functional languages (some better than others), and seeing which con-

cepts from

FP could be effectively applied in C# and in the kind of applications most

developers are paid to write, and it culminated in the writing of this book.

This book bridges the language gap for C# developers by showing how you can

leverage functional techniques in this language. It also bridges the domain gap by

showing how these techniques can be applied to typical business scenarios. I take a

pragmatic approach and cover functional techniques to the extent that they’re useful

in a typical

LOB application scenario, and dispense with most of the theory behind FP.

Ultimately, you should care about FP because it gives you the following:

■

Power—This simply means that you can get more done with less code. FP raises

the level of abstraction, allowing you to write high-level code while freeing you

from low-level technicalities that add complexity but no value.

■

Safety—This is especially true when dealing with concurrency. A program writ-

ten in the imperative style may work well in a single-threaded implementation

but cause all sorts of bugs when concurrency comes in. Functional code offers

much better guarantees in concurrent scenarios, so it’s only natural that we’re

seeing a surge of interest in

FP in the era of multicore processors.

■

Clarity—We spend more time maintaining and consuming existing code than

writing new code, so it’s important that our code be clear and intention-revealing.

As you learn to think functionally, achieving this clarity will become more natural.

If you’ve been programming in an object-oriented style for some time, it may take a

bit of effort and willingness to experiment before the concepts in this book come to

fruition. To make sure learning

FP is an enjoyable and rewarding process, I have two

recommendations:

■

Be patient—You may have to read some sections more than once. You may put

the book down for a few weeks and find that when you pick it up again, some-

thing that seemed obscure suddenly starts to make sense.

■

Experiment in code—You won’t learn unless you get your hands dirty. The book

provides many examples and exercises, and many of the code snippets can be

tested in the

REPL.

Your colleagues may be less eager to explore than you. Expect them to protest your

adoption of this new style and to look perplexed at your code and say things like, “why

not just do x?” (where x is boring, obsolete, and usually harmful). Don’t discuss. Just

sit back and watch them eventually turn around and use your techniques to solve

issues they run into again and again.

剩余411页未读，继续阅读

zxfwinder

粉丝: 1
资源: 32

C#中函数编程实战：提升代码可读性与效率

Functional Programming in C# How to write better C# code 无水印转化版pdf

Functional Programming in C#.pdf

Functional C#

functional programming in c++

hands-on functional programming in rust csdn

introducing erlang: getting started in functional programming

assignment and functional programming

UserWarning: The torchvision.transforms.functional_tensor module is deprecated in 0.15 and will be **removed in 0.17**. Please don't rely on it. You probably just need to use APIs in torchvision.transforms.functional or in torchvision.transforms.v2.functional. warnings.warn(

functional pca in functional data analysis

library(dplyr) # for data manipulation library(caret) # for model-building library(DMwR) # for smote implementation library(smotefamily) # for smote implementation library(purrr) # for functional programming (map) library(pROC)

最新资源

UserWarning: The torchvision.transforms.functional_tensor module is deprecated in 0.15 and will be removed in 0.17. Please don't rely on it. You probably just need to use APIs in torchvision.transforms.functional or in torchvision.transforms.v2.functional. warnings.warn(