C# : Impression de toutes les propriétés d'un objet

Question

Existe-t-il une méthode intégrée à .NET permettant d'écrire toutes les propriétés et autres d'un objet dans la console ?

On pourrait utiliser la réflexion bien sûr, mais je suis curieux de savoir si cela existe déjà... d'autant plus que vous pouvez le faire dans Visual Studio dans la fenêtre immédiate. Là, vous pouvez taper le nom d'un objet (en mode débogage), appuyer sur Entrée, et il est imprimé assez joliment avec tous ses éléments.

Une telle méthode existe-t-elle ?

Answer 1

Vous pouvez utiliser le TypeDescriptor pour ce faire :

foreach(PropertyDescriptor descriptor in TypeDescriptor.GetProperties(obj))
{
    string name = descriptor.Name;
    object value = descriptor.GetValue(obj);
    Console.WriteLine("{0}={1}", name, value);
}

TypeDescriptor vit dans le System.ComponentModel et est l'API que Visual Studio utilise pour afficher votre objet dans son navigateur de propriétés. En fin de compte, elle est basée sur la réflexion (comme toute solution le serait), mais elle fournit un assez bon niveau d'abstraction de l'API de réflexion.

Answer 2

Sur la base de l'ObjectDumper des exemples LINQ, j'ai créé une version qui vide chacune des propriétés sur sa propre ligne.

Cet échantillon de classe

namespace MyNamespace
{
    public class User
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public Address Address { get; set; }
        public IList<Hobby> Hobbies { get; set; }
    }

    public class Hobby
    {
        public string Name { get; set; }
    }

    public class Address
    {
        public string Street { get; set; }
        public int ZipCode { get; set; }
        public string City { get; set; }    
    }
}

a une sortie de

{MyNamespace.User}
  FirstName: "Arnold"
  LastName: "Schwarzenegger"
  Address: { }
    {MyNamespace.Address}
      Street: "6834 Hollywood Blvd"
      ZipCode: 90028
      City: "Hollywood"
  Hobbies: ...
    {MyNamespace.Hobby}
      Name: "body building"

Voici le code.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Text;

public class ObjectDumper
{
    private int _level;
    private readonly int _indentSize;
    private readonly StringBuilder _stringBuilder;
    private readonly List<int> _hashListOfFoundElements;

    private ObjectDumper(int indentSize)
    {
        _indentSize = indentSize;
        _stringBuilder = new StringBuilder();
        _hashListOfFoundElements = new List<int>();
    }

    public static string Dump(object element)
    {
        return Dump(element, 2);
    }

    public static string Dump(object element, int indentSize)
    {
        var instance = new ObjectDumper(indentSize);
        return instance.DumpElement(element);
    }

    private string DumpElement(object element)
    {
        if (element == null || element is ValueType || element is string)
        {
            Write(FormatValue(element));
        }
        else
        {
            var objectType = element.GetType();
            if (!typeof(IEnumerable).IsAssignableFrom(objectType))
            {
                Write("{{{0}}}", objectType.FullName);
                _hashListOfFoundElements.Add(element.GetHashCode());
                _level++;
            }

            var enumerableElement = element as IEnumerable;
            if (enumerableElement != null)
            {
                foreach (object item in enumerableElement)
                {
                    if (item is IEnumerable && !(item is string))
                    {
                        _level++;
                        DumpElement(item);
                        _level--;
                    }
                    else
                    {
                        if (!AlreadyTouched(item))
                            DumpElement(item);
                        else
                            Write("{{{0}}} <-- bidirectional reference found", item.GetType().FullName);
                    }
                }
            }
            else
            {
                MemberInfo[] members = element.GetType().GetMembers(BindingFlags.Public | BindingFlags.Instance);
                foreach (var memberInfo in members)
                {
                    var fieldInfo = memberInfo as FieldInfo;
                    var propertyInfo = memberInfo as PropertyInfo;

                    if (fieldInfo == null && propertyInfo == null)
                        continue;

                    var type = fieldInfo != null ? fieldInfo.FieldType : propertyInfo.PropertyType;
                    object value = fieldInfo != null
                                       ? fieldInfo.GetValue(element)
                                       : propertyInfo.GetValue(element, null);

                    if (type.IsValueType || type == typeof(string))
                    {
                        Write("{0}: {1}", memberInfo.Name, FormatValue(value));
                    }
                    else
                    {
                        var isEnumerable = typeof(IEnumerable).IsAssignableFrom(type);
                        Write("{0}: {1}", memberInfo.Name, isEnumerable ? "..." : "{ }");

                        var alreadyTouched = !isEnumerable && AlreadyTouched(value);
                        _level++;
                        if (!alreadyTouched)
                            DumpElement(value);
                        else
                            Write("{{{0}}} <-- bidirectional reference found", value.GetType().FullName);
                        _level--;
                    }
                }
            }

            if (!typeof(IEnumerable).IsAssignableFrom(objectType))
            {
                _level--;
            }
        }

        return _stringBuilder.ToString();
    }

    private bool AlreadyTouched(object value)
    {
        if (value == null)
            return false;

        var hash = value.GetHashCode();
        for (var i = 0; i < _hashListOfFoundElements.Count; i++)
        {
            if (_hashListOfFoundElements[i] == hash)
                return true;
        }
        return false;
    }

    private void Write(string value, params object[] args)
    {
        var space = new string(' ', _level * _indentSize);

        if (args != null)
            value = string.Format(value, args);

        _stringBuilder.AppendLine(space + value);
    }

    private string FormatValue(object o)
    {
        if (o == null)
            return ("null");

        if (o is DateTime)
            return (((DateTime)o).ToShortDateString());

        if (o is string)
            return string.Format("\"{0}\"", o);

        if (o is char && (char)o == '\0') 
            return string.Empty; 

        if (o is ValueType)
            return (o.ToString());

        if (o is IEnumerable)
            return ("...");

        return ("{ }");
    }
}

et vous pouvez l'utiliser comme ça :

var dump = ObjectDumper.Dump(user);

Modifier

• Les références bi-directionnelles sont maintenant arrêtées. Le HashCode d'un objet est donc stocké dans une liste.
• Correction de AlreadyTouched (voir les commentaires)
• FormatValue corrigé (voir commentaires)

Answer 3

En ObjectDumper La classe est connue pour faire ça. Je n'ai jamais confirmé, mais j'ai toujours soupçonné que la fenêtre immédiate utilise cela.

EDIT : Je viens de réaliser que le code pour ObjectDumper est en fait sur votre machine. Allez-y :

C:/Program Files/Microsoft Visual Studio 9.0/Samples/1033/CSharpSamples.zip

Cela va dézipper dans un dossier appelé LinqSamples . Là-dedans, il y a un projet appelé ObjectDumper . Utilisez cela.

Answer 4

Peut-être via JavaScriptSerializer.Serialize ?

Answer 5

En ce qui concerne le TypeDescriptor de la réponse de Sean (je ne peux pas faire de commentaires parce que j'ai une mauvaise réputation)... l'un des avantages de l'utilisation de TypeDescriptor par rapport à GetProperties() est que TypeDescriptor dispose d'un mécanisme pour attacher dynamiquement des propriétés aux objets au moment de l'exécution et que la réflexion normale les manquera.

Par exemple, lorsqu'ils travaillent avec PSObject de PowerShell, auquel des propriétés et des méthodes peuvent être ajoutées au moment de l'exécution, ils ont mis en œuvre un TypeDescriptor personnalisé qui fusionne ces membres avec l'ensemble de membres standard. En utilisant TypeDescriptor, votre code n'a pas besoin d'être conscient de ce fait.

Les composants, les contrôles et, je pense, les DataSets font également appel à cette API.