F＃コンパイラがOutOfMemoryExceptionをスローする

Question

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

と一致する場合コンディションリストには十分多くの異なる条件が含まれている場合の型による比較コンパイラはOutOfMemoryExceptionをスローします。 F＃コード次たとえば

は、コンパイル時にSystem.OutOfMemoryExceptionに（パラメータエラーFS0193）を発生させます（コンパイルは、例外がスローされる前に約30秒かかりました）私はIEquatableインターフェイスを追加できることを確認するために

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インターフェイスにint型カインドメンバー（または列挙型）を追加していない種類によって、いくつかによって試合を行います私のIBaseClassクラスint値。

注、私はMS VS 2010およびMSVS 11のベータ版を同じプロジェクトをコンパイルしようとした、と同じコンパイラエラー

質問持っていた：コンパイラの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 

おかげ

Answer 1

は、これはどのようにF＃コンパイラによって引き起こされますこの場合、タプル上のパターンマッチングをコンパイルします。私は完全にこの特定の問題で実行するとき、コンパイラが他のアプローチを使用するときは完全にはわかりませんが、ここではなぜこの場合失敗するのか説明しています...

あなたの例では、コンパイラは、最初にoriginal（:? IChildClass1）の最初のパターンをテストし、2つの分岐を生成する決定木を生成します。最初のブランチはcompareWithがIChildClass1であるかどうかをチェックします。はいの場合、最初のケースが実行されます。

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) 
     (...) 

この：あなたのようなものを（あなたがILSpyを使用して例数が少ないためにコンパイルされたコードを見て、これをチェックすることができます）を取得してパターンマッチングの残りの部分は、その後は、枝の両方にを重複しています生成されたコードのサイズがこのパターンマッチングのケースの数に指数関数的に比例することを意味します。 20件の場合、コンパイラは2^20のブランチを作成しようとしますが、それは失敗することはありません。