F# - 使 C# 库更加“F#”

Question

当您无法访问源代码时，使 ac# 库变得更加 F#ish 的最佳方法是什么？在我看来，您似乎有两个选择：扩展方法或封装在模块中的函数

……或者是否有一种更简洁、更少“黑客”的方式来完成这样的任务？

EF Code First 就是一个例子。

在我开始将函数包装到模块中之前：

override x.OnModelCreating(modelBuilder:DbModelBuilder) =

    // ----------- FileUpload Configuration ----------- //

    // General
    modelBuilder.Entity<FileUpload>()
        .ToTable("Some")
        |> ignore

    // Key
    modelBuilder.Entity<FileUpload>()
        .HasKey(ToLinq(<@ fun z -> z.ID @>))
        |> ignore

    // Properties
    modelBuilder.Entity<FileUpload>()
        .Property(ToLinq(<@ fun z -> z.Path @>))
        |> ignore

    modelBuilder.Entity<FileUpload>()
        .Property(ToLinq(<@ fun z -> z.Extension @>))
        |> ignore

以及之后：

override x.OnModelCreating(modelBuilder:DbModelBuilder) =
    let finished = ignore

    // ----------- FileUpload Configuration ----------- //
    let entity = modelBuilder.Entity<FileUpload>()

    // General
    entity
        |> ETC.toTable "Some"

    // Key
    entity 
        |> ETC.hasKey(fun z -> z.ID) 
        |> finished

    // Properties
    entity
        |> ETC.property(fun z -> z.Path)
        |> finished

    entity
        |> ETC.property(fun z -> z.Extension)
        |> finished

后一个示例中使用的模块：

module ETC =
    let property (expr:'a -> string) (cfg:EntityTypeConfiguration<'a>) = 
        cfg.Property(ToLinq(<@ expr @>))

    let hasKey (expr:'a -> 'b) (cfg:EntityTypeConfiguration<'a>) = 
        cfg.HasKey(% expr)

    let hasForeignKey (expr: 'a -> 'b) (cfg:DependentNavigationPropertyConfiguration<'a>) = 
        cfg.HasForeignKey(% expr)

    let hasMany (expr: 'a -> ICollection<'b>) (cfg:EntityTypeConfiguration<'a>) = 
        cfg.HasMany(% expr)

    let hasRequired (expr: 'a -> 'b) (cfg:EntityTypeConfiguration<'a>) = cfg.HasRequired(ToLinq(<@ expr @>))

    let withRequired (expr: 'a -> 'a) (cfg:ManyNavigationPropertyConfiguration<'a,'a>) = 
        cfg.WithRequired(% expr)

    let willCascadeOnDelete (cfg:CascadableNavigationPropertyConfiguration) = 
        cfg.WillCascadeOnDelete()

    let isMaxLength(cfg:StringPropertyConfiguration) = 
        cfg.IsMaxLength()

    let toTable (s:string) (cfg:EntityTypeConfiguration<'a>) = 
        cfg.ToTable s

它可能看起来不是一个显着的改进，因为我还没有编写一个完整的示例（懒惰的我） - 但正如你所见，后者但我的问题是，将方法包装到函数中并将这些函数包装到模块中以提供更实用的方式来使用这些 C# 库是否是不好的做法？

Answer 1

首先，我认为你的包装器不会工作 - 在你的 ETC.property 中，你不能将普通函数作为参数，然后在 ETC.property 中引用它/代码>。您需要传递已经引用的 lambda 函数（并且参数的类型需要为 Expr<'a -> string>：

entity |> ETC.property <@ fun z -> z.Path @>
       |> finished

对于您原来的问题 - 我认为使用带有包装器的模块函数是一个不错的选择。您可以通过指定属性的管道传递实体的表示，从而使语法更好一些，通过适当的定义，您可以得到如下内容：

EF.entity<FileUpload> modelBuilder
|> EF.hasKey <@ fun z -> z.ID @>
|> EF.property <@ fun z -> z.Path @>
|> EF.property <@ fun z -> z.Extension @>
|> EF.toTable "Some"

想法是您将拥有某种类型 EntityInfo<'T> 包装了通过调用 modelBuilder.Entity<'T>() 获得的内容，这些函数的类型如下：

EF.hasKey : Expr<'a -> 'b> -> EntityInfo<'T> -> EntityInfo<'T>
EF.toTable : string -> EntityInfo<'T> -> unit

我有意使用 unit< /code> 作为 toTable 的结果，因为它可能总是需要调用（因此我们可以将其移至末尾并避免显式ignore）。函数只需指定属性，然后返回原始的 EntityInfo<'T> 对象。

您可以使其变得更加奇特，并将整个规范编写为引用。例如：

modelBuilder |> EF.entity<FileUpload> <@ fun z ->
    EF.hasKey z.ID
    EF.property z.Path
    EF.property z.Extension
    EF.toTable "Some" @>

这不是可执行代码 - 这些函数只是虚拟函数。诀窍在于您可以处理报价并基于此调用 EF 方法。然而，这比较棘手——您必须进行大量的报价处理，而且这也不是太好。