CODEWITHSUNDEEP
c#debuggingtostringdebuggerdisplay
bwerks
bwerks

Reputation: 8971

C# debugging: [DebuggerDisplay] or ToString()?

There are two ways to increase the usefulness of debugging information instead of seeing {MyNamespace.MyProject.MyClass} in the debugger.

These are the use of DebuggerDisplayAttribute and the ToString() method.

using System.Diagnostics;
...

[DebuggerDisplay("Name = {Name}")]
public class Person
{
    public string Name;
}

or 

public class Person
{
    public string Name;
    public override string ToString()
    {
        return string.Format("Name = {0}", Name);
    }
}

Is there any reason to prefer one to the other? Any reason not to do both? Is it purely personal preference?

Upvotes: 107

Views: 20342

Answers (7)

Wizou
Wizou

Reputation: 1897

Slowness of the debugger can also be taken into account:

[DebuggerDisplayAttribute()] format expression is interpreted by the debugger after each debugging step / breakpoint.

ToString() is compiled in your code and is therefore much faster to execute by the debugger.

That's the same with conditional breakpoints: If the conditional expression is too slow to interpret by the debugger each time the execution reach the breakpoint, it can be useful to remove the breakpoint and instead add temporary code like this: if (condition) Debugger.Break();

Upvotes: 15

Reed Copsey
Reed Copsey

Reputation: 564323

Using [DebuggerDisplay] is meant only for the debugger. Overriding ToString() has the "side effect" of changing the display at runtime.

This may or may not be a good thing.

Often, you want more info during debugging than your standard ToString() output, in which case you'd use both.

For example, in your case, the ToString() implementation seems odd to me. I would expect a Person class ToString() implementation to just return the Name directly, not "Name = PersonsName". However, during debugging, I might want that extra information.

Upvotes: 113

David V. Corbin
David V. Corbin

Reputation: 397

Personal Preference (when the desired output is not really 100% known)

  1. Implement HelperFunction
  2. Implement ToString in terms of HelperFunction
  3. Implement DebuggerDisplay in terms of HelperFunction.

Now future edits can either differentiate or remain consistent as appropriate and there is better tracbility.

Upvotes: 2

JHM
JHM

Reputation: 411

DebuggerDisplay is quicker to type for something simple.

ToString() can be much more complex in case the data you want to view depends on the properties of the object. Combine with #if DEBUG statement and you'll have a good DEBUG-only data viewer. Literally no one uses ToString() as-is for "client view", because it's too vague and any changes would be impossible to maintain logically. Everybody always call explicit properties or methods instead of ToString(), except if providing that string is the sole purpose of the class and it's the same also in debugging.

There also are the DebuggerBrowsableAttribute and DebuggerTypeProxyAttribute, but those are just added complexity if there is no real need for such thing.

Upvotes: 1

Victor Chelaru
Victor Chelaru

Reputation: 4807

If you use Xamarin to develop for Android, the ToString method will not be shown in the watch window, but DebuggerDisplay will.

Upvotes: 1

Peter B
Peter B

Reputation: 1581

DebuggerDisplay is quite limited in what it can do. You only have a format string that you can use to show values of certain members.

If you want to show data conditionally, data from several levels deep, or aggregated data, ToString() might be your only option.

Upvotes: 0

Piotr Perak
Piotr Perak

Reputation: 11088

"When you create a custom class or struct, you should override the ToString method in order to provide information about your type to client code." — MSDN

If what ToString() returns and you see in debugger is not what you would like then you use DebuggerDisplayAttribute.

Upvotes: 8

Related Questions