¿Cuál es la mejor manera de volcar objetos completos en un registro en C #?

Entonces, para ver el estado de un objeto actual en tiempo de ejecución, realmente me gusta lo que me da la ventana Inmediato de Visual Studio. Solo haciendo un simple

? objectname

Me dará un 'volcado' bien formateado del objeto.

¿Hay una manera fácil de hacer esto en código, para que pueda hacer algo similar al iniciar sesión?

Podría basar algo en el código ObjectDumper que se incluye con las muestras de Linq .
También eche un vistazo a la respuesta de esta pregunta relacionada para obtener una muestra.

Para un gráfico de objeto más grande, secundo el uso de Json pero con una estrategia ligeramente diferente. Primero tengo una clase estática que es fácil de llamar y con un método estático que envuelve la conversión de Json (nota: podría hacer de este un método de extensión).

using Newtonsoft.Json;

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

Entonces en tu Immediate Window,

var lookHere = F.Dump(myobj);

lookHere se mostrará automáticamente en la Localsventana antepuesta con un $ o puede agregarle un reloj. En el lado derecho de la Valuecolumna en el inspector, hay una lupa con un cursor desplegable al lado. Elija el cursor desplegable y elija el visualizador Json.

Estoy usando Visual Studio 2013.

Estoy seguro de que hay mejores formas de hacerlo, pero en el pasado he usado un método similar al siguiente para serializar un objeto en una cadena que puedo registrar:

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

Verá que el método también puede devolver la excepción en lugar del objeto serializado, por lo que querrá asegurarse de que los objetos que desea registrar sean serializables.

Puede usar la ventana Inmediato de Visual Studio

Simplemente pegue esto (cambie actualsu nombre de objeto obviamente):

Newtonsoft.Json.JsonConvert.SerializeObject(actual);

Debería imprimir el objeto en JSON

Debería poder copiarlo sobre la herramienta de texto textmechanic o notepad ++ y reemplazar las comillas escapadas ( \") con "y las líneas nuevas ( \r\n) con un espacio vacío, luego elimine las comillas dobles ( ") desde el principio y el final y péguelo en jsbeautifier para que sea más legible.

ACTUALIZAR al comentario de OP

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

Esto debería permitirle volcar cualquier objeto.

Espero que esto te ahorre algo de tiempo.

ServiceStack.Text tiene un método de extensión T.Dump () que hace exactamente esto, volca recursivamente todas las propiedades de cualquier tipo en un formato agradable y legible.

Ejemplo de uso:

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

y salida:

{
    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
    }
}

Aquí hay una manera estúpidamente simple de escribir un objeto plano, bien formateado:

using Newtonsoft.Json.Linq;

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

Lo que sucede es que el objeto se convierte primero en una representación interna JSON por JObject.FromObject, y luego se convierte en una cadena JSON por ToString. (Y, por supuesto, una cadena JSON es una muy buena representación de un objeto simple, especialmente porque ToStringincluirá nuevas líneas y sangrías). El "ToString" es, por supuesto, extraño (como se implica al usar +para concatenar una cadena y un objeto), pero Me gusta especificarlo aquí.

Puede usar la reflexión y recorrer todas las propiedades del objeto, luego obtener sus valores y guardarlos en el registro. El formato es realmente trivial (puede usar \ t para sangrar las propiedades de un objeto y sus valores):

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

Lo que me gusta hacer es anular ToString () para obtener una salida más útil más allá del nombre del tipo. Esto es útil en el depurador, puede ver la información que desea sobre un objeto sin necesidad de expandirlo.

Encontré una biblioteca llamada ObjectPrinter que permite volcar fácilmente objetos y colecciones en cadenas (y más). Hace exactamente lo que necesitaba.

La siguiente es otra versión que hace lo mismo (y maneja las propiedades anidadas), que creo que es más simple (no depende de bibliotecas externas y se puede modificar fácilmente para hacer otras cosas que no sean el registro):

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

Puedes escribir tu propio método 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());
    }

Úselo como ...

WriteLine(myObject);

Para escribir una colección podemos usar:

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

El método puede parecer-

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

Usando if, else ify comprobando interfaces, atributos, tipo base, etc. y recursividad (ya que este es un método recursivo) de esta manera podemos lograr un objeto volcado, pero es tedioso con seguridad. Usar el volcador de objetos de la muestra LINQ de Microsoft le ahorraría tiempo.

Basado en la respuesta de @engineforce, hice esta clase que estoy usando en un proyecto PCL de una Solución 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;
    }
}

Todas las rutas anteriores suponen que sus objetos son serializables a XML o JSON,
o debe implementar su propia solución.

Pero al final todavía llegas al punto en que tienes que resolver problemas como

• recursividad en objetos
• objetos no serializables
• excepciones
• ...

Además inicie sesión desea más información:

• cuando sucedió el evento
• pila de llamadas
• cual threead
• lo que había en la sesión web
• cual dirección ip
• url
• ...

Existe la mejor solución que resuelve todo esto y mucho más.
Use este paquete Nuget : Desharp .
Para todo tipo de aplicaciones, tanto aplicaciones web como de escritorio .
Vea que es la documentación de Desharp Github . Tiene muchas opciones de configuración .

Simplemente llame a cualquier parte:

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

• puede guardar el registro en HTML agradable (o en formato TEXTO, configurable)
• es posible escribir opcionalmente en hilo de fondo (configurable)
• Tiene opciones para la profundidad máxima de los objetos y la longitud máxima de las cadenas (configurable)
• utiliza bucles para objetos iterables y reflexión hacia atrás para todo lo demás, de
  hecho para cualquier cosa que pueda encontrar en el entorno .NET .

Creo que te ayudará.