Quelle est la meilleure façon de vider des objets entiers dans un journal en C #?

Donc, pour afficher l'état d'un objet actuel au moment de l'exécution, j'aime vraiment ce que la fenêtre Visual Studio Immediate me donne. Faire juste un simple

? objectname

Me donnera un «vidage» bien formaté de l'objet.

Existe-t-il un moyen simple de le faire dans le code, afin que je puisse faire quelque chose de similaire lors de la journalisation?

Vous pouvez baser quelque chose sur le code ObjectDumper fourni avec les exemples Linq .
Jetez également un œil à la réponse à cette question connexe pour obtenir un échantillon.

Pour un graphe d'objets plus grand, je seconde l'utilisation de Json mais avec une stratégie légèrement différente. J'ai d'abord une classe statique qui est facile à appeler et avec une méthode statique qui encapsule la conversion Json (note: pourrait en faire une méthode d'extension).

using Newtonsoft.Json;

public static class F
{
    public static string Dump(object obj)
    {
        return JsonConvert.SerializeObject(obj);
    }
}

Puis dans votre Immediate Window,

var lookHere = F.Dump(myobj);

lookHere s'affichera automatiquement dans la Localsfenêtre précédée d'un $ ou vous pouvez y ajouter une montre. Sur le côté droit de la Valuecolonne dans l'inspecteur, il y a une loupe avec un curseur déroulant à côté. Choisissez le curseur de la liste déroulante et choisissez le visualiseur Json.

J'utilise Visual Studio 2013.

Je suis certain qu'il existe de meilleures façons de faire cela, mais j'ai dans le passé utilisé une méthode semblable à la suivante pour sérialiser un objet dans une chaîne que je peux enregistrer:

  private string ObjectToXml(object output)
  {
     string objectAsXmlString;

     System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(output.GetType());
     using (System.IO.StringWriter sw = new System.IO.StringWriter())
     {
        try
        {
           xs.Serialize(sw, output);
           objectAsXmlString = sw.ToString();
        }
        catch (Exception ex)
        {
           objectAsXmlString = ex.ToString();
        }
     }

     return objectAsXmlString;
  }

Vous verrez que la méthode peut également renvoyer l'exception plutôt que l'objet sérialisé, vous voudrez donc vous assurer que les objets que vous souhaitez consigner sont sérialisables.

Vous pouvez utiliser la fenêtre immédiate de Visual Studio

Collez simplement ceci (changez actualévidemment le nom de votre objet):

Newtonsoft.Json.JsonConvert.SerializeObject(actual);

Il devrait imprimer l'objet en JSON

Vous devriez pouvoir le copier sur l'outil de texte textmechanic ou notepad ++ et remplacer les guillemets échappés ( \") par "et newlines ( \r\n) par un espace vide, puis supprimer les guillemets doubles ( ") du début et de la fin et le coller dans jsbeautifier pour le rendre plus lisible.

MISE À JOUR du commentaire d'OP

public static class Dumper
{
    public static void Dump(this object obj)
    {
        Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(obj)); // your logger
    }
}

cela devrait vous permettre de vider n'importe quel objet.

J'espère que cela vous fera gagner du temps.

ServiceStack.Text a une méthode d'extension T.Dump () qui fait exactement cela, vide récursivement toutes les propriétés de n'importe quel type dans un bon format lisible.

Exemple d'utilisation:

var model = new TestModel();
Console.WriteLine(model.Dump());

et sortie:

{
    Int: 1,
    String: One,
    DateTime: 2010-04-11,
    Guid: c050437f6fcd46be9b2d0806a0860b3e,
    EmptyIntList: [],
    IntList:
    [
        1,
        2,
        3
    ],
    StringList:
    [
        one,
        two,
        three
    ],
    StringIntMap:
    {
        a: 1,
        b: 2,
        c: 3
    }
}

Voici une façon stupidement simple d'écrire un objet plat, joliment formaté:

using Newtonsoft.Json.Linq;

Debug.WriteLine("The object is " + JObject.FromObject(theObjectToDump).ToString());

Ce qui se passe, c'est que l'objet est d'abord converti en une représentation interne JSON par JObject.FromObject, puis converti en chaîne JSON par ToString. (Et bien sûr, une chaîne JSON est une très belle représentation d'un objet simple, d'autant plus ToStringqu'elle inclura des retours à la ligne et des retraits.) Le "ToString" est bien sûr étranger (comme il est impliqué en utilisant +pour concaténer une chaîne et un objet), mais J'aime un peu le spécifier ici.

Vous pouvez utiliser la réflexion et parcourir toutes les propriétés de l'objet, puis obtenir leurs valeurs et les enregistrer dans le journal. Le formatage est vraiment trivial (vous pouvez utiliser \ t pour indenter les propriétés d'un objet et ses valeurs):

MyObject
    Property1 = value
    Property2 = value2
    OtherObject
       OtherProperty = value ...

Ce que j'aime faire, c'est remplacer ToString () afin d'obtenir une sortie plus utile au-delà du nom du type. Ceci est pratique dans le débogueur, vous pouvez voir les informations souhaitées sur un objet sans avoir besoin de le développer.

J'ai trouvé une bibliothèque appelée ObjectPrinter qui permet de vider facilement des objets et des collections dans des chaînes (et plus). Il fait exactement ce dont j'avais besoin.

Voici une autre version qui fait la même chose (et gère les propriétés imbriquées), ce que je pense est plus simple (pas de dépendances sur les bibliothèques externes et peut être modifiée facilement pour faire des choses autres que la journalisation):

public class ObjectDumper
{
    public static string Dump(object obj)
    {
        return new ObjectDumper().DumpObject(obj);
    }

    StringBuilder _dumpBuilder = new StringBuilder();

    string DumpObject(object obj)
    {
        DumpObject(obj, 0);
        return _dumpBuilder.ToString();
    }

    void DumpObject(object obj, int nestingLevel = 0)
    {
        var nestingSpaces = "".PadLeft(nestingLevel * 4);

        if (obj == null)
        {
            _dumpBuilder.AppendFormat("{0}null\n", nestingSpaces);
        }
        else if (obj is string || obj.GetType().IsPrimitive)
        {
            _dumpBuilder.AppendFormat("{0}{1}\n", nestingSpaces, obj);
        }
        else if (ImplementsDictionary(obj.GetType()))
        {
            using (var e = ((dynamic)obj).GetEnumerator())
            {
                var enumerator = (IEnumerator)e;
                while (enumerator.MoveNext())
                {
                    dynamic p = enumerator.Current;

                    var key = p.Key;
                    var value = p.Value;
                    _dumpBuilder.AppendFormat("{0}{1} ({2})\n", nestingSpaces, key, value != null ? value.GetType().ToString() : "<null>");
                    DumpObject(value, nestingLevel + 1);
                }
            }
        }
        else if (obj is IEnumerable)
        {
            foreach (dynamic p in obj as IEnumerable)
            {
                DumpObject(p, nestingLevel);
            }
        }
        else
        {
            foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(obj))
            {
                string name = descriptor.Name;
                object value = descriptor.GetValue(obj);

                _dumpBuilder.AppendFormat("{0}{1} ({2})\n", nestingSpaces, name, value != null ? value.GetType().ToString() : "<null>");
                DumpObject(value, nestingLevel + 1);
            }
        }
    }

    bool ImplementsDictionary(Type t)
    {
        return t.GetInterfaces().Any(i => i.Name.Contains("IDictionary"));
    }
}

Vous pouvez écrire votre propre méthode WriteLine-

public static void WriteLine<T>(T obj)
    {
        var t = typeof(T);
        var props = t.GetProperties();
        StringBuilder sb = new StringBuilder();
        foreach (var item in props)
        {
            sb.Append($"{item.Name}:{item.GetValue(obj,null)}; ");
        }
        sb.AppendLine();
        Console.WriteLine(sb.ToString());
    }

Utilisez-le comme-

WriteLine(myObject);

Pour écrire une collection, nous pouvons utiliser-

 var ifaces = t.GetInterfaces();
        if (ifaces.Any(o => o.Name.StartsWith("ICollection")))
        {

            dynamic lst = t.GetMethod("GetEnumerator").Invoke(obj, null);
            while (lst.MoveNext())
            {
                WriteLine(lst.Current);
            }
        }   

La méthode peut ressembler à -

 public static void WriteLine<T>(T obj)
    {
        var t = typeof(T);
        var ifaces = t.GetInterfaces();
        if (ifaces.Any(o => o.Name.StartsWith("ICollection")))
        {

            dynamic lst = t.GetMethod("GetEnumerator").Invoke(obj, null);
            while (lst.MoveNext())
            {
                WriteLine(lst.Current);
            }
        }            
        else if (t.GetProperties().Any())
        {
            var props = t.GetProperties();
            StringBuilder sb = new StringBuilder();
            foreach (var item in props)
            {
                sb.Append($"{item.Name}:{item.GetValue(obj, null)}; ");
            }
            sb.AppendLine();
            Console.WriteLine(sb.ToString());
        }
    }

En utilisant if, else ifet en vérifiant les interfaces, les attributs, le type de base, etc. et la récursivité (car c'est une méthode récursive) de cette façon, nous pouvons réaliser un vidage d'objets, mais c'est certainement fastidieux. L'utilisation du videur d'objets de l'exemple LINQ de Microsoft vous fera gagner du temps.

Sur la base de la réponse @engineforce, j'ai créé cette classe que j'utilise dans un projet PCL d'une solution Xamarin:

/// <summary>
/// Based on: https://stackoverflow.com/a/42264037/6155481
/// </summary>
public class ObjectDumper
{
    public static string Dump(object obj)
    {
        return new ObjectDumper().DumpObject(obj);
    }

    StringBuilder _dumpBuilder = new StringBuilder();

    string DumpObject(object obj)
    {
        DumpObject(obj, 0);
        return _dumpBuilder.ToString();
    }

    void DumpObject(object obj, int nestingLevel)
    {
        var nestingSpaces = "".PadLeft(nestingLevel * 4);

        if (obj == null)
        {
            _dumpBuilder.AppendFormat("{0}null\n", nestingSpaces);
        }
        else if (obj is string || obj.GetType().GetTypeInfo().IsPrimitive || obj.GetType().GetTypeInfo().IsEnum)
        {
            _dumpBuilder.AppendFormat("{0}{1}\n", nestingSpaces, obj);
        }
        else if (ImplementsDictionary(obj.GetType()))
        {
            using (var e = ((dynamic)obj).GetEnumerator())
            {
                var enumerator = (IEnumerator)e;
                while (enumerator.MoveNext())
                {
                    dynamic p = enumerator.Current;

                    var key = p.Key;
                    var value = p.Value;
                    _dumpBuilder.AppendFormat("{0}{1} ({2})\n", nestingSpaces, key, value != null ? value.GetType().ToString() : "<null>");
                    DumpObject(value, nestingLevel + 1);
                }
            }
        }
        else if (obj is IEnumerable)
        {
            foreach (dynamic p in obj as IEnumerable)
            {
                DumpObject(p, nestingLevel);
            }
        }
        else
        {
            foreach (PropertyInfo descriptor in obj.GetType().GetRuntimeProperties())
            {
                string name = descriptor.Name;
                object value = descriptor.GetValue(obj);

                _dumpBuilder.AppendFormat("{0}{1} ({2})\n", nestingSpaces, name, value != null ? value.GetType().ToString() : "<null>");

                // TODO: Prevent recursion due to circular reference
                if (name == "Self" && HasBaseType(obj.GetType(), "NSObject"))
                {
                    // In ObjC I need to break the recursion when I find the Self property
                    // otherwise it will be an infinite recursion
                    Console.WriteLine($"Found Self! {obj.GetType()}");
                }
                else
                {
                    DumpObject(value, nestingLevel + 1);
                }
            }
        }
    }

    bool HasBaseType(Type type, string baseTypeName)
    {
        if (type == null) return false;

        string typeName = type.Name;

        if (baseTypeName == typeName) return true;

        return HasBaseType(type.GetTypeInfo().BaseType, baseTypeName);
    }

    bool ImplementsDictionary(Type t)
    {
        return t is IDictionary;
    }
}

Tous les chemins ci-dessus supposent que vos objets sont sérialisables en XML ou JSON,
ou vous devez implémenter votre propre solution.

Mais à la fin, vous arrivez toujours au point où vous devez résoudre des problèmes tels que

• récursivité dans les objets
• objets non sérialisables
• des exceptions
• ...

Plus journal que vous voulez plus d'informations:

• quand l'événement s'est produit
• pile d'appels
• qui a lu
• ce qui était dans la session Web
• quelle adresse IP
• URL
• ...

Il existe la meilleure solution qui résout tout cela et bien plus encore.
Utilisez ce package Nuget : Desharp .
Pour tous les types d'applications - applications Web et de bureau .
Voir sa documentation Desharp Github . Il a de nombreuses options de configuration .

Appelez n'importe où:

Desharp.Debug.Log(anyException);
Desharp.Debug.Log(anyCustomValueObject);
Desharp.Debug.Log(anyNonserializableObject);
Desharp.Debug.Log(anyFunc);
Desharp.Debug.Log(anyFunc, Desharp.Level.EMERGENCY); // you can store into different files

• il peut enregistrer le journal dans un joli HTML (ou au format TEXTE, configurable)
• il est possible d'écrire en option dans le thread d'arrière-plan (configurable)
• il a des options pour la profondeur maximale des objets et la longueur maximale des chaînes (configurable)
• il utilise des boucles pour les objets itérables et une réflexion en arrière pour tout le reste, en
  fait pour tout ce que vous pouvez trouver dans l'environnement .NET .

Je crois que cela aidera.