Simple Variable Dump

Pascal Ganaye

Rate me:

4.89/5 (12 votes)

25 Jun 2013CPOL1 min read

39.5K

This class dumps any .NET object properties to your output window.

Introduction

This is a quick variable dump.

It shows types and values of all properties and works its way recursively avoiding variables that have already been dumped.

Background

This is based on this blog.

Using the Code

A simple line to call the static method...

Utils.Dump(requestObject);

...will display the output (as an example):

1 PublicProperties (Middleware.Contracts.ReturnPeriodicMeterDataRequestRequestMessage)
2  | ExtensionData (System.Runtime.Serialization.ExtensionDataObject)
3  | Header (Middleware.Contracts.HeaderType)
4  |  | ExtensionData (System.Runtime.Serialization.ExtensionDataObject)
5  |  | MessageId = "0847c4b1-7f1c-4cf2-a011-09626d181234" (System.String)
6  |  | CorrelationId = "1" (System.String)
7  |  | Segment = 1739 (System.Int32)
8  |  | SegmentCount = 1753 (System.Int32)
9  |  | LastSegment = null (System.Nullable`1[System.Boolean])
10  | MeterData (Middleware.Contracts.MeterDataType)
11  |  | ExtensionData (System.Runtime.Serialization.ExtensionDataObject)
12  |  | MeterSerialNumber = "00000000123450083" (System.String)
13  |  | RegisterList (System.Collections.Generic.List`1[Middleware.Contracts.RegisterType])
14  |  |  | Capacity = 4 (System.Int32)
15  |  |  | Count = 1 (System.Int32)
16  |  | RegisterList[0] (Middleware.Contracts.RegisterType)
17  |  |  | ExtensionData (System.Runtime.Serialization.ExtensionDataObject)
18  |  |  | RegisterId = "2" (System.String)
19  |  |  | Unit = "Wh" (System.String)
20  |  |  | MeterReadingList (System.Collections.Generic.List`1[Middleware.Contracts.MeterReadingType])
21  |  |  |  | Capacity = 32 (System.Int32)
22  |  |  |  | Count = 20 (System.Int32)
23  |  |  | MeterReadingList[0] (Middleware.Contracts.MeterReadingType)
24  |  |  |  | ExtensionData (System.Runtime.Serialization.ExtensionDataObject)
25  |  |  |  | Reading = 17540 (System.Double)
26  |  |  |  | ReadingDate = 21/12/2011 04:00:00 (System.DateTime)
27  |  |  |  | Status = "2000" (System.String)
28  |  |  | MeterReadingList[1] (Middleware.Contracts.MeterReadingType)
29  |  |  |  | ExtensionData (System.Runtime.Serialization.ExtensionDataObject)
30  |  |  |  | Reading = 17540 (System.Double)
31  |  |  |  | ReadingDate = 21/12/2011 05:00:00 (System.DateTime)
32  |  |  |  | Status = "2000" (System.String)
...
118  |  |  | MeterReadingList[19] (Middleware.Contracts.MeterReadingType)
119  |  |  |  | ExtensionData (System.Runtime.Serialization.ExtensionDataObject)
120  |  |  |  | Reading = 17540 (System.Double)
121  |  |  |  | ReadingDate = 21/12/2011 23:00:00 (System.DateTime)
122  |  |  |  | Status = "2000" (System.String)

You can also dump private members if you prefer:

Utils.Dump(yourObject, Utils.DumpStyle.PrivateFields);

In this mode, we dump all fields rather than public properties.

Complete Code

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Text;

class Utils
{
    public enum DumpStyle
    {
        PublicProperties,
        PrivateFields
    }
    public static void Dump(object obj)
    {
        Dump(obj, DumpStyle.PublicProperties, null);
    }

    public static void Dump(object obj, DumpStyle dumpStyle)
    {
        var varDumper1 = new VarDumper();
        varDumper1.Dump(obj, dumpStyle, null);
    }

    public static void Dump(object obj, DumpStyle dumpStyle, Action<string> action)
    {
        if (action == null) action = (s) => Trace.WriteLine(s);
        var varDumper1 = new VarDumper();
        varDumper1.Dump(obj, dumpStyle, action);
    }

    public static IEnumerable<string> HexDump(byte[] bytes, int bytesPerLine)
    {
        if (bytes == null)
        {
            yield return "<null>";
            yield break;
        }
        int bytesLength = bytes.Length;

        char[] HexChars = "0123456789ABCDEF".ToCharArray();

        int firstHexColumn =
              8                   // 8 characters for the address
            + 3;                  // 3 spaces

        int firstCharColumn = firstHexColumn
            + bytesPerLine * 3       // - 2 digit for the hexadecimal value and 1 space
            + (bytesPerLine - 1) / 8 // - 1 extra space every 8 characters from the 9th
            + 2;                  // 2 spaces

        int lineLength = firstCharColumn
            + bytesPerLine;           // - characters to show the ASCII value

        char[] line = (new String(' ', lineLength)).ToCharArray();
        int expectedLines = (bytesLength + bytesPerLine - 1) / bytesPerLine;

        for (int i = 0; i < bytesLength; i += bytesPerLine)
        {
            line[0] = HexChars[(i >> 28) & 0xF];
            line[1] = HexChars[(i >> 24) & 0xF];
            line[2] = HexChars[(i >> 20) & 0xF];
            line[3] = HexChars[(i >> 16) & 0xF];
            line[4] = HexChars[(i >> 12) & 0xF];
            line[5] = HexChars[(i >> 8) & 0xF];
            line[6] = HexChars[(i >> 4) & 0xF];
            line[7] = HexChars[(i >> 0) & 0xF];

            int hexColumn = firstHexColumn;
            int charColumn = firstCharColumn;

            for (int j = 0; j < bytesPerLine; j++)
            {
                if (j > 0 && (j & 7) == 0) hexColumn++;
                if (i + j >= bytesLength)
                {
                    line[hexColumn] = ' ';
                    line[hexColumn + 1] = ' ';
                    line[charColumn] = ' ';
                }
                else
                {
                    byte b = bytes[i + j];
                    line[hexColumn] = HexChars[(b >> 4) & 0xF];
                    line[hexColumn + 1] = HexChars[b & 0xF];
                    line[charColumn] = (b < 32 || b >= 128 ? '.' : (char)b);
                }
                hexColumn += 3;
                charColumn++;
            }
            yield return new String(line);
        }
    }
    private class VarDumper
    {
        int maxRecursion = 10;
        private DumpStyle mDumpStyle;
        private int mLineCounter;

        private Dictionary<Object, int>
            seenObjects = new Dictionary<Object, int>();

        private static HashSet<Type> SimpleTypes = new HashSet<Type>() {
            typeof(UInt16 ), typeof(UInt32), typeof(UInt64),
            typeof(Int16 ), typeof(Int32), typeof(Int64),
            typeof(Byte), typeof(DateTime),
            typeof(Single), typeof(Double), typeof(Decimal),
            typeof(Boolean),
            typeof(Char), typeof(String),
            typeof(string)};


        internal void Dump<T>(T obj, DumpStyle dumpStyle, Action<string> writeLine)
        {
            mDumpStyle = dumpStyle;
            DumpObjectMember(0, "", dumpStyle.ToString(), typeof(T), obj, writeLine);

        }

        private string IndentedLine(string format, params object[] args)
        {
            mLineCounter++;
            string line;
            if (args != null && args.Length > 0) line = string.Format(format, args);
            else line = format;
            line = mLineCounter.ToString("000") + " " + line;
            return line;
        }

        private bool DumpObjectMembers(int recursion, string indent, object obj, Action<string> writeLine)
        {
            if (obj == null) return false;
            // Protect the method against endless recursion
            if (seenObjects.ContainsKey(obj))
            {
                writeLine(IndentedLine("{0}<already dumped on line {1}>", indent, seenObjects[obj]));
                return false;
            }
            else
            {
                // Determine object type
                Type t = obj.GetType();

                if (SimpleTypes.Contains(t) || obj is Type)
                {
                    return false;
                }
                if (obj is Byte[])
                {
                    Byte[] arr = obj as Byte[];
                    int lineNo = 0;
                    foreach (var line in Utils.HexDump(arr, 16))
                    {
                        if (lineNo > 100)
                        {
                            writeLine(IndentedLine("{0}...({1} bytes)", indent, arr.Length));
                            break;
                        }
                        writeLine(IndentedLine("{0}{1}", indent, line));
                        lineNo++;
                    }
                    return true;
                }

                if (recursion >= maxRecursion)
                {
                    writeLine(IndentedLine("{0}<maximum recursion of {1} reached>", indent, maxRecursion));
                }
                seenObjects.Add(obj, mLineCounter);

                bool classDisplayed = true;
                int propertiesFound = 0;
                while (t != null)
                {

                    switch (mDumpStyle)
                    {
                        case DumpStyle.PublicProperties:
                            // Get array with properties for this object
                            PropertyInfo[] properties = t.GetProperties
                            (BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);

                            foreach (PropertyInfo property in properties)
                            {
                                string l = CheckClassIsDisplayed(ref classDisplayed, indent, t);
                                if (l != null) writeLine(l);

                                Exception ex = null;
                                object value = null;
                                try
                                {
                                    if (property.GetIndexParameters().Length > 0) continue;
                                    // Get the property value
                                    propertiesFound++;
                                    value = property.GetValue(obj, null);
                                }
                                catch (Exception ex0)
                                {
                                    // You can't yield in a catch block
                                    ex = ex0;
                                }
                                if (ex == null)
                                {
                                    // Create indenting string to put
                                    // in front of properties of a deeper level
                                    // We'll need this when we display the property name and value
                                    DumpObjectMember
                                        (recursion, indent, property.Name, property.PropertyType, value, writeLine);

                                }
                                if (ex != null)
                                    writeLine(IndentedLine(@"{0}{1} = {2} ({3})", indent, property.Name, ex.Message, ex.GetType()));
                            }
                            break;
                        case DumpStyle.PrivateFields:
                            // Get array with properties for this object
                            FieldInfo[] fields = t.GetFields(BindingFlags.Instance |
                            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);

                            foreach (FieldInfo field in fields)
                            {
                                string l = CheckClassIsDisplayed(ref classDisplayed, indent, t);
                                if (l != null) writeLine(l);
                                // Get the property value
                                object value = field.GetValue(obj);

                                // Create indenting string to put
                                // in front of properties of a deeper level
                                // We'll need this when we display the property name and value
                                propertiesFound++;
                                DumpObjectMember
                                    (recursion, indent, field.Name, field.FieldType, value, writeLine);
                            }
                            break;
                    }
                    t = t.BaseType;
                    classDisplayed = false;
                }
                if (propertiesFound == 0)
                {
                    seenObjects.Remove(obj);
                }
            }
            return true;
        }

        private string CheckClassIsDisplayed(ref bool classDisplayed, string indent, Type t)
        {
            if (classDisplayed == false)
            {
                classDisplayed = true;
                return IndentedLine("{0}(inherited from {1})", indent, t);
            }
            else return null;
        }

        private void DumpObjectMember(int recursion,
            string indent, string propertyName, Type propertyType, object value,
             Action<string> writeLine)
        {
            if (value == null)
            {
                writeLine(IndentedLine("{0}{1} = null ({2})",
                indent, propertyName, FriendlyTypeName(propertyType)));
            }
            else
            {
                string displayValue = value.ToString();
                // If the value is a string, add quotation marks
                if (value is string) displayValue = String.Concat("\"",
                displayValue.Replace("\"", "\"\""), '"');
                string valueType = value.GetType().ToString();

                if (displayValue.Contains("\r\n"))
                {
                    writeLine(IndentedLine("{0}{1} = ({2})",
                        indent, propertyName, FriendlyTypeName(value.GetType())));
                    int lineNo = 0;
                    string[] lines = displayValue.Split('\r');
                    foreach (var line in lines)
                    {
                        if (lineNo > 100)
                        {
                            writeLine(IndentedLine("{0}   ... ({1} lines)", indent, lines.Length));
                            break;
                        }
                        displayValue = line.TrimStart('\n');
                        if (lineNo >= (lines.Length - 1) && displayValue.Length == 0) break;
                        if (displayValue.Length >= 200) displayValue =
                        string.Format("{0}... (length: {1})",
                        displayValue.Substring(0, 200), displayValue.Length);
                        writeLine(IndentedLine("{0} |  : {1}", indent, displayValue));
                        lineNo++;
                    }
                }
                else
                {
                    if (displayValue.Length >= 200) displayValue =
                    string.Format("{0}... (length: {1})",
                    displayValue.Substring(0, 200), displayValue.Length);
                    if (displayValue == valueType)
                    {
                        // The display value is identical to the type (no need to add it)
                        writeLine(IndentedLine("{0}{1} ({2})",
                            indent, propertyName, FriendlyTypeName(value.GetType())));
                    }
                    else
                    {
                        // Add property name and value to return string
                        writeLine(IndentedLine("{0}{1} = {2} ({3})",
                            indent, propertyName, displayValue, FriendlyTypeName(value.GetType())));
                    }
                }
                if (DumpObjectMembers(recursion + 1, indent + " | ", value, writeLine)
                    && value is IEnumerable && !(value is string) && !(value is Byte[]))
                {
                    // 2009-07-29: added support for collections
                    // The value is a collection (eg. it's an arraylist or generic list)
                    // so loop through its elements and dump their properties
                    int elementCount = 0;
                    Type elementType = typeof(object);
                    Exception ex = null;
                    IEnumerator enumerator = (value as IEnumerable).GetEnumerator();
                    bool next = false;
                    object element = null;
                    while (true)
                    {
                        // You can't yield in a try catch this is why
                        // I am breaking the loop with an explicit enumerator
                        try
                        {
                            next = enumerator.MoveNext();
                            if (next) element = enumerator.Current;
                        }
                        catch (Exception ex0)
                        {
                            // You can't yield in a catch block
                            ex = ex0;
                        }
                        if (!next || ex != null) break;
                        // Display the collection element name and type
                        DumpObjectMember(recursion + 1,
                       indent,
                       string.Format("{0}[{1}]", propertyName, elementCount),
                       elementType, element, writeLine);
                        elementCount++;
                    }
                    if (ex != null) writeLine(IndentedLine("{0} * An error occured while enumerating {1} : {2}",
                        indent, propertyName, ex.Message));
                }
            }
        }

        private object FriendlyTypeName(Type type)
        {
            if (!type.IsGenericType)
            {
                if (type.IsPrimitive || type.Namespace == "System")
                {
                    return type.Name;
                }
                else
                {
                    return type.FullName.Replace('+', ' ');
                }
            }

            var name = type.Name;
            var index = name.IndexOf("`");
            name = name.Substring(0, index);
            var args = type.GetGenericArguments();
            if (type.GetGenericTypeDefinition() ==
            typeof(Nullable<>) && args[0].IsPrimitive)
            {
                return args[0].Name + '?';
            }
            else
            {
                var builder = new System.Text.StringBuilder();
                builder.Append(type.Namespace);
                builder.Append('.');
                builder.Append(name);
                builder.Append('<');
                var first = true;
                foreach (var arg in args)
                {
                    if (first) first = false;
                    else builder.Append(',');
                    builder.Append(FriendlyTypeName(arg));
                }
                builder.Append('>');
                return builder.ToString();
            }
        }
    }

    public static object DumpToString(object obj, DumpStyle dumpStyle)
    {
        var varDumper1 = new VarDumper();
        StringBuilder result = new StringBuilder();
        varDumper1.Dump(obj, dumpStyle, (s) => result.Append(s));
        return result.ToString();
    }
}

Points of Interest

Nothing fancy. It dumps the public properties of the object. The main difference with Ruud version is that I keep a HashSet of dumped objects. This way you can dump trees that point to themselves or parents and it won't show much duplication.

I added the line counter to point to objects that have already been dumped, in practice it is also useful to locate when objects start and stop.

History

2013-06-26 (PG) Improve array rendering (now shows at higher level) and do not rely so much on yield
2012-06-01 (PG) Dump byte arrays, display generics types with C# syntax.
2012-05-22 (PG) Display exceptions and inherited members a bit better. Also line numbers for cycling references.
2012-05-18 (PG) Moved the StringBuilder and most of the code to a class
2009-07-28 First version from Ruud.Tech (no license attached)