Quelle est la meilleure méthode pour exporter des objets entiers dans un journal en C#?

Pour un grand objet graphique, je seconde l'utilisation de Json, mais avec un peu différente de la stratégie. D'abord j'ai une classe statique qui est facile d'appeler et avec une méthode statique qui enveloppe le Json de conversion (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 auto-apparaître dans la Locals fenêtre précédées d'un $ ou vous pouvez ajouter une montre à elle. Sur le côté droit de la Value colonne dans l'inspecteur, il y a une loupe avec un menu curseur à côté d'elle. Choisissez le menu curseur et choisissez Json visualizer.

Je suis à l'aide de Visual Studio 2013.

J'ai un T. Dump() la méthode d'extension qui fait exactement cela, de manière récursive les vidages de toutes les propriétés de n'importe quel type, dans un beau format lisible.

Exemple d'utilisation:

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

et de 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
    }
}

Ici est bêtement un moyen simple d'écrire un objet plat, bien mis en forme:

using Newtonsoft.Json.Linq;

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

Ce qu'il se passe, c'est que l'objet est d'abord converti en JSON représentation interne par JObject.FromObject, et ensuite convertis 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, surtout depuis ToString comprendra des sauts de ligne et des tirets.) Le "ToString" est superflu (comme il est implicite en utilisant + à la concaténation d'une chaîne et d'un objet), mais j'aime un peu le spécifier ici.

Ce que j'aime faire est primordial ToString() de sorte que j'ai plus de sortie utile au-delà du nom du type. C'est pratique dans le débogueur, vous pouvez voir les informations que vous voulez sur un objet sans avoir besoin de le développer.

- Ci est une autre version qui fait la même chose (et poignée de propriétés imbriquées), je pense que c'est plus simple (pas de dépendances sur les bibliothèques externes et peuvent être modifiés facilement à faire des choses autres que l'exploitation forestière):

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"));
}
}

Basé sur @engineforce réponse, j'ai fait cette classe que j'utilise dans un PCL projet de Xamarin Solution:

///<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;
}
}