(If you’re new to Entrian Inline Watch, check out the intro page!)

I’m pleased to announce Entrian Inline Watch 0.9.1, which fixes the following bugs:

• Parameter values are now displayed properly for functions with a throw() signature (thanks, Martin).
• Where there’s no Object Display rule for a class, and the debugger’s default value looks like {ClassName}, don’t clutter the code with it (thanks, Jan and Martin).
• Commenting out a line in the Object Display settings no longer affects the layout of the columns.

You can download this new release from the download page or the gallery.

(Update: version 0.9.2 also updates the Beta expiry date. 🙂 )

I’ve just published Entrian Inline Watch 0.8.9, with these enhancements:

• You can now suppress the display of values for a type, by entering a blank format for it in the Object Display settings.
• When an accessor expression like p->get_x() doesn’t render a value, a value is now displayed for p (thanks, Martin).
• Values are now correctly rendered for pointers to pointers (to pointers to pointers to pointers…) (thanks, Martin).
• Fixed an intermittent crash that was due to Visual Studio firing debugger events re-entrantly (yeah, thanks, Visual Studio 🙂 )

You can download the new release from the download page or the gallery.

I’m pleased to announce Entrian Inline Watch 0.8.8, with the following enhancements:

• Object expressions can now follow references, eg. {m_x.y->z} (thanks, Martin).
• If Inline Watch crashed, it could produce a crash report with no meaningful stack trace (thanks, Chris).
• Object expressions can now special-case nullptr, eg. {p_str == nullptr ? "No!" : p_str} (thanks, Martin).
• Fixed a bug whereby in a scope with lots of variables, the last few to be evaluated might not be displayed.
• For pointers to objects, if there’s nothing meaningful to display for the object, display the pointer value rather than nothing (thanks, Martin).
• Expressions of the form x.y - (z) now display the value of x.y properly (thanks, Martin).

You can download the new release from the download page or the gallery.

I’ve just published Inline Watch 0.8.6, which includes this new feature:

• You can now control the maximum length of the displayed values

and a bunch of features related to custom formatting of object instances:

• Integer arithmetic in object formats, eg. {right-left} to display the width of a rectangle
• Pointer arithmetic, eg. {m_str+4} where your string actually starts at an offset
• Array indexing, eg. {m_arr[N]} where you want to display the N’th member of an array, where N can be a literal, {m_arr[4]} or another member, {m_arr[m_index]}
• Specifying the length of a string (when your string is long, or not null-terminated), again with a literal, {m_str,8}, or another member {m_str,{m_len}}
• Displaying braces now requires them to be backslash escaped – see the next example:
• Force hex or decimal display in object formats, so if you always want your Point instances to be displayed in decimal like this: {50, 100} even if the Visual Studio debugger is set to hex display, you can say \{{m_x,d}, {m_y,d}\}. Use an x to get hex display.

Here’s an example that demonstrates some of these features.  (It’s based on a customer example – they have a C++ string class whose string buffer includes a leading reference count, and is not NUL-terminated but instead has a length member.)

struct Formatting
{
  const char *s;     // 4-byte refcount then an unterminated string.
  int len;           // Number of chars in the string, counting from s+4.
  const char *a[3];  // An array of three C-style strings.
  int current;       // Which of the three strings is the 'current' one?

  Formatting()
  {
    s = "\x1\x2\x3\x4TextGARBAGEGARBAGE...";
    len = 4;
    a[0] = "Zero";
    a[1] = "One";
    a[2] = "Two";
    current = 1; // "One" is the string to display.
  }
};

With an object formatting rule like this:

\{{s + 4,{len}}, {a[current]}\}

a Formatting instance displays like this: {“Text”, “One”}

You can download the new release from the download page or the gallery.

I’m really excited to announce a new product from Entrian Solutions: Entrian Inline Watch.

It displays the values of variables inline in your source code, updated live as you step through your code:

You can see the live values right there in the source, rather than having to hover over them with the mouse, or find them in the Watch windows.

As soon as you land in a function, or at a breakpoint, you can see the values of your function parameters and variables instantly.

It makes debugging almost pleasant.  You and your team need it.  🙂

Entrian Inline Watch works with Visual Studio 2010, 2012, 2013 or 2015; any edition except Express.

It works with both Managed and Native debugging; in C++, C#, and VB.

It’s free during the Beta period, with builds timing out after a few weeks.  Once it’s out of Beta it will cost $29 per developer, or $24 with a volume discount.

Download it from the download page, read the fine manual and the FAQ, and let me know what you think!  (And bear in mind it’s in Beta, and therefore does not carry a no-weirdness guarantee.)