Qual è il modo migliore per scaricare interi oggetti in un registro in C #?

Quindi, per visualizzare lo stato di un oggetto corrente in fase di runtime, mi piace molto quello che mi dà la finestra di Visual Studio Immediate. Sto solo facendo un semplice

? objectname

Mi darà un 'dump' ben formattato dell'oggetto.

C'è un modo semplice per farlo nel codice, quindi posso fare qualcosa di simile durante la registrazione?

È possibile basare qualcosa sul codice ObjectDumper fornito con gli esempi Linq .
Dai anche un'occhiata alla risposta di questa domanda correlata per ottenere un campione.

Per un grafico a oggetti più grande, secondo l'uso di Json ma con una strategia leggermente diversa. Innanzitutto ho una classe statica che è facile da chiamare e con un metodo statico che avvolge la conversione Json (nota: potrebbe rendere questo un metodo di estensione).

using Newtonsoft.Json;

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

Quindi nel tuo Immediate Window,

var lookHere = F.Dump(myobj);

lookHere verrà mostrato automaticamente nella Localsfinestra preceduto da $ o puoi aggiungere un orologio ad esso. Sul lato destro della Valuecolonna nell'ispettore, c'è una lente d'ingrandimento con un cursore a discesa accanto. Scegli il cursore a discesa e scegli Visualizzatore Json.

Sto usando Visual Studio 2013.

Sono certo che ci sono modi migliori per farlo, ma in passato ho usato un metodo simile al seguente per serializzare un oggetto in una stringa che posso registrare:

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

Vedrai che il metodo potrebbe anche restituire l'eccezione anziché l'oggetto serializzato, quindi assicurati che gli oggetti che desideri registrare siano serializzabili.

È possibile utilizzare la finestra immediata di Visual Studio

Basta incollarlo ( actualovviamente cambia il nome del tuo oggetto):

Newtonsoft.Json.JsonConvert.SerializeObject(actual);

Dovrebbe stampare l'oggetto in JSON

Dovresti essere in grado di copiarlo sullo strumento di testo textmechanic o sul blocco note ++ e sostituire le virgolette ( \") con "e newline ( \r\n) con spazio vuoto, quindi rimuovere le virgolette doppie ( ") dall'inizio e dalla fine e incollarlo in jsbeautifier per renderlo più leggibile.

AGGIORNAMENTO al commento di OP

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

questo dovrebbe consentire di scaricare qualsiasi oggetto.

Spero che questo ti faccia risparmiare un po 'di tempo.

ServiceStack.Text ha un metodo di estensione T.Dump () che fa esattamente questo, scarica in modo ricorsivo tutte le proprietà di qualsiasi tipo in un formato leggibile.

Esempio di utilizzo:

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

e uscita:

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

Ecco un modo stupidamente semplice per scrivere un oggetto piatto, ben formattato:

using Newtonsoft.Json.Linq;

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

Quello che sta succedendo è che l'oggetto viene prima convertito in una rappresentazione interna JSON da JObject.FromObject, quindi convertito in stringa JSON da ToString. (E ovviamente una stringa JSON è una rappresentazione molto bella di un oggetto semplice, soprattutto perché ToStringincluderà righe e rientri.) Il "ToString" è ovviamente estraneo (come è implicito usando +per concatenare una stringa e un oggetto), ma Mi piacerebbe specificarlo qui.

È possibile utilizzare la riflessione e scorrere tutte le proprietà dell'oggetto, quindi ottenere i loro valori e salvarli nel registro. La formattazione è davvero banale (puoi usare \ t per indentare le proprietà di un oggetto e i suoi valori):

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

Quello che mi piace fare è sovrascrivere ToString () in modo da ottenere un output più utile oltre il nome del tipo. Questo è utile nel debugger, puoi vedere le informazioni che desideri su un oggetto senza bisogno di espanderlo.

Ho trovato una libreria chiamata ObjectPrinter che consente di scaricare facilmente oggetti e raccolte nelle stringhe (e altro). Fa esattamente quello di cui avevo bisogno.

Di seguito è un'altra versione che fa la stessa cosa (e gestisce le proprietà nidificate), che penso sia più semplice (nessuna dipendenza da librerie esterne e può essere modificata facilmente per fare cose diverse dalla registrazione):

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

Puoi scrivere il tuo metodo 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());
    }

Usalo come-

WriteLine(myObject);

Per scrivere una raccolta possiamo usare-

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

Il metodo può apparire come-

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

Utilizzando if, else ife controllando interfacce, attributi, tipo di base, ecc. E ricorsione (in quanto questo è un metodo ricorsivo) in questo modo possiamo ottenere un oggetto dumper, ma è sicuramente noioso. L'uso del dumper oggetto dall'esempio LINQ di Microsoft consente di risparmiare tempo.

Sulla base della risposta di @engineforce, ho creato questa classe che sto usando in un progetto PCL di una soluzione 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;
    }
}

Tutti i percorsi sopra riportati presuppongono che i tuoi oggetti siano serializzabili in XML o JSON,
oppure devi implementare la tua soluzione.

Ma alla fine arrivi ancora al punto in cui devi risolvere problemi come

• ricorsione negli oggetti
• oggetti non serializzabili
• eccezioni
• ...

Inoltre registro vuoi maggiori informazioni:

• quando si è verificato l'evento
• callstack
• quale tre
• cosa c'era nella sessione web
• quale indirizzo IP
• url
• ...

C'è la migliore soluzione che risolve tutto questo e molto altro.
Usa questo pacchetto Nuget: Desharp .
Per tutti i tipi di applicazioni, sia Web che desktop .
Guarda la documentazione di Desharp Github . Ha molte opzioni di configurazione .

Chiama ovunque:

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

• può salvare il registro in un bel HTML (o in formato TEXT, configurabile)
• è possibile scrivere facoltativamente nel thread in background (configurabile)
• ha opzioni per la profondità massima degli oggetti e la lunghezza massima delle stringhe (configurabile)
• utilizza loop per oggetti iterabili e riflessioni all'indietro per tutto il resto,
  anzi per tutto ciò che puoi trovare nell'ambiente .NET .

Credo che aiuterà.