12

私が使用するプロジェクトには、単一の基本クラスから継承された多くのクラスが含まれています。単体テストでは、受け取った結果を型とデータで比較する必要があります。

条件リストに十分な数の異なる条件が含まれている場合に型による一致比較を使用すると、コンパイラは 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

ありがとう

4

1 に答える 1

9

これは、この場合、F# コンパイラがタプルのパターン マッチングをコンパイルする方法が原因です。この特定の問題で正確にいつ実行され、コンパイラが他のアプローチを使用するかは完全にはわかりませんが、この場合に失敗する理由は次のとおりです...

例のようなパターン マッチングを記述すると、コンパイラは基本的に、original( :? IChildClass1) の最初のパターンをテストしてから 2 つの分岐を生成する決定木を生成します。最初のブランチ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 の分岐を作成しようとしますが、(当然のことながら) 失敗します。

于 2012-05-16T12:29:43.030 に答える