1

When debugging there are various Variable windows (autos, locals, watch) containing columns Name,Value,Type. The value often seems to show an object's class name. In specific cases I would like to show something more meaningful based on the properties of the class instance.

As a specific example, for CodeTypeReference I'd like to see a text representation of the type referenced (where valid) based on the BaseType string or ArrayElementType value, rather than seeing "System.CodeDom.CodeTypeReferenceExpression".

Visualizers seem to offer separate dialog windows, rather than a way to populate the value column.

Data tips are per variable rather than per type.

The closest thing seems to be the DebuggerTypeProxyAttribute in which case I guess I'm asking "Is it possible to apply an attribute to somebody else's class ?"

I'm mainly dealing with Visual Studio 2010 although a Visual Studio 2008 answer would be useful.

Omer Raviv
  • 11,409
  • 5
  • 43
  • 82
WaffleSouffle
  • 3,293
  • 2
  • 28
  • 27

3 Answers3

7

Yes, there are two ways you can accomplish this:

  1. By using OzCode (previously BugAid for Visual Studio), a commercial tool that I created, you can simply star properties/fields on your type, and have those appear in the Value column on any type, whether it is 3rd party or not.

  2. You can change your autoexp.cs file, and apply either the DebuggerDisplayAttribute or the DebuggerTypeProxyAttribute to 3rd party types, as described in my answer on a similar question. For example, this is how you would apply the DebuggerDisplayAttribute to System.Drawing.Pen: [assembly: DebuggerDisplay(@"\{Color = {color}}", Target = typeof(Pen))]

This answer applies to both VS2008 and VS2010.

Jens
  • 2,327
  • 25
  • 34
Omer Raviv
  • 11,409
  • 5
  • 43
  • 82
  • 1
    Thanks - somehow I'd missed autoexp.cs Got this working, but only if I use the DebbugerDisplay parameter Target=typeof(MyAssembly::Foo). Couldn't get TargetTypeName="MyAssembly.Foo" to work including adding brace decoration. – WaffleSouffle Oct 05 '11 at 15:33
  • 1
    Fastforward several years and discovered that the `TargetTypeName` works for an instance's `GetType().AssemblyQualifiedName` which is typically an entry in _autoexp.cs_ something like: `[assembly: DebuggerDisplay(@"ProofInPudding {_privateStringData}", TargetTypeName = "MyNamespace.MySubNamespace.MyClassName, MyAssemblyName, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null")]` which will display `ProofInPooding "foo"` for an instance of that type who's `_privateStringData` field (or property) is set to `"foo"`. – WaffleSouffle Feb 24 '15 at 17:46
  • 2
    Or even drop the version/culture/public key token and use `[assembly: DebuggerDisplay(@"ProofInPudding {_privateStringData}", TargetTypeName = "MyNamespace.MySubNamespace.MyClassName, MyAssemblyName")]` – WaffleSouffle Feb 24 '15 at 17:57
1

You can override the ToString method for your own classes. The Value is usually just a call to ToString, and if not overridden, this shows the type.

Update: For classes you do not have the code for, I cannot provide a valuable answer rather than you could wrap the classes ( inherit from ), but that is, hm, strange to be polite ( IMHO ).

Sascha
  • 10,231
  • 4
  • 41
  • 65
  • 2
    I don't recommend doing this - I used to override `ToString()` to quickly inspect data in objects in the debugger but it has a tendency of becoming permanent code and then it starts introducing all kinds of problems. `ToString()` is intended to provide a string representation of an object while devs usually want to see all kinds of internal detail in the debugger. – xxbbcc Oct 30 '12 at 03:55
0

Yes you can apply DebuggerTypeProxyAttribute to types you don't own (unless they are private) as explained in my answer to a similar question here

Jens
  • 2,327
  • 25
  • 34