F#：我可以在调用基类的构造函数中使用 try/with 吗？

Question

我是一名新手 F# 程序员，在正确获取 F# 程序的语法时遇到了一些困难。

本质上，我想将这个 C# 代码转换为 F#：

class MyRiskyObject : BaseObject
{
    private string field;

    public MyRiskyObject(object foo, string data)
        : base(foo)
    {
        try
        {
            this.data = RiskyOperation(data);
        }
        catch (ArgumentException)
        {
            DoSomethingElse();
        }
    }
}

到目前为止，

type MyRiskyObject
    inherit BaseObject

    val field : string

    new (foo:object, data:string) = {
        inherit BaseObject(foo)
        try
          field = RiskyOperation()
        ????????
    }

我只是无法获得正确的语法......

---

编辑：

这是我正在处理的实际代码：

type RegExpObject = 
  inherit CommonObject

  val RegExp : Regex
  val Global : bool

  member x.IgnoreCase:bool =
    (x.RegExp.Options &&& RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase

  member x.MultiLine:bool =
    (x.RegExp.Options &&& RegexOptions.Multiline) = RegexOptions.Multiline

  new (env, pattern, options, global') =
    {
      inherit CommonObject(env, env.Maps.RegExp, env.Prototypes.RegExp) 

      // Here, I need to catch the exception, and instead call RaiseSyntaxError.
      RegExp = new Regex(pattern, options ||| RegexOptions.ECMAScript ||| RegexOptions.Compiled)

      Global = global'
    }
    then RegExp = new Regex(pattern, options ||| RegexOptions.ECMAScript ||| RegexOptions.Compiled)

  new (env, pattern) = 
    RegExpObject(env, pattern, RegexOptions.None, false)

Answer 1

为什么不将实际工作委托给一个单独的自由函数，这样工作就不必直接在类的构造函数中完成？

let createRegex pattern options =
  try
    Regex(pattern, options ||| RegexOptions.ECMAScript ||| RegexOptions.Compiled)
  with
  | :? System.ArgumentException -> RaiseSynaxError ()

那么你的类（如你的编辑中所示）将是：

type RegExpObject(env, pattern, options, global') //'
  inherit CommonObject(env, env.Maps.RegExp, env.Prototypes.RegExp)

  let RegExp = createRegex pattern options
  let Global = global' //'

  member x.IgnoreCase =
    (x.RegExp.Options &&& RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase

  member x.MultiLine =
    (x.RegExp.Options &&& RegexOptions.Multiline) = RegexOptions.Multiline

  new (env, pattern) = RegExpObject(env, pattern, RegexOptions.None, false)

这里的一个优点是，正如 @Brian 所指出的，不需要使用 val ，从而使类定义更加清晰。

Answer 2

尝试以下

type MyRiskyObject(foo : obj, data : string) as this =
    inherit BaseObject(foo)

    let mutable data = data;

    do
        try
            data <- this.RiskyOperation data 
        with 
            | :? System.ArgumentException -> this.DoSomethingElse()

具有不可变 let 绑定的替代示例，其中 RiskOperation 和 DoSomethingElse 不是 MyRiskObject 的成员

type MyRiskyObject(foo : obj, data : string) =
    inherit BaseObject(foo)

    let data = 
        try 
           OtherModule.RiskyOperation data
        with
        | :? System.ArgumentException -> 
           OtherModule.DoSomethingElse()
           data