我使用的项目包含许多从单个基类继承的类。在单元测试中,我需要按类型和数据比较接收到的结果。
当我在情况列表中包含足够多不同条件的情况下使用类型匹配比较时,编译器会抛出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
肯定地说,我可以在我的IBaseClass类中添加IEquatable接口来避免使用这样的匹配构造,或者将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
谢谢
IChildClass1-20
作为举例,而不是实际的代码?我认为编译器本身不应该抛出OutOfMemoryException
(但我没有答案)。 - Abel