Was ist der beste Weg, um ganze Objekte in einem Protokoll in C # abzulegen?

Um den Status eines aktuellen Objekts zur Laufzeit anzuzeigen, gefällt mir sehr, was mir das Visual Studio-Sofortfenster bietet. Einfach ein einfaches machen

? objectname

Gibt mir einen schön formatierten 'Dump' des Objekts.

Gibt es eine einfache Möglichkeit, dies im Code zu tun, damit ich beim Protokollieren etwas Ähnliches tun kann?

Sie könnten etwas auf dem ObjectDumper-Code basieren, der mit den Linq-Beispielen geliefert wird .
Schauen Sie sich auch die Antwort auf diese verwandte Frage an, um ein Beispiel zu erhalten.

Für ein größeres Objektdiagramm unterstütze ich die Verwendung von Json, jedoch mit einer etwas anderen Strategie. Zuerst habe ich eine statische Klasse, die einfach aufzurufen ist und eine statische Methode enthält, die die Json-Konvertierung umschließt (Hinweis: Dies könnte eine Erweiterungsmethode sein).

using Newtonsoft.Json;

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

Dann in deinem Immediate Window,

var lookHere = F.Dump(myobj);

lookHere wird automatisch in dem LocalsFenster angezeigt, dem ein $ vorangestellt ist, oder Sie können eine Uhr hinzufügen. Auf der rechten Seite der ValueSäule im Inspektor befindet sich eine Lupe mit einem Dropdown-Caret daneben. Wählen Sie das Dropdown-Caret und dann Json Visualizer.

Ich verwende Visual Studio 2013.

Ich bin mir sicher, dass es dafür bessere Möglichkeiten gibt, aber ich habe in der Vergangenheit eine Methode wie die folgende verwendet, um ein Objekt in eine Zeichenfolge zu serialisieren, die ich protokollieren kann:

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

Sie werden sehen, dass die Methode möglicherweise auch die Ausnahme anstelle des serialisierten Objekts zurückgibt. Sie sollten daher sicherstellen, dass die Objekte, die Sie protokollieren möchten, serialisierbar sind.

Sie können Visual Studio Immediate Window verwenden

Fügen Sie dies einfach ein (ändern actualSie offensichtlich Ihren Objektnamen):

Newtonsoft.Json.JsonConvert.SerializeObject(actual);

Es sollte ein Objekt in JSON drucken

Sie sollten in der Lage sein, es über ein textmechanisches Textwerkzeug oder einen Editor ++ zu kopieren und maskierte Anführungszeichen ( \") durch "und Zeilenumbrüche ( \r\n) durch Leerzeichen zu ersetzen. Entfernen Sie dann doppelte Anführungszeichen ( ") von Anfang und Ende und fügen Sie es in ein jsbeautifier ein , um es besser lesbar zu machen.

UPDATE zum Kommentar von OP

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

Dies sollte es Ihnen ermöglichen, jedes Objekt zu sichern.

Hoffe das spart dir etwas Zeit.

ServiceStack.Text verfügt über eine T.Dump () - Erweiterungsmethode , die genau dies tut und rekursiv alle Eigenschaften eines beliebigen Typs in einem gut lesbaren Format .

Anwendungsbeispiel:

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

und Ausgabe:

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

Hier ist eine dumm einfache Möglichkeit, ein flaches Objekt zu schreiben, das gut formatiert ist:

using Newtonsoft.Json.Linq;

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

Was passiert ist, dass das Objekt zuerst von in eine interne JSON-Darstellung JObject.FromObjectkonvertiert und dann von in eine JSON-Zeichenfolge konvertiert wird ToString. (Und natürlich ist eine JSON-Zeichenfolge eine sehr schöne Darstellung eines einfachen Objekts, zumal ToStringsie Zeilenumbrüche und Einrückungen enthält.) Der "ToString" ist natürlich irrelevant (wie es impliziert wird +, wenn eine Zeichenfolge und ein Objekt verwendet werden), aber Ich möchte es hier irgendwie spezifizieren.

Sie können Reflection verwenden und alle Objekteigenschaften durchlaufen, dann ihre Werte abrufen und im Protokoll speichern. Die Formatierung ist wirklich trivial (Sie können \ t verwenden, um die Eigenschaften eines Objekts und seine Werte einzurücken):

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

Was ich gerne mache, ist das Überschreiben von ToString (), damit ich über den Typnamen hinaus eine nützlichere Ausgabe bekomme. Dies ist praktisch im Debugger. Sie können die gewünschten Informationen zu einem Objekt anzeigen, ohne es erweitern zu müssen.

Ich habe eine Bibliothek namens ObjectPrinter gefunden , mit der Objekte und Sammlungen einfach in Zeichenfolgen (und mehr) gespeichert werden können. Es macht genau das, was ich brauchte.

Das Folgende ist eine andere Version, die dasselbe tut (und verschachtelte Eigenschaften behandelt), was meiner Meinung nach einfacher ist (keine Abhängigkeiten von externen Bibliotheken und einfach zu ändern, um andere Dinge als die Protokollierung zu tun):

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

Sie können Ihre eigene WriteLine-Methode schreiben.

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

Verwenden Sie es wie-

WriteLine(myObject);

Um eine Sammlung zu schreiben, können wir verwenden:

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

Die Methode kann wie folgt aussehen:

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

Wenn if, else ifwir Schnittstellen, Attribute, Basistyp usw. und Rekursion (da dies eine rekursive Methode ist) verwenden und überprüfen, können wir auf diese Weise einen Objektdumper erzielen, der jedoch mit Sicherheit langwierig ist. Die Verwendung des Objektdummers aus dem LINQ-Beispiel von Microsoft würde Ihre Zeit sparen.

Basierend auf der Antwort von @engineforce habe ich diese Klasse erstellt, die ich in einem PCL-Projekt einer Xamarin-Lösung verwende:

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

Bei allen oben genannten Pfaden wird davon ausgegangen, dass Ihre Objekte in XML oder JSON serialisierbar sind.
oder Sie müssen Ihre eigene Lösung implementieren.

Aber am Ende kommt man immer noch an den Punkt, an dem man Probleme wie lösen muss

• Rekursion in Objekten
• nicht serialisierbare Objekte
• Ausnahmen
• ...

Plus Protokoll Sie möchten weitere Informationen:

• als das Ereignis passierte
• Callstack
• welche drei
• Was war in der Web-Sitzung
• welche IP-Adresse
• URL
• ...

Es gibt die beste Lösung, die all dies und noch viel mehr löst.
Verwenden Sie dieses Nuget-Paket: Desharp .
Für alle Arten von Anwendungen - sowohl Web- als auch Desktop-Anwendungen .
Siehe Desharp Github-Dokumentation . Es gibt viele Konfigurationsoptionen .

Rufen Sie einfach irgendwo an:

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

• Es kann das Protokoll in schönem HTML (oder im konfigurierbaren TEXT-Format) speichern.
• Es ist möglich, optional im Hintergrund-Thread zu schreiben (konfigurierbar).
• Es verfügt über Optionen für die maximale Objekttiefe und die maximale Zeichenfolgenlänge (konfigurierbar).
• Es verwendet Schleifen für iterierbare Objekte und Rückwärtsreflexion für alles andere, in der
  Tat für alles , was Sie in einer .NET-Umgebung finden können .

Ich glaube es wird helfen.