12
\$\begingroup\$

The DebuggerDisplayAttribute is a very helpful feature. But creating those strings is an extremely tedious task. I wanted to make it a no-brainer so that I can create them quickly and at the same time make sure that all of them are formatted the same way so I created the following tools.


Core

The starting point is the DebuggerDisplayHelper<T>. It initializes the process of creating a string for the given type and caches the Func<T, string> that is used in subsequent calls.

public static class DebuggerDisplayHelper<T>
{
    private static Func<T, string> _toString;

    public static string ToString(T obj, Action<DebuggerDisplayBuilder<T>> builderAction)
    {
        if (_toString is null)
        {
            var builder = new DebuggerDisplayBuilder<T>();
            builderAction(builder);
            _toString = builder.Build();
        }

        return _toString(obj);
    }
}

The DebuggerDisplayBuilder<T> is responsible for actually building and formatting the string from members specified as expressions. They can be either simple types or collections.

I had to use different method names Property & Collection instead of a single Add because the compiler wasn't able to correctly resolve the overload for collections and picked the one for simple properties.

public class DebuggerDisplayBuilder<T>
{
    private readonly IList<(string MemberName, Func<T, object> GetValue)> _members;

    public DebuggerDisplayBuilder()
    {
        _members = new List<(string MemberName, Func<T, object> GetValue)>();
    }

    public DebuggerDisplayBuilder<T> Property<TProperty>(Expression<Func<T, TProperty>> expression)
    {
        var memberExpressions = MemberFinder.FindMembers(expression);
        var getProperty = expression.Compile();

        return Add(
            memberName: memberExpressions.FormatMemberName(), 
            getValue: obj => getProperty(obj).FormatValue()
        );
    }

    public DebuggerDisplayBuilder<T> Collection<TProperty, TValue>(Expression<Func<T, IEnumerable<TProperty>>> expression, Expression<Func<TProperty, TValue>> formatExpression)
    {
        var memberExpressions = MemberFinder.FindMembers(expression);
        var getProperty = expression.Compile();
        var getValue = formatExpression.Compile();

        return Add(
            memberName: memberExpressions.FormatMemberName(),
            getValue: obj => getProperty(obj).Select(getValue).FormatCollection()
        );
    }

    public DebuggerDisplayBuilder<T> Collection<TProperty>(Expression<Func<T, IEnumerable<TProperty>>> expression)
    {
        return Collection(expression, x => x);
    }

    private DebuggerDisplayBuilder<T> Add(string memberName, Func<T, object> getValue)
    {
        _members.Add((memberName, getValue));
        return this;
    }

    public Func<T, string> Build()
    {
        return obj => string.Join(", ", _members.Select(t => $"{t.MemberName} = {t.GetValue(obj)}"));
    }
}

The formatting is supported by the DebuggerDisplayFormatter. By default it calls at some point ToString for all values but the user can customize the formatting (e.g. for dates or numbers). It formats strings by quoting them with single quotes. Numbers don't get any. Arrays are enclosed with square brackes and their values follow the same rules as strings or numbers. null and DBNull are reproduced respectively as strings.

internal static class DebuggerDisplayFormatter
{
    public static string FormatValue<TValue>(this TValue value)
    {
        if (Type.GetTypeCode(value?.GetType()) == DBNull.Value.GetTypeCode()) return $"{nameof(DBNull)}";
        if (value == null) return "null";
        if (value.IsNumeric()) return value.ToString();

        return $"'{value}'";
    }

    public static string FormatCollection<TValue>(this IEnumerable<TValue> values)
    {
        if (values == null) return "null";

        return "[" + string.Join(", ", values.Select(FormatValue)) + "]";
    }

    public static string FormatMemberName(this IEnumerable<MemberExpression> memberExpressions)
    {
        return string.Join(".", memberExpressions.Select(m => m.Member.Name));
    }

    private static readonly ISet<TypeCode> NumericTypeCodes = new HashSet<TypeCode>
    {
        TypeCode.Byte,
        TypeCode.SByte,
        TypeCode.UInt16,
        TypeCode.UInt32,
        TypeCode.UInt64,
        TypeCode.Int16,
        TypeCode.Int32,
        TypeCode.Int64,
        TypeCode.Decimal,
        TypeCode.Double,
        TypeCode.Single,
    };

    public static bool IsNumeric<TValue>(this TValue value)
    {
        return NumericTypeCodes.Contains(Type.GetTypeCode(typeof(TValue)));
    }
}

Finding memeber names is the resposibility of the MemberFinder[Visitor]

internal class MemberFinder : ExpressionVisitor, IEnumerable<MemberExpression>
{
    private readonly IList<MemberExpression> _members = new List<MemberExpression>();

    public static IEnumerable<MemberExpression> FindMembers(Expression expression)
    {
        var memberFinder = new MemberFinder();
        memberFinder.Visit(expression);
        return memberFinder;
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        _members.Add(node);
        return base.VisitMember(node);
    }

    #region IEnumerable<MemberExpression>

    public IEnumerator<MemberExpression> GetEnumerator()
    {
        return _members.Reverse().GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion
}

Example

This is how everything put together looks like when using Person as a test model

public class Person
{
    private string _testField = "TestValue";

    public string FirstName { get; set; }

    public string LastName { get; set; }

    public double Age { get; set; }

    public object DBNullTest { get; set; } = DBNull.Value;

    public IList<int> GraduationYears { get; set; } = new List<int>();

    public IList<string> Nicknames { get; set; } = new List<string>();

    private string DebuggerDisplay() => DebuggerDisplayHelper<Person>.ToString(this, builder =>
    {
        builder.Property(x => x.FirstName);
        builder.Property(x => x.LastName);
        builder.Property(x => x._testField);
        builder.Property(x => x.DBNullTest);
        builder.Property(x => x.Age.ToString("F2"));
        builder.Property(x => x.GraduationYears.Count);
        builder.Collection(x => x.GraduationYears);
        builder.Collection(x => x.GraduationYears, x => x.ToString("X2"));
        builder.Collection(x => x.Nicknames);
    });
}

that I initialize with the following values

var person = new Person
{
    FirstName = "John",
    LastName = null,
    Age = 123.456,
    DBNullTest = DBNull.Value,
    GraduationYears = { 1901, 1921, 1941 },
    Nicknames = { "Johny", "Doe" }
};

and as a result the DebuggerDisplay() method produces this

 FirstName = 'John', LastName = null, _testField = 'TestValue', DBNullTest = DBNull, Age = '123,46', GraduationYears.Count = 3, GraduationYears = [1901, 1921, 1941], GraduationYears = ['76D', '781', '795'], Nicknames = ['Johny', 'Doe']

The Person isn't decorated with the DebuggerDisplayAttribute because the assembly is:

[assembly: DebuggerDisplay("{DebuggerDisplay(),nq}", Target = typeof(Person))]

If you've found and obvious flaws in this solution or think that anything can be improved, I'd be happy to read about it.

\$\endgroup\$
  • \$\begingroup\$ I'm not sure your feelings on expression bodies for methods, but since you're using C#7 (from the Tuple types), you can employ them to reduce some curly brace noise if you so desire. \$\endgroup\$ – Jesse C. Slicer Apr 2 '18 at 14:16
  • \$\begingroup\$ @JesseC.Slicer sure, I like expression bodied members but sometimes I value consistency more. I either use them everywhere (if it's a simple decorator with redirections) or none. I don't like mixing them - this means I'm pretty binary about them ;-) \$\endgroup\$ – t3chb0t Apr 2 '18 at 14:19
8
\$\begingroup\$

This is great work and very useful. I have the following comments/suggestions:

1) The usual suspects:

a) return "[" + string.Join(", ", values.Select(FormatValue)) + "]";

should/could be:

  return $"[ {string.Join(", ", sample.Select(FormatValue))} ]";

b) if (Type.GetTypeCode(value?.GetType()) == DBNull.Value.GetTypeCode()) return $"{nameof(DBNull)}";

can be simplified to:

  if (value is DBNull) return $"{nameof(DBNull)}";

2) Suggestions:

a) If a collection has many elements, you may want to truncate the debug output:

public static string FormatCollection<TValue>(this IEnumerable<TValue> values, string format = null)
{
  if (values == null) return "null";

  TValue[] sample = values.Take(11).ToArray();
  string dots = sample.Length > 10 ? "..." : "";

  return $"[ {string.Join(", ", sample.Take(10).Select(x => FormatValue(x, format)))}{dots} ]";
}

b) I would augment DebuggerDisplayBuilder<T>.Property and .Collection with an optional format string like:

public DebuggerDisplayBuilder<T> Property<TProperty>(Expression<Func<T, TProperty>> expression, string format = null)
public DebuggerDisplayBuilder<T> Collection<TProperty, TValue>(Expression<Func<T, IEnumerable<TProperty>>> expression, Expression<Func<TProperty, TValue>> formatExpression, string format = null)

You could then call them like this:

  builder.Property(x => x.Age, "{0:F2}");
  builder.Collection(x => x.GraduationYears, x => x, "{0:X2}");

instead of x.Age.ToString("F2") etc.

DebuggerDisplayFormatter.FormatValue(...) should then be changed to something like this:

public static string FormatValue<TValue>(this TValue value, string format = null)
{
  if (value is DBNull) return $"{nameof(DBNull)}";
  if (value == null) return "null";
  if (value.IsNumeric())
  {
    if (format != null)
    {
      return String.Format(format, value);
    }
    else
    {
      return value.ToString();
    }
  }

  return $"'{value}'";
}

and should of cause be called appropriately with the format argument by the clients.


Update

I'm not sure, if this is obvious to others, but, if you don't want to "pollute" your classes with the DebuggerDisplay method or you want to create a custom debug display to a type that you can't modify, then you can place the DebuggerDisplay as a static method on a static class like this:

[assembly: DebuggerDisplay("{AnotherNamespace.DebuggerDisplayers.DebuggerDisplay(this),nq}", Target = typeof(Person))]
[assembly: DebuggerDisplay("{AnotherNamespace.DebuggerDisplayers.DebuggerDisplay(this),nq}", Target = typeof(DateTime))]

namespace AnotherNamespace
{
  public static class DebuggerDisplayers
  {
    public static string DebuggerDisplay(Person value) => DebuggerDisplayHelper<Person>.ToString(value, builder =>
    {
      builder.Property(x => x.FirstName);
      builder.Property(x => x.LastName);
      //builder.Property(x => x._testField); // Can't access a private member
      builder.Property(x => x.DBNullTest);
      builder.Property(x => x.Age, "{0:F2}");
      builder.Property(x => x.GraduationYears.Count);
      builder.Collection(x => x.GraduationYears);
      builder.Collection(x => x.GraduationYears, x => x, "{0:X2}");
      builder.Collection(x => x.Nicknames);
    });

    public static string DebuggerDisplay(DateTime value) => DebuggerDisplayHelper<DateTime>.ToString(value, builder =>
    {
      builder.Property(x => x.Year);
      builder.Property(x => x.Month);
      builder.Property(x => x.Day);
      builder.Property(x => x.Ticks);
    });
  }
}

Please notice the full qualified method name in the assembly directive and the this parameter to DebuggerDisplay(this) in the same line. The penalty is that you can't display private and possible internal members.


If changing DebuggerDisplayFormatter.FormatValue to the below you can avoid the IsNumeric check and you can specify a format string for all property types:

public static string FormatValue<TValue>(this TValue value, string format = null)
{
  if (value == null) return "null";
  if (value is DBNull) return $"{nameof(DBNull)}";

  if (value is string)
  {
    if (format != null)
      return $"'{string.Format(format, value)}'";
    return $"'{value}'";
  }

  if (format != null)
    return string.Format(format, value);

  return value.ToString();
}
\$\endgroup\$
  • \$\begingroup\$ AnotherNamespace.DebuggerDisplayers.DebuggerDisplay(this) Where did you find that? :-o And I thought I'd read the documentation carefully. Another great tipp! \$\endgroup\$ – t3chb0t Apr 3 '18 at 7:04
  • 1
    \$\begingroup\$ @t3chb0t: Well, I really din't find it, I just thought it could be nice to be able to have the debugger method apart from the actual class, so I tried different things, and discovered it more or less by accident. \$\endgroup\$ – Henrik Hansen Apr 3 '18 at 7:27
5
\$\begingroup\$

I'd personally like DebuggerDisplayHelper.ToString() to be an extension method, so I finagled it up as such:

public static class DebuggerDisplayHelper
{
    public static string ToString<T>(this T obj, Action<DebuggerDisplayBuilder<T>> builderAction)
    {
        return DebuggerDisplayHelperInternal<T>.ToString(obj, builderAction);
    }

    private static class DebuggerDisplayHelperInternal<T>
    {
        private static Func<T, string> _toString;

        public static string ToString(T obj, Action<DebuggerDisplayBuilder<T>> builderAction)
        {
            if (_toString is null)
            {
                var builder = new DebuggerDisplayBuilder<T>();

                builderAction(builder);
                _toString = builder.Build();
            }

            return _toString(obj);
        }
    }
}

It'll be called like:

private string DebuggerDisplay() => this.ToString(builder =>
{
    builder.Property(x => x.FirstName);
    builder.Property(x => x.LastName);
    builder.Property(x => x._testField);
    builder.Property(x => x.DBNullTest);
    builder.Property(x => x.Age.ToString("F2"));
    builder.Property(x => x.GraduationYears.Count);
    builder.Collection(x => x.GraduationYears);
    builder.Collection(x => x.GraduationYears, x => x.ToString("X2"));
    builder.Collection(x => x.Nicknames);
});
\$\endgroup\$
2
\$\begingroup\$

I've added the suggested improvements and a couple more.


The DebuggerDisplayHelper class got a non-generic companion to support extensions. The new method is now called ToDebuggerDisplayString.

public static class DebuggerDisplayHelper<T>
{
    private static Func<T, string> _toString;

    public static string ToDebuggerDisplayString([CanBeNull] T obj, Action<DebuggerDisplayBuilder<T>> builderAction)
    {
        if (builderAction == null) throw new ArgumentNullException(nameof(builderAction));

        if (_toString is null)
        {
            var builder = new DebuggerDisplayBuilder<T>();
            builderAction(builder);
            _toString = builder.Build();
        }

        return _toString(obj);
    }
}

public static class DebuggerDisplayHelper
{
    public static string ToDebuggerDisplayString<T>([CanBeNull] this T obj, [NotNull] Action<DebuggerDisplayBuilder<T>> builderAction)
    {
        if (builderAction == null) throw new ArgumentNullException(nameof(builderAction));

        return DebuggerDisplayHelper<T>.ToDebuggerDisplayString(obj, builderAction);
    }
}

The DebuggerDisplayBuilder has been extended to support formatting and max length for collections. A new null check prevents it from crashing when this is null.

public class DebuggerDisplayBuilder<T>
{
    private readonly IList<(string MemberName, Func<T, object> GetValue)> _members;

    public DebuggerDisplayBuilder()
    {
        _members = new List<(string MemberName, Func<T, object> GetValue)>();
    }

    public DebuggerDisplayBuilder<T> Property<TProperty>(
        [NotNull] Expression<Func<T, TProperty>> propertySelector, 
        [NotNull] string format)
    {
        if (propertySelector == null) throw new ArgumentNullException(nameof(propertySelector));
        if (format == null) throw new ArgumentNullException(nameof(format));

        var memberExpressions = DebuggerDisplayVisitor.EnumerateMembers(propertySelector);
        var getProperty = propertySelector.Compile();

        return Add(
            memberName: memberExpressions.FormatMemberName(),
            getValue: obj => obj == null ? null : getProperty(obj).FormatValue(format)
        );
    }

    public DebuggerDisplayBuilder<T> Collection<TProperty, TValue>(
        [NotNull] Expression<Func<T, IEnumerable<TProperty>>> propertySelector,
        [NotNull] Expression<Func<TProperty, TValue>> valueSelector,
        [NotNull] string format,
        int max)
    {
        if (propertySelector == null) throw new ArgumentNullException(nameof(propertySelector));
        if (valueSelector == null) throw new ArgumentNullException(nameof(valueSelector));
        if (format == null) throw new ArgumentNullException(nameof(format));

        var memberExpressions = DebuggerDisplayVisitor.EnumerateMembers(propertySelector);
        var getProperty = propertySelector.Compile();
        var getValue = valueSelector.Compile();

        return Add(
            memberName: memberExpressions.FormatMemberName(),
            getValue: obj => obj == null ? null : getProperty(obj).Select(getValue).FormatCollection(format, max)
        );
    }

    private DebuggerDisplayBuilder<T> Add(string memberName, Func<T, object> getValue)
    {
        _members.Add((memberName, getValue));
        return this;
    }

    public Func<T, string> Build()
    {
        return obj => string.Join(", ", _members.Select(t => $"{t.MemberName} = {t.GetValue(obj)}"));
    }
}

The main class has no optional parameters but instead extensions provide default values.

public static class DebuggerDisplayBuilder
{
    public static DebuggerDisplayBuilder<T> Property<T, TProperty>(
        this DebuggerDisplayBuilder<T> builder,
        Expression<Func<T, TProperty>> propertySelector)
    {
        return builder.Property(propertySelector, DebuggerDisplayFormatter.DefaultValueFormat);
    }

    public static DebuggerDisplayBuilder<T> Collection<T, TProperty, TValue>(
        this DebuggerDisplayBuilder<T> builder,
        Expression<Func<T, IEnumerable<TProperty>>> propertySelector,
        Expression<Func<TProperty, TValue>> valueSelector,
        string format,
        int max = DebuggerDisplayFormatter.DefaultCollectionLength)
    {
        return builder.Collection(propertySelector, valueSelector, DebuggerDisplayFormatter.DefaultValueFormat, max);
    }

    public static DebuggerDisplayBuilder<T> Collection<T, TProperty>(
        this DebuggerDisplayBuilder<T> builder,
        Expression<Func<T, IEnumerable<TProperty>>> propertySelector)
    {
        return builder.Collection(propertySelector, x => x, DebuggerDisplayFormatter.DefaultValueFormat, DebuggerDisplayFormatter.DefaultCollectionLength);
    }
}

The DebuggerDisplayFormatter has lost its IsNumeric helper but gained two default values and custom formatting. The array output now also contains an ... ellipsis and the max number of elements that is always displayed. This could be made more sophisticated but maybe another time...

internal static class DebuggerDisplayFormatter
{
    public const string DefaultValueFormat = "{0}";

    public const int DefaultCollectionLength = 10;

    public static string FormatValue<TValue>([CanBeNull] this TValue value, [NotNull] string format)
    {
        if (format == null) throw new ArgumentNullException(nameof(format));

        if (value == null) return "null";
        if (value is DBNull) return $"{nameof(DBNull)}";

        var valueFormatted = string.Format(CultureInfo.InvariantCulture, format, value);

        return
            value is string
                ? $"'{valueFormatted}'"
                : valueFormatted;
    }

    public static string FormatValue<TValue>([CanBeNull] this TValue value)
    {
        return value.FormatValue(DefaultValueFormat);
    }

    public static string FormatCollection<TValue>([CanBeNull] this IEnumerable<TValue> values, [NotNull] string format, int max)
    {
        if (format == null) throw new ArgumentNullException(nameof(format));

        if (values == null) return "null";

        // [1, 2, 3, ...] (max = 10)
        return $"[{string.Join(", ", values.Select(x => x.FormatValue(format)).Take(max))}, ...] (max {max})"; 
    }

    // Foo.Bar(..).Baz
    public static string FormatMemberName([NotNull] this IEnumerable<Expression> expressions)
    {
        if (expressions == null) throw new ArgumentNullException(nameof(expressions));

        return string.Join(".", expressions.GetMemberNames());
    }

    private static IEnumerable<string> GetMemberNames([NotNull] this IEnumerable<Expression> expressions)
    {
        if (expressions == null) throw new ArgumentNullException(nameof(expressions));

        foreach (var expression in expressions)
        {
            switch (expression)
            {
                case MemberExpression memberExpression:
                    yield return memberExpression.Member.Name;
                    break;
                case MethodCallExpression methodCallExpression:
                    // Ignore ToString calls.
                    if (methodCallExpression.Method.Name == nameof(ToString)) continue;
                    yield return $"{methodCallExpression.Method.Name}(..)";
                    break;
            }
        }
    }
}

The DebuggerDisplayVisitor became an IEnumerable<Expression> being now able to enumerate multiple members for call chains.

internal class DebuggerDisplayVisitor : ExpressionVisitor, IEnumerable<Expression>
{
    // Member expressions are visited in revers order. 
    // This allows fast inserts at the beginning and thus to avoid reversing it back.
    private readonly LinkedList<Expression> _members = new LinkedList<Expression>();

    public static IEnumerable<Expression> EnumerateMembers(Expression expression)
    {
        var memberFinder = new DebuggerDisplayVisitor();
        memberFinder.Visit(expression);
        return memberFinder;
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        _members.AddFirst(node);
        return base.VisitMember(node);
    }

    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        _members.AddFirst(node);
        return base.VisitMethodCall(node);
    }

    #region IEnumerable<MemberExpression>

    public IEnumerator<Expression> GetEnumerator()
    {
        return _members.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion
}

Example

The new test data and builder.

var person = new Person
{
    FirstName = "John",
    LastName = null,
    Age = 123.456,
    DBNullTest = DBNull.Value,
    GraduationYears = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 },
    Nicknames = { "Johny", "Doe" }
};

var toString = person.ToDebuggerDisplayString(builder =>
{
    builder.Property(x => x.FirstName, "{0,8}");
    builder.Property(x => x.LastName);
    builder.Property(x => x.DBNullTest);
    builder.Property(x => x.GraduationYears.Sum());
    builder.Property(x => x.Age, "{0:F2}");
    builder.Property(x => x.GraduationYears.Count);
    builder.Collection(x => x.GraduationYears);
    builder.Collection(x => x.GraduationYears, x => x, "{0:X2}");
    builder.Collection(x => x.Nicknames);
});

and the new output

"FirstName = '    John', LastName = null, DBNullTest = DBNull, GraduationYears.Sum(..) = 78, Age = 123.46, GraduationYears.Count = 12, GraduationYears = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...] (max 10), GraduationYears = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...] (max 10), Nicknames = ['Johny', 'Doe', ...] (max 10)"
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.