Ndtyjky

For a larger object graph, I second the use of Json but with a slightly different strategy. First I have a static class that is easy to call and with a static method that wraps the Json conversion (note: could make this an extension method).

using Newtonsoft.Json;



public static class F

{

    public static string Dump(object obj)

    {

        return JsonConvert.SerializeObject(obj);

    }

}

Then in your Immediate Window,

var lookHere = F.Dump(myobj);

lookHere will auto-show up in the Locals window prepended with a $ or you can add a watch to it. On the right hand side of the Value column in the inspector, there is a magnifying glass with a dropdown caret beside it. Choose the dropdown caret and choose Json visualizer.

I am using Visual Studio 2013.

I'm certain there are better ways of doing this, but I have in the past used a method something like the following to serialize an object into a string that I can log:

  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;

  }

You'll see that the method might also return the exception rather than the serialized object, so you'll want to ensure that the objects you want to log are serializable.

I have a T.Dump() extension method that does exactly this, recursively dumps all properties of any type in a nice readable format.

Example usage:

var model = new TestModel();

Console.WriteLine(model.Dump());

and output:

{

    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

    }

}

You could use Visual Studio Immediate Window

Just paste this (change actual to your object name obviously):

Newtonsoft.Json.JsonConvert.SerializeObject(actual);

It should print object in JSON

You should be able to copy it over textmechanic text tool or notepad++ and replace escaped quotes (") with " and newlines (rn) with empty space, then remove double quotes (") from beginning and end and paste it to jsbeautifier to make it more readable.

UPDATE to OP's comment

public static class Dumper

{

    public static void Dump(this object obj)

    {

        Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(obj)); // your logger

    }

}

this should allow you to dump any object.

Hope this saves you some time.

Here is a stupidly simple way to write a flat object, nicely formatted:

using Newtonsoft.Json.Linq;



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

What's going on is that the object is first converted to a JSON internal representation by JObject.FromObject, and then converted to JSON string by ToString. (And of course a JSON string is a very nice representation of a simple object, especially since ToString will include newlines and indents.) The "ToString" is of course extraneous (as it's implied by using + to concat a string and an object), but I kinda like to specify it here.

You could use reflection and loop through all the object properties, then get their values and save them to the log. The formatting is really trivial (you could use t to indent an objects properties and its values):

MyObject

    Property1 = value

    Property2 = value2

    OtherObject

       OtherProperty = value ...

What I like doing is overriding ToString() so that I get more useful output beyond the type name. This is handy in the debugger, you can see the information you want about an object without needing to expand it.

I found a library called ObjectPrinter which allows to easily dump objects and collections to strings (and more). It does exactly what I needed.

Following is another version that does the same thing (and handle nested properties), which I think is simpler (no dependencies on external libraries and can be modified easily to do things other than logging):

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

    }

}

You can write your own WriteLine method-

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

    }

Use it like-

WriteLine(myObject);

To write a collection we can use-

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

            }

        }   

The method may look like-

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

        }

    }

Using if, else if and checking interfaces, attributes, base type, etc. and recursion (as this is a recursive method) in this way we may achieve an object dumper, but it is tedious for sure. Using the object dumper from Microsoft's LINQ Sample would save your time.

Based on @engineforce answer, I made this class that I'm using in a PCL project of a 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}nulln", 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;

    }

}