f # comparaison de type générique

Question

J'essaie de déterminer si un obj retourné par un appel est d'un certain type. Voici mon code:

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

et une méthode qui a une portée MyType ...

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

Comment puis-je savoir si un est de type MyType?

Answer 1

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

Si vous vous souciez juste un MyType<X> pour une X inconnue,

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

Answer 2

Je ne pense pas que ce soit aussi simple que cela (rappelez-vous que je suis f # naïf) envisager le scénario follwoing où

1) nous utilisons des génériques sur plusieurs types 2) nous n'avons pas les informations de type pour un objet, donc il arrive dans une fonction comme type obj, comme dans certaines des bibliothèques .NET datacontract/serialization

que nous avons retravaillé ma proposition d'utiliser la réflexion:

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 

On dirait qu'il devrait y avoir beaucoup plus naturel de le faire ...