Question

我目前正在进行exercism.io F＃追踪。对于那些不了解它的人来说，它解决了TDD风格的小问题，无法学习或改进编程语言。

最后两个任务是关于F＃中类的使用（或者在F＃中调用它们的类型）。其中一个任务使用具有余额和状态（打开/关闭）的BankAccount，可以使用函数进行更改。用法是这样的（取自测试代码）：

let test () =
    let account = mkBankAccount () |> openAccount
    Assert.That(getBalance account, Is.EqualTo(Some 0.0)

我编写了使用不可变的BankAccount类进行测试传递的代码，该类可以使用自由函数进行交互：

type AccountStatus = Open | Closed

type BankAccount (balance, status) =
    member acc.balance = balance
    member acc.status = status

let mkBankAccount () =
    BankAccount (0.0, Closed)

let getBalance (acc: BankAccount) =
    match acc.status with
    | Open -> Some(acc.balance)
    | Closed -> None

let updateBalance balance (acc: BankAccount) =
    match acc.status with
    | Open -> BankAccount (acc.balance + balance, Open)
    | Closed -> failwith "Account is closed!"

let openAccount (acc: BankAccount) =
    BankAccount (acc.balance, Open)

let closeAccount (acc: BankAccount) =
    BankAccount (acc.balance, Closed)

在开始学习F＃之前做了很多OO，这让我感到疑惑。更有经验的F＃开发人员如何使用类？为了更简单地回答这个问题，这里是我对F＃中的类/类型的主要关注：

在F＃中，是否以典型的OO方式使用课程？
首选不可变类吗？（我在上面的例子中发现它们令人困惑）
在F＃中访问/更改类数据的首选方法是什么？（类成员函数和获取/设置或允许管道的自由函数？静态成员如何允许管道并为函数提供合适的命名空间？）

如果问题含糊不清，我很抱歉。我不想在我的功能代码中养成糟糕的编码习惯，我需要一个关于良好实践的起点。

Answer 1

在F＃中是否阻止以典型的OO方式使用类？

它不是气馁，但它不是最有经验的F＃开发者会去的第一个地方。大多数F＃开发人员都会避免使用子类和OO范例，而是使用记录或有区别的联合，以及对它们进行操作的函数。

首选不可变类吗？

应尽可能选择不变性。话虽这么说，不可变类通常可以用其他方式表示（见下文）。

在F＃中访问/更改类数据的首选方法是什么？（类成员函数和获取/设置或允许管道的自由函数？静态成员如何允许管道并为函数提供适合的命名空间？）

这通常通过允许管道的功能来完成，但也可以直接进行访问。

对于上面的代码，使用记录而不是类更常见，然后将记录上工作的函数放入模块中。一个＆＃34;不可变的类＆＃34;像你的一样可以更简洁地写成记录：

Request

完成此操作后，使用它会变得更容易，因为您可以使用type BankAccount = { balance : float ; status : AccountStatus }返回修改后的版本：

with

请注意，将这些功能放入模块是很常见的：

let openAccount (acc: BankAccount) =
    { acc with status = Open }

Answer 2

问题：在F＃中是否阻止以典型的OO方式使用课程？

这并不反对F＃的本质。我认为有些情况是合理的。

但是，如果开发人员希望充分利用F＃优势（例如类型干扰，使用部分应用程序等功能模式的能力，简洁性）并且不受遗留系统和库的约束，则应限制类的使用。

F＃for fun and profit提供了pros and cons of using classes的快速摘要。

Ouestion：不可变类是首选吗？（我在上面的例子中发现它们令人困惑）

有时是，有时不是。我认为类的不变性给你带来了很多好处（它更容易推理类型的不变量等）但有时候使用不可变类可能有点麻烦。

我认为这个问题有点过于宽泛 - 如果fluent interfaces在面向对象设计中更受欢迎，它有点类似于问题 - 简短的答案是：它取决于。

在F＃中访问/更改类数据的首选方法是什么？（类成员函数和获取/设置或允许管道的自由函数？静态成员如何允许管道并为函数提供适合的命名空间？）

管道是F＃中的规范构造，所以我会选择静态成员。如果您的库是以其他语言使用的，那么您也应该在类中包含getter和setter。

修改

FSharp.org列出了非常具体的设计指南，其中包括：


✔根据标准，使用类来封装可变状态   面向对象方法。

✔使用受歧视的联盟作为类层次结构的替代方案   用于创建树状结构数据。

Answer 3

有几种方法可以看待这个问题。

这可能意味着几件事。对于POCO，不可变的F＃records是首选。然后对它们的操作返回 new 记录，并更改必需的字段。

type BankAccount { status: AccountStatus; balance: int }
let close acct = { acct with status = Closed } // returns a *new* acct record

这意味着你必须超越帐户的想法＆＃34;对象＆＃34;这代表了一个单一的东西＆＃34;。它只是您操作的数据，用于创建不同的数据，并最终（可能）存储到某个数据库中。

因此，不是OO范例acct.Close(); acct.PersistChanges()，而是let acct' = close acct; db.UpdateRecord(acct')。

对于＆＃34;服务＆＃34;在面向服务的体系结构（SOA）中＃34;但是，接口和类在F＃中是完全自然的。例如，如果你想要一个Twitter API，你可能会像在C＃中一样创建一个包装所有HTTP调用的类。我已经看过一些关于＆＃34; SOLID＆＃34; F＃中的意识形态完全避开SOA，但我从来没有想过如何在实践中完成这项工作。

就个人而言，我喜欢FP-OO-FP三明治，顶部是Suave的FP组合器，中间是使用Autofac的SOA，底部是FP记录。我发现它运作良好且可扩展。

FWIW，如果BankAccount无法达到平衡，您可能还想让Closed成为受歧视的联盟。在您的代码示例中尝试这一点。 F＃的一个好处是它使不合逻辑的状态无法代表。

type BankAccount = Open of balance: int | Closed

使用F＃中的类（可变性与不变性/成员与自由函数）

3 个答案: