F＃编译器抛出OutOfMemoryException

2018-06-09 19:54:16

我使用的项目包含许多从单个基类继承的类。在单元测试中，我需要根据类型和数据比较收到的结果。

当条件列表包含足够多的不同条件的情况下，我通过类型使用匹配比较时，编译器会抛出OutOfMemoryException异常。

例如，下面的F＃代码在编译期间引发System.OutOfMemoryException（参数错误FS0193）（并且在抛出异常之前编译大约需要30秒）

type IBaseClass() = class end

type IChildClass1 () = inherit IBaseClass () 

type IChildClass2 () = inherit IBaseClass () 

type IChildClass3 () = inherit IBaseClass () 

type IChildClass4 () = inherit IBaseClass () 

type IChildClass5 () = inherit IBaseClass () 

type IChildClass6 () = inherit IBaseClass () 

type IChildClass7 () = inherit IBaseClass () 

type IChildClass8 () = inherit IBaseClass () 

type IChildClass9 () = inherit IBaseClass () 

type IChildClass10 () = inherit IBaseClass () 

type IChildClass11 () = inherit IBaseClass () 

type IChildClass12 () = inherit IBaseClass () 

type IChildClass13 () = inherit IBaseClass () 

type IChildClass14 () = inherit IBaseClass () 

type IChildClass15 () = inherit IBaseClass () 

type IChildClass16 () = inherit IBaseClass () 

type IChildClass17 () = inherit IBaseClass () 

type IChildClass18 () = inherit IBaseClass () 

type IChildClass19 () = inherit IBaseClass () 

type IChildClass20 () = inherit IBaseClass () 


let AreEqual (original: IBaseClass) (compareWith: IBaseClass) : bool =
    match (original, compareWith) with
    | (:? IChildClass1 as a), (:? IChildClass1 as b) -> a = b
    | (:? IChildClass2 as a), (:? IChildClass2 as b) -> a = b
    | (:? IChildClass3 as a), (:? IChildClass3 as b) -> a = b
    | (:? IChildClass4 as a), (:? IChildClass4 as b) -> a = b
    | (:? IChildClass5 as a), (:? IChildClass5 as b) -> a = b
    | (:? IChildClass6 as a), (:? IChildClass6 as b) -> a = b
    | (:? IChildClass7 as a), (:? IChildClass7 as b) -> a = b
    | (:? IChildClass8 as a), (:? IChildClass8 as b) -> a = b
    | (:? IChildClass9 as a), (:? IChildClass9 as b) -> a = b
    | (:? IChildClass10 as a), (:? IChildClass10 as b) -> a = b
    | (:? IChildClass11 as a), (:? IChildClass11 as b) -> a = b
    | (:? IChildClass12 as a), (:? IChildClass12 as b) -> a = b
    | (:? IChildClass13 as a), (:? IChildClass13 as b) -> a = b
    | (:? IChildClass14 as a), (:? IChildClass14 as b) -> a = b
    | (:? IChildClass15 as a), (:? IChildClass15 as b) -> a = b
    | (:? IChildClass16 as a), (:? IChildClass16 as b) -> a = b
    | (:? IChildClass17 as a), (:? IChildClass17 as b) -> a = b
    | (:? IChildClass18 as a), (:? IChildClass18 as b) -> a = b
    | (:? IChildClass19 as a), (:? IChildClass19 as b) -> a = b
    | (:? IChildClass20 as a), (:? IChildClass20 as b) -> a = b
    | _ -> false

当然，我可以添加IEquatable接口到我的IBaseClass类，这将避免使用这种匹配构造，或者将int Kind成员（或枚举）添加到IBaseClass接口，并且不通过类型进行匹配，而是通过一些int值进行匹配。

请注意，我试图在MS VS 2010和MSVS 11 Beta中编译相同的项目，并且具有相同的编译器错误

问题：为什么编译器的OutOfMemoryException发生在我的情况中（是否知道编译器错误或其他限制），我应该如何重新组织匹配条件以避免它？

更新当我把类放入歧视联盟并使用类似的匹配比较Fsc.exe毫无例外地编译项目

type AllClasses = 
    | ChildClass1 of IChildClass1 | ChildClass2 of IChildClass2 | ChildClass3 of IChildClass3 | ChildClass4 of IChildClass4 | ChildClass5 of IChildClass5 | ChildClass6 of IChildClass6
    | ChildClass7 of IChildClass7 | ChildClass8 of IChildClass8 | ChildClass9 of IChildClass9 | ChildClass10 of IChildClass10 | ChildClass11 of IChildClass11 | ChildClass12 of IChildClass12
    | ChildClass13 of IChildClass13 | ChildClass14 of IChildClass14 | ChildClass15 of IChildClass15 | ChildClass16 of IChildClass16 | ChildClass17 of IChildClass17 | ChildClass18 of IChildClass18 
    | ChildClass19 of IChildClass19 | ChildClass20 of IChildClass20

let AreEqual2 (original: AllClasses) (compareWith: AllClasses) : bool =
    match (original, compareWith) with
    | ChildClass1(a), ChildClass1(b) -> a = b
    | ChildClass2(a), ChildClass2(b) -> a = b
    | ChildClass3(a), ChildClass3(b) -> a = b
    | ChildClass4(a), ChildClass4(b) -> a = b
    | ChildClass5(a), ChildClass5(b) -> a = b
    | ChildClass6(a), ChildClass6(b) -> a = b
    | ChildClass7(a), ChildClass7(b) -> a = b
    | ChildClass8(a), ChildClass8(b) -> a = b
    | ChildClass9(a), ChildClass9(b) -> a = b
    | ChildClass10(a), ChildClass10(b) -> a = b
    | ChildClass11(a), ChildClass11(b) -> a = b
    | ChildClass12(a), ChildClass12(b) -> a = b
    | ChildClass13(a), ChildClass13(b) -> a = b
    | ChildClass14(a), ChildClass14(b) -> a = b
    | ChildClass15(a), ChildClass15(b) -> a = b
    | ChildClass16(a), ChildClass16(b) -> a = b
    | ChildClass17(a), ChildClass17(b) -> a = b
    | ChildClass18(a), ChildClass18(b) -> a = b
    | ChildClass19(a), ChildClass19(b) -> a = b
    | ChildClass20(a), ChildClass20(b) -> a = b
    | _ -> false

谢谢

这是由F＃编译器在这种情况下如何编译元组上的模式匹配引起的。我不完全确定你究竟在什么时候运行这个特定的问题，以及编译器是否使用其他方法，但这里解释了为什么它在这种情况下失败了......

如果您编写的模式与您的示例中的模式匹配，编译器实际上会生成一个决策树，用于测试第一个模式的original （ :? IChildClass1 ），然后生成两个分支。第一个分支检查compareWith是否也是IChildClass1 。如果是的话，它会运行第一个案例。其余的模式匹配然后在两个分支中被复制，所以你得到类似的东西（你可以通过查看编译的代码来查看使用ILSpy的较少数目的情况）：

if (original is IChildClass1)
  if (compareWith is IChildClass1)
    case #1
  if (original is IChildClass2)
    if (compareWith is IChildClass2)
      case #2
    if (original is IChildClass3)
      (...)
else
  if (original is IChildClass2)
    if (compareWith is IChildClass2)
      case #2
    if (original is IChildClass3)
      (...)

这意味着生成的代码的大小与此模式匹配中的个案数成指数成比例。对于20种情况，编译器会尝试创建2 ^ 20个分支，这（意外）会失败。

链接地址: http://www.djcxy.com/p/29273.html

上一篇: F# compiler throws OutOfMemoryException

下一篇: Why does StreamReader.ReadLine throw OutOfMemoryException?