C# Réflexion avec la récursivité

Je suis en train de travailler sur la Réflexion , mais je suis coincé tout en faisant de la récursivité.

Code :

public class User {
  public string Name;
  public int Number;
  public Address Address;    
}


public class Address {
 public string Street;
 public string State;
 public string Country;
}

maintenant, je suis d'impression les valeurs.

 Type t = user.GetType();  
 PropertyInfo[] props = t.GetProperties(); 
 foreach (PropertyInfo prp in props)  
 {  
   if(!prp.GetType().IsPrimitive && prp.GetType().IsClass) 
   {
     //Get the values of the Inner Class.
     //i am stucked over here , can anyone help me with this.

           Type ty = prp.GetType();
           var prpI = ty.GetProperties();
           //var tp = ty.GetType().;
            foreach (var propertyInfo in prpI)
            {
            var value = propertyInfo.GetValue(prp);
            var stringValue = (value != null) ? value.ToString() : "";
            console.WriteLine(prp.GetType().Name + "." + propertyInfo.Name+" Value : " +stringValue);    
            }
   }
   else
   {    
     var value = prp.GetValue(user);   
     var stringValue = (value != null) ? value.ToString() : "";
     console.writeline(user.GetType().Name + "." + prp.Name+" Value : " +stringValue); 
   }
 }

je veux savoir comment faire pour savoir si la propriété est une classe ou d'une primitive. et faire la récursivité si c'est une classe.

Pourquoi ne pas vous afficher quelque chose qui au moins compile?
Êtes-vous sûr que la réflexion est la solution du problème? Pourquoi voulez-vous faire cela?
Pourquoi n'essayez-vous pas Automapper il va faire le travail.
Si vous voulez travailler de cette façon, un Dictionnaire au lieu d'une classe serait faire le travail.
le Automapper fonctionnera sûrement, mais je veux écrire ce code sur mon propre. si quelqu'un peut m'aider comment faire pour savoir si la propriété est primitif ou de sa classe.
Que les sons inutiles, ne pas tomber dans le "Pas inventé ici" piège...
double possible de classes Imbriquées et récursivité

InformationsquelleAutor Syed Abdul Qadeer | 2013-02-04

c#nested nested-class recursion reflection

13

Tout d'abord, si vous voulez accéder aux propriétés d'un type, assurez-vous d'utiliser un type qui a des propriétés:
```
public class User {
  public string Name{get;set;}
  public int Number{get;set;}
  public Address Address{get;set;}    
}


public class Address {
 public string Street{get;set;}
 public string State{get;set;}
 public string Country{get;set;}
}
```
Deuxième, prp.GetType() retournera toujours PropertyInfo. Vous êtes à la recherche pour prp.PropertyType, qui sera de retour le Type de la propriété.

Aussi, if(!prp.GetType().IsPrimitive && prp.GetType().IsClass) ne fonctionne pas de la manière que vous voulez, parce que String par exemple, est une de la classe et aussi pas un primitif. Mieux utiliser prp.PropertyType.Module.ScopeName != "CommonLanguageRuntimeLibrary".

Dernier mais non le moins, d'utiliser la récursivité, en fait, vous avez de mettre votre code dans une méthode.

Voici un exemple complet:
```
IEnumerable<string> GetPropertInfos(object o, string parent=null)
{
    Type t = o.GetType();  
    PropertyInfo[] props = t.GetProperties(BindingFlags.Public|BindingFlags.Instance);
    foreach (PropertyInfo prp in props)  
    {  
        if(prp.PropertyType.Module.ScopeName != "CommonLanguageRuntimeLibrary")
        {
            //fix me: you have to pass parent + "." + t.Name instead of t.Name if parent != null
            foreach(var info in GetPropertInfos(prp.GetValue(o), t.Name))
                yield return info; 
        }
        else
        {    
            var value = prp.GetValue(o);   
            var stringValue = (value != null) ? value.ToString() : "";
            var info = t.Name + "." + prp.Name + ": " + stringValue;
            if (String.IsNullOrWhiteSpace(parent))
                yield return info; 
            else
                yield return parent + "." + info; 
        }
    }
}
```
Utilisée comme ceci:
```
var user = new User { Name = "Foo", Number = 19, Address = new Address{ Street="MyStreet", State="MyState",  Country="SomeCountry" }    };
foreach(var info in GetPropertInfos(user))
    Console.WriteLine(info);
```
il sera de sortie
```
User.Name: Foo
User.Number: 19
User.Address.Street: MyStreet
User.Address.State: MyState
User.Address.Country: SomeCountry
```
- merci de ton bro, la sortie est exactement comme je le voulais, tout simplement remarquable , j'ai été de me gratter la tête depuis ce matin , je voulais juste dire un GRAND MERCI.
- Cela a le potentiel de causer des stackoverflow dans le cas d'un appel récursif de la classe. c'est à dire La classe Utilisateur a une propriété qui est également un Utilisateur. En général, tous les récursive méthodes devraient avoir un moyen de prévenir une récurrence infinie cas. (Comme l'utilisation d'un maxDepth argument)
- Vrai, mais je pense que de plus en plus problématique scénario à surveiller sont les dépendances circulaires, comme par exemple, un User istance de la référence à une Address instance qui, à son tour références de la même User instance de nouveau.
- En effet, c'est ce que je voulais dire par un appel récursif de la classe. Un Utilisateur de la classe qui contient également une propriété de l'Utilisateur (ou de toute Propriété qui a une propriété de l'Utilisateur). Je suis d'accord de référence circulaire est le meilleur terme, comme une récursion infinie serait le résultat.
- si l'Utilisateur de la classe est dans une autre bibliothèque de classes, je ne vois pas comment ce code fonctionne. Le Module.ScopeName serait alors quelque chose comme WhateverClassLibrary.dll
- Depuis "WhateverClassLibrary.dll" != "CommonLanguageRuntimeLibrary" je ne vois pas votre problème.
- Mon problème est que dans le deuxième niveau de la récursivité mon Type t est égal à {Nom = "RuntimeType" FullName = "le Système de.RuntimeType"}. Que puis-je faire?
InformationsquelleAutor sloth
3

Tout d'abord, évitez d'utiliser la réflexion, à moins que vous vraiment besoin. C'est lent, c'est salissant, c'est limite undebuggable (et j'adore ça, mais c'est une autre chose)

Si vous voulez vider tout le contenu de votre objet, je vous recommande de transférer des objets eux-mêmes, ils doivent connaître leur état intérieur. Vous pouvez utiliser les objets ToString méthode pour écrire leur état intérieur, ou vous pouvez définir une interface pour l'affichage de l'état interne
```
interface IStateDisplay
{
   string GetInnerState();
}
```
et vos objets en œuvre. Ensuite le code pour afficher les propriétés de l'être
```
Console.WriteLine(user.GetInnerState());
```
Une autre option serait d'utiliser un outil comme AutoMapper qui cache la complexité et les subtilités de la réflexion à partir de vous, et expose une belle API à utiliser.

Toutefois, si vous êtes l'apprentissage de la réflexion, l'impression de l'état d'un objet complexe est un bel exercice. Quelques conseils dans ce sens:
```
public string Name;
```
n'est pas une propriété, il est un domaine, de sorte que type.GetProperties() ne la ramène pas. Lire sur ce que le C# propriétés sont, et comment ils sont utilisés et définis. Un minimum de déclaration de la propriété est
```
public string Name {get; set;}
```
Aussi, prp.GetType() sera de retour les informations de type pour la PropertyInfo type, pas pour le type de la propriété qu'il contient. Ce qu'il vous faut dans ce cas est le prp.PropertyType propriété.

Prochaine, je ne pense pas que le Type.IsPrimitive vérifier est ce que vous voulez qu'il soit. Cette propriété renvoie la valeur true pour l'Boolean, Byte, SByte, Int16, UInt16, Int32 UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, et un Seul des types, et false pour tout le reste. Le plus important typeof(string).IsPrimitive renvoie la valeur false.

Sur la même note, je ne pense pas que le Type.IsClass vérifier est ce que vous voulez qu'il soit, soit. Comme vous vous en servez, que seulement de vérifier si la propriété est d'une valeur ou d'un type de référence, et que les types de valeur (struct) peut aussi être très complexes et contiennent des propriétés et domaines de leur propre, la vérification n'a pas de sens.
- Concept de mise en œuvre de l'état de l'interface est de l'or pur. MANIÈRE de mieux qu'un tas de compliqué et inutile de réflexion. J'ai utilisé un état de l'interface sur certains de mon point de vue, les modèles de (commune) des propriétés de l'ID que j'avais besoin d'accéder à une action de filtre. Travaille incroyable. Thx.
InformationsquelleAutor SWeko

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
namespace Extensions
{
public static class ObjectExtension
{
public static string ToStringProperties(this object o)
{
return o.ToStringProperties(0);
}
public static string ToStringProperties(this object o, int level)
{
StringBuilder sb = new StringBuilder();
string spacer = new String(' ', 2 * level);
if (level == 0) sb.Append(o.ToString());
sb.Append(spacer);
sb.Append("{\r\n");
foreach (PropertyInfo pi in o.GetType().GetProperties())
{
if (pi.GetIndexParameters().Length == 0)
{
sb.Append(spacer);
sb.Append("  ");
sb.Append(pi.Name);
sb.Append(" = ");
object propValue = pi.GetValue(o, null);
if (propValue == null)
{
sb.Append(" <null>");
} else {
if (IsMyOwnType(pi.PropertyType))
{
sb.Append("\r\n");
sb.Append(((object)propValue).ToStringProperties(level + 1));
} else{
sb.Append(propValue.ToString());
}
}
sb.Append("\r\n");
}
}
sb.Append(spacer);
sb.Append("}\r\n");
return sb.ToString();
}
private static bool IsMyOwnType(Type t) 
{
return (t.Assembly == Assembly.GetExecutingAssembly());
}
}
}

InformationsquelleAutor user1700502

Merci @Paresse, vous code est très utile. C'est une légère modification de ceux qui obtiennent un "Objet de référence non définie à une instance d'un objet." erreur. Il crée une instance de l'objet est null et gère également les tableaux. Plus doit être fait pour traiter tous les types de collection, mais c'est un début.

public static IEnumerable<string> GetPropertInfos(object o, string parent = null)
{
Type t = o.GetType();
//  String namespaceValue = t.Namespace;
PropertyInfo[] props = t.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (PropertyInfo prp in props)
{
if (prp.PropertyType.Module.ScopeName != "CommonLanguageRuntimeLibrary")
{
//fix me: you have to pass parent + "." + t.Name instead of t.Name if parent != null
object value = prp.GetValue(o);
if (value == null)
{
value =
Activator.CreateInstance(Type.GetType(
(prp.PropertyType).AssemblyQualifiedName.Replace("[]", "")));
}
var propertInfos = GetPropertInfos(value, t.Name);
foreach (var info in propertInfos)
yield return info;
}
else
{
var type = GetTypeName(prp);
var info = t.Name + "." + prp.Name ;
if (String.IsNullOrWhiteSpace(parent))
yield return info;
else
yield return parent + "." + info;
}
}
}

InformationsquelleAutor kazi develop

-1

Vous pouvez utiliser le Type.IsValueType propriété.

InformationsquelleAutor Mehmet Ataş

Vous devez vous connecter pour publier un commentaire.