Modèle f # correspondant aux types

Je suis en train de récursivement imprimer tous une propriétés des objets et les sous-propriétés de type de etc. Mon modèle d'objet est comme suit...

type suggestedFooWidget = {
    value: float ; 
    hasIncreasedSinceLastPeriod: bool ;
}

type firmIdentifier = {
    firmId: int ;
    firmName: string ;
}
type authorIdentifier = {
    authorId: int ;
    authorName: string ;
    firm: firmIdentifier ;
}

type denormalizedSuggestedFooWidgets = {
    id: int ; 
    ticker: string ;
    direction: string ;
    author: authorIdentifier ;
    totalAbsoluteWidget: suggestedFooWidget ;
    totalSectorWidget: suggestedFooWidget ;
    totalExchangeWidget: suggestedFooWidget ;
    todaysAbsoluteWidget: suggestedFooWidget ;
    msdAbsoluteWidget: suggestedFooWidget ;
    msdSectorWidget: suggestedFooWidget ;
    msdExchangeWidget: suggestedFooWidget ;
}

Et mon récursivité est basé sur le filtrage suivant...

let rec printObj (o : obj) (sb : StringBuilder) (depth : int) 
    let props = o.GetType().GetProperties()
    let enumer = props.GetEnumerator()
    while enumer.MoveNext() do
        let currObj = (enumer.Current : obj)
        ignore <|
             match currObj with
             | :? string as s -> sb.Append(s.ToString())
             | :? bool as c -> sb.Append(c.ToString())
             | :? int as i -> sb.Append(i.ToString())
             | :? float as i -> sb.Append(i.ToString())
             | _ ->  printObj currObj sb (depth + 1)
    sb

Dans le débogueur je vois que currObj est de type string, int, float, etc, mais il saute toujours defualt affaire au fond. Une idée de pourquoi ce qui se passe?

source d'informationauteur PhilBrown

f#pattern-matching types

15

Comme d'autres l'ont souligné, vous avez besoin d'invoquer la GetValue membre pour obtenir la valeur de la propriété - l'itération que vous avez mis en œuvre itère sur PropertyInfo objets, qui sont des "descripteurs de la propriété" - et non pas des valeurs réelles. Cependant, je n'arrive pas à comprendre pourquoi êtes-vous à l'aide de GetEnumerator et while boucle explicitement lorsque la même chose peut être écrite à l'aide de for boucle.

Aussi, vous n'avez pas besoin d'ignorer la valeur retournée par la sb.Append d'appel vous pouvez renvoyer simplement comme le résultat d'ensemble (parce que c'est la StringBuilder). Ce sera effectivement rendre le code plus efficace (parce qu'il permet à la queue-appel optimizataion). Comme un dernier point, vous n'avez pas besoin ToString dans sb.Append(..)parce que le Append méthode est surchargée et fonctionne pour tous les types standard.

Donc après un peu de simplification, vous pouvez obtenir quelque chose comme ceci (ce n'est pas vraiment à l'aide de la depth paramètre, mais je suppose que vous voulez l'utiliser pour quelque chose plus tard):
```
let rec printObj (o : obj) (sb : StringBuilder) (depth : int) =
  let props = o.GetType().GetProperties() 
  for propInfo in props do
    let propValue = propInfo.GetValue(o, null)
    match propValue with 
    | :? string as s -> sb.Append(s) 
    | :? bool as c -> sb.Append(c) 
    | :? int as i -> sb.Append(i) 
    | :? float as i -> sb.Append(i) 
    | _ ->  printObj currObj sb (depth + 1) 
```

Voici comment je l'ai eu à travailler...

 let getMethod = prop.GetGetMethod()
 let value = getMethod.Invoke(o, Array.empty)
     ignore <|
         match value with
         | :? float as f -> sb.Append(f.ToString() + ", ") |> ignore
                            ...

1

Dans votre exemple, enumer.Current est un objet contenant une PropertyInfo. Cela signifie que currObj est toujours un PropertyInfo objet, et correspond toujours à la dernière affaire dans votre déclaration.

Puisque vous êtes intéressés par le type de la valeur de la propriété, vous aurez besoin d'appeler le GetValue() la méthode de la PropertyInfo pour obtenir la valeur réelle de la propriété (comme dans ChaosPandion de réponse).

Depuis un Énumérateur renvoie ses valeurs en tant qu'objets, vous aurez également besoin de jeter l'enum.le courant pour une PropertyInfo avant de pouvoir accéder à GetValue.

Essayez de remplacer
```
let currObj = (enumer.Current : obj)
```
avec
```
let currObj = unbox<PropertyInfo>(enumer.Current).GetValue (o, null)
```
Avec ce changement, je peux obtenir votre code de travail (FSI):
```
>  let test = {authorId = 42; authorName = "Adams"; firm = {firmId = 1; firmName = "GloboCorp inc."} };;
> string <| printObj test (new StringBuilder()) 1;;
val it : string = "42Adams1GloboCorp inc."
```
0

Êtes-vous sûr que le programme ne se comporte pas comme prévu? Le débogueur s'étend sur ne sont pas toujours fiables.
0

Vous voulez quelque chose comme cela à la place.
```
let rec printObj (o : obj) (sb : StringBuilder) (depth : int) 
    let props = o.GetType().GetProperties() :> IEnumerable<PropertyInfo>
    let enumer = props.GetEnumerator()
    while enumer.MoveNext() do
        let currObj = (enumer.Current.GetValue (o, null)) :> obj
        ignore <|
             match currObj with
             | :? string as s -> sb.Append(s.ToString())
             | :? bool as c -> sb.Append(c.ToString())
             | :? int as i -> sb.Append(i.ToString())
             | :? float as i -> sb.Append(i.ToString())
             | _ ->  printObj currObj sb (depth + 1)
    sb
```
Ce qui est à venir à partir de MSDN docs sur le Array classe:

Dans le .NET Framework version 2.0, le
Tableau de la classe implémente l'
Système.Les Collections.Génériques.IList,
Système.Les Collections.Génériques.ICollection,
et
Système.Les Collections.Génériques.IEnumerable
les interfaces génériques. L'
les implémentations sont fournis aux tableaux
au moment de l'exécution, et, par conséquent, ne sont pas
visible à la documentation de construire
outils. En conséquence, le générique
les interfaces n'apparaissent pas dans le
syntaxe de déclaration pour le Tableau
de la classe, et il n'y a pas de référence
thèmes pour l'interface des membres qui sont
accessible uniquement par coulée d'un tableau à
le générique type d'interface (explicite
des implémentations d'interface). La clé
chose d'être conscient de quand vous lancez un
tableau à l'une de ces interfaces est
que les membres qui ajouter, insérer ou
supprimer des éléments jeter
NotSupportedException.

Vous devez vous connecter pour publier un commentaire.