Syntax 使用替代类语法在构造函数中添加代码

我想在上面的构造函数中添加此代码：

type Foo = 
    class
        inherit Bar

        val _stuff : int

        new (stuff : int) = {
            inherit Bar()
            _stuff = stuff
        }
    end

if（stuff<0）则引发（ArgumentOutOfRangeException“stuff必须为正”）
else（）

---

我怎样才能在F#中做到这一点呢？

Hm，看起来就像语法上的一个漏洞；我会提出一个建议。您可以这样处理它：

if (stuff < 0) then raise (ArgumentOutOfRangeException "Stuff must be positive.")
else ()

type Bar（）=类结束
类型Foo=
阶级
继承条
val_stuff:int
私有new（stuff:int，dummyUnused:int）={
继承条（）
_东西
}
新的（资料：int）=
Foo（stuff，0）
然后
如果（stuff<0），那么
raise（System.ArgumentOutOfRangeException
“东西必须是正面的。”）
结束

其中，第一个构造函数是一个伪构造函数，其唯一目的是允许第二个实构造函数使用“其他构造函数然后是副作用”语法调用它

然而，如果你使用它，你会活得更长，更快乐

type Bar() = class end

type Foo =     
    class        
        inherit Bar        
        val _stuff : int        
        private new (stuff : int, dummyUnused : int) = {            
            inherit Bar()            
            _stuff = stuff        
            }
        new (stuff : int) = 
            Foo(stuff, 0)
            then
                if (stuff < 0) then 
                    raise (System.ArgumentOutOfRangeException 
                             "Stuff must be positive.")
    end

输入Foo（\u stuff:int）=
继承条（）
做
如果（_stuff<0），则
raise（System.ArgumentOutOfRangeException“Stuff必须为正值”）

相反尽可能将类与主构造函数一起使用。（“主构造函数”是类声明中的构造函数-在上面的示例中，“type Foo”后面的参数是构造函数参数，而类体中的任何let/do语句都定义了主构造函数体。）

编辑：

这里有一个更简单的解决方法

type Foo(_stuff:int) =     
    inherit Bar()
    do
        if (_stuff < 0) then 
            raise (System.ArgumentOutOfRangeException "Stuff must be positive.")

类型Foo=
阶级
继承条
val_stuff:int
新的（资料：int）=
let效应=
如果（stuff<0），那么
raise（System.ArgumentOutOfRangeException
“东西必须是正面的。”）
{            
继承条（）
_东西
}
结束

您可以在不需要任何解决方法的情况下执行此操作，但是初始左卷发的位置相当敏感（或者可能解析器有缺陷？）。要首先实现效果，请执行以下操作：

type Foo =     
    class        
        inherit Bar        
        val _stuff : int        
        new (stuff : int) = 
            let effect = 
                if (stuff < 0) then 
                    raise (System.ArgumentOutOfRangeException 
                            "Stuff must be positive.")
            {            
            inherit Bar()            
            _stuff = stuff        
            }
    end

输入Foo=
班
继承条
val_stuff:int
新的（资料：int）=
如果stuff<0，则引发（System.ArgumentOutOfRangeException（“stuff必须为正”））
{ 
继承条（）
_东西
}
结束

要实现第二种效果：

type Foo =
  class
    inherit Bar
    val _stuff : int
    new (stuff : int) = 
      if stuff < 0 then raise (System.ArgumentOutOfRangeException("Stuff must be positive"))
      { 
        inherit Bar() 
        _stuff = stuff 
      }
  end

输入Foo=
班
继承条
val_stuff:int
新的（资料：int）=
{ 
继承条（）
_东西
}
然后，如果stuff<0，则引发（System.ArgumentOutOfRangeException（“stuff必须为正”））
结束

谢谢！它只是工作。大括号的位置确实很挑剔。谢谢。我知道主ctor，在我的例子中，我需要几个ctor，所以唯一的方法是类/结束语法。

type Foo =
  class
    inherit Bar
    val _stuff : int
    new (stuff : int) = 
      { 
        inherit Bar() 
        _stuff = stuff 
      }
      then if stuff < 0 then raise (System.ArgumentOutOfRangeException("Stuff must be positive"))
  end