f # ogólne porównanie typów

Question

Próbuję dowiedzieć się, czy obiekt zwracany z połączenia jest określonego typu. Tu jest mój kodu:

type MyType<'T>= 
    val mutable myArr : array 
    val mutable id : int 
    val mutable value : 'T 

iw jakiś sposób, który ma MyType w zakresie ...

let a = someFunThatReturnsObj() // a could be of type MyType 

Jak mogę dowiedzieć się, czy jest typu MyType?

Answer 1

match a with 
| :? MyType<int> as mt -> // it's a MyType<int>, use 'mt' 
| _ -> // it's not 

Jeśli zależy Ci tylko MyType<X> jakiegoś nieznanego X, następnie

let t = a.GetType() 
if t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<MyType<int>> then 
    // it is 

Answer 2

I nie sądzę, że to jest takie proste (należy pamiętać, jestem f # naiwny) rozważyć scenariusz follwoing gdzie

1) używamy generycznych na wielu typach 2) nie mamy informacji o typie obiektu, więc przychodzi on do funkcji typu obj, jak w niektórych bibliotekach .NET datacontract/serialization

I przerobione moją propozycję wykorzystania refleksji:

type SomeType<'A> = { 
     item : 'A 
    } 


type AnotherType<'A> = { 
    someList : 'A list 
} 

let test() = 

    let getIt() : obj = 
     let results : SomeType<AnotherType<int>> = { item = { someList = [1;2;3] }} 
     upcast results 

    let doSomething (results : obj) = 
     let resultsType = results.GetType() 
     if resultsType.GetGenericTypeDefinition() = typedefof<SomeType<_>> then 
      let method = resultsType.GetMethod("get_item") 
      if method <> null then 
       let arr = method.Invoke(results, [||]) 
       if arr.GetType().GetGenericTypeDefinition() = typedefof<AnotherType<_>> then 
        printfn "match" 

    getIt() |> doSomething 

Wydaje się, że powinien być bardziej naturalny sposób to zrobić ...