使用Visual Studio 2013编写可维护的本地可视化(natvis)

在Visual Studio 2012中，我们介绍了创建可视化使用原生类型的能力natvis文件。 Visual Studio 2013中包含了一些改进，使其更容易编写可视化的类，在内部利用收集来存储项目。 在这篇博客文章中，我将介绍一个示例场景，告诉你什么是你必须做的VS2012以达到预期的效果，然后告诉你如何在natvis创作变得更容易，体验VS2013新功能的增强。

示例场景

让我们考虑下面的源代码，并假设我们是在写一个可视化的CNameList类：

  #include <vector>

 using namespace std;

 class CName

 {

 private:

     string m_first;

     string m_last;

 public:

     CName(string first, string last) : m_first(first), m_last(last) {}

     void Print()

     { 

         wprintf(L"%s %s\n", (const char*) m_first.c_str(), (const char*) m_last.c_str());

     }

 };

 class CNameList

 {

 private:

     vector m_list;

 public:

     CNameList() {}

     ~CNameList()

     {

         for (int i = 0; i < m_list.size(); i++)

         {

             delete m_list[i];

         }

         m_list.clear();

     }

     void AddName(string first, string last)

     {

         m_list.push_back(new CName(first, last));

     }

 };

 int _tmain(int argc, _TCHAR* argv[])

 {

     CNameList presidents;

     presidents.AddName("George", "Washington");

     presidents.AddName("John", "Adams");

     presidents.AddName("Thomas", "Jefferson");

     presidents.AddName("Abraham", "Lincoln");

     return 0;

 }

CNameList可视化工具

在Visual Studio 2012中，它可能会非常棘手，有人编写了可视化的CNameList类。 最明显的natvis创作：

   <?xml version="1.0" encoding="utf-8"?>

 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">

   <Type Name="CNameList">

     <Expand>

       <ExpandedItem>m_list</ExpandedItem>

     </Expand>

   </Type>

   <Type Name="CName">

     <DisplayString>{m_first} {m_last}</DisplayString>

     <Expand>

       <Item Name="First">m_first</Item>

       <Item Name="Last">m_last</Item>

     </Expand>

   </Type>

 </AutoVisualizer>

会显示如下：

因为我们希望以可视化查看CNameList对象的内容，而不是它的实现细节，我们可以不关心内部向量的大小或容量，也关于每个CNAME对象在列表中的内存地址，或周围的引号姓氏和名字，以表明它们是作为单独的字符串存储。 使用Visual Studio 2012，去掉这混乱是可能的，但比较繁琐，并且需要可视化的CNAME和CNameList被加上了STL的实现细节。 例如，在VS2012我们可以摆脱的尺寸和载体的容量，以及CNAME对象的存储器地址，通过与该更换可视化对于CNameList的：

  <Type Name="CNameList">

     <Expand>

       <IndexListItems>

         <Size>m_list._Mylast - m_list._Myfirst</Size>

         <ValueNode>*m_list._Myfirst[$i]</ValueNode>

       </IndexListItems>

     </Expand>

   </Type>

  <Type Name="CName">

     <DisplayString Condition="m_first._Myres &lt; m_first._BUF_SIZE &amp;&amp; m_last._Myres &lt; m_last._BUF_SIZE">{m_first._Bx._Buf,sb} {m_last._Bx._Buf,sb}</DisplayString>

     <DisplayString Condition="m_first._Myres &gt;= m_first._BUF_SIZE &amp;&amp; m_last._Myres &lt; m_last._BUF_SIZE">{m_first._Bx._Ptr,sb} {m_last._Bx._Buf,sb}</DisplayString>

     <DisplayString Condition="m_first._Myres &lt; m_first._BUF_SIZE &amp;&amp; m_last._Myres &gt;= m_last._BUF_SIZE">{m_first._Bx._Buf,sb} {m_last._Bx._Ptr,sb}</DisplayString>

     <DisplayString Condition="m_first._Myres &gt;= m_first._BUF_SIZE &amp;&amp; m_last._Myres &gt;= m_last._BUF_SIZE">{m_first._Bx._Ptr,sb} {m_last._Bx._Ptr,sb}</DisplayString>

     <Expand>

       <Item Condition="m_first._Myres &lt; m_first._BUF_SIZE" Name="First">m_first._Bx._Buf,sb</Item>

       <Item Condition="m_first._Myres &gt;= m_first._BUF_SIZE" Name="First">m_first._Bx._Ptr,sb</Item>

       <Item Condition="m_last._Myres &lt; m_last._BUF_SIZE" Name="Last">m_last._Bx._Buf,sb</Item>

       <Item Condition="m_last._Myres &gt;= m_last._BUF_SIZE" Name="Last">m_last._Bx._Ptr,sb</Item>

     </Expand>

   </Type>

虽然这些可视化的工作肯定的，因为它们产生在监视窗口中所需的输出整洁感。他们需要更多的工作，编写和维护。 首先，可视化工具为CNameList和CNAME现在对类在STL私有成员的依赖。 由于实施细则STL如有更改，这些可视化工具是在Visual Studio中的未来版本中无法正常工作，如果STL实现改变这些条目依赖于一些风险。 此外，如果CNameList的分布有可能被列入任何版本的Visual Studio中的头文件，你可能需要包括CNAME单独natvis条目，对于STL的每个实现，那么必须更新所有的人，任何时间在CNAME的实施改变了未来。

此外，当观察仪的内部类有在它条件句的条件句结束的方式，使可视一团糟相乘。 例如，内置的观察仪的std :: basic_string的有两种可能的显示字符串的情况：

  <Type Name="std::basic_string&lt;char,*&gt;">

     <DisplayString Condition="_Myres &lt; _BUF_SIZE">{_Bx._Buf,s}</DisplayString>

     <DisplayString Condition="_Myres &gt;= _BUF_SIZE">{_Bx._Ptr,s}</DisplayString>

     <StringView Condition="_Myres &lt; _BUF_SIZE">_Bx._Buf,s</StringView>

     <StringView Condition="_Myres &gt;= _BUF_SIZE">_Bx._Ptr,s</StringView>

     <Expand>

         <Item Name="[size]">_Mysize</Item>

         <Item Name="[capacity]">_Myres</Item>

         <ArrayItems>

             <Size>_Mysize</Size>

             <ValuePointer Condition="_Myres &lt; _BUF_SIZE">_Bx._Buf</ValuePointer>

             <ValuePointer Condition="_Myres &gt;= _BUF_SIZE">_Bx._Ptr</ValuePointer>

         </ArrayItems>

     </Expand>

 </Type>

。

CNameList展台为Visual Studio 2013

在Visual Studio 2013中，可以这样编写整洁的CNameList在监视窗口：

  <?xml version="1.0" encoding="utf-8"?>

 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">

   <Type Name="CNameList">

     <Expand>

       <ExpandedItem>m_list,view(simple)na</ExpandedItem>

     </Expand>

   </Type>

   <Type Name="CName">

     <DisplayString>{m_first,sb} {m_last,sb}</DisplayString>

     <Expand>

       <Item Name="First">m_first,sb</Item>

       <Item Name="Last">m_last,sb</Item>

     </Expand>

   </Type>

 </AutoVisualizer>

多个对象视图

在Visual Studio 2012中，<类型>条目只能描述一种方式来查看的对象。

在Visual Studio 2013年，每种类型仍然只有一个默认的视图，而现在它是可能的natvis项来定义，可以通过适当的格式说明访问其他视图。 例如，在Visual Studio 2013的可视化的std ::矢量这样做是这样的：

  <Type Name="std::vector&lt;*&gt;">

     <DisplayString>{{ size={_Mylast - _Myfirst} }}</DisplayString>

     <Expand>

         <Item Name="[size]" ExcludeView="simple">_Mylast - _Myfirst</Item>

         <Item Name="[capacity]" ExcludeView="simple">_Myend - _Myfirst</Item>

         <ArrayItems>

             <Size>_Mylast - _Myfirst</Size>

             <ValuePointer>_Myfirst</ValuePointer>

         </ArrayItems>

     </Expand>

 </Type>

在<DisplayString>和<ArrayItems>元素总是使用，而“[大小]”和“[容量]”项目被排除在了有“简单”的名称的视图。 通常情况下，将显示使用默认视图，它会显示所有元素对象。 然而，“，图”格式说明可用于指定备用视图，如图整数的简单向量的本实施例。 需要注意的是“VEC，视图（XXX）”的行为完全一样的默认视图因为载体natvis条目不包含任何特殊行为“XXX”的观点。

如果要被添加到natvis元件，而不是除去从一个特定视图中，可以使用，而不是“ExcludeView”该“IncludeView”属性。 你也可以指定的意见“IncludeView”和“ExcludeView”分号分隔的属性列表，如果你想属性应用到一组的意见，而不是只有一个。 例如，该可视化将显示“备用视图”使用两种“视图（备用）”或“视图（alternate2）”的显示文本，而在其他情况下，“默认视图”。

 <Type Name="MyClass">

     <DisplayString IncludeView="alternate; alternate2">Alternate view </DisplayString>

     <DisplayString>Default View</DisplayString>

   </Type>

所以，回到我们的例子中，我们CNameList以可视化的“载体”可视化定义的“简单”的观点的优势，消除的大小和容量节点杂波：

  <Type Name="CNameList">

     <Expand>

       <ExpandedItem>m_list,view(simple)na</ExpandedItem>

     </Expand>

   </Type>

跳过存储器地址

：

  <Type Name="CNameList">

     <Expand>

       <IndexListItems>

         <Size>m_list._Mylast - m_list._Myfirst</Size>

         <ValueNode>*m_list._Myfirst[$i]</ValueNode>

       </IndexListItems>

     </Expand>

   </Type>

在我们的CNameList例子中，我们使用“呐”格式说明隐藏CNAME对象，这是不重要的内存地址。 无“，不适用”格式说明，隐藏内存地址将需要复制粘贴，修改为可视化的std ::向量，使其取消引用矢量内的元素，如图所示这里。

还应当指出的是，“娜”格式说明是不太一样的对其操作“*”。 尽管“呐”格式说明会忽略数据的存储地址所指向，仍然会显示有关该地址的任何可用的符号信息。 例如，在功能的情况下，“* wmain”将是一个语法错误，但“wmain，NA”表示“wmain”功能的模块和签名，省略存储器地址。 同样，“＆myGlobal，娜”仍显示你的指针指向符号“INT myGlobal”。 在“NA”格式说明，也可以用在内存地址中的一个函数中，如图中的“（void *）以EIP，呐”的例子。 这可以使“呐”格式说明用于可视化已记录对象的内部，用于调试的堆栈跟踪颇具吸引力。

传播格式说明

尽管“SB”格式说明已经存在在Visual Studio 2012，创作的CNAME可视化这样的VS2012不工作：

  <Type Name="CName">

     <DisplayString>{m_first,sb} {m_last,sb}</DisplayString>

     <Expand>

       <Item Name="First">m_first,sb</Item>

       <Item Name="Last">m_last,sb</Item>

     </Expand>

   </Type>

当应用到矢量对象时，Visual Studio 2012将简单地忽略它，就像这样：

在Visual Studio 2013，“X”干脆自动向下传播到向量的孩子，像这样：

其他的可视化改进

使用类的显示字符串中的最后执行的名字：

在Visual Studio 2013，对于一个基类natvis条目可能利用对象的实现类的名称$（类型）宏单元内。 举例来说，如果我们有这个源代码：

class Room

 {

 private:

     int m_squareFeet;

 public:

     Room() : m_squareFeet(100) {}

     virtual void Print() = 0;

 };

 class Bedroom : public Room

 {

 public:

     virtual void Print() { printf("Bedroom");  }

 };

 class LivingRoom : public Room

 {

 public:

     virtual void Print() { printf("Living room");  }

 };

 class DiningRoom : public Room

 {

 public:

     virtual void Print() { printf("Dining room");  }

 };

 int _tmain(int argc, _TCHAR* argv[])

 {

     Bedroom br;

     LivingRoom lr;

     DiningRoom dr;

     br.Print();

     lr.Print();

     dr.Print();

 }

我们可以写一个可视化工具类“室”是这样的：

  <?xml version="1.0" encoding="utf-8"?>

 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">

   <Type Name="Room">

     <DisplayString>{m_squareFeet}-square foot $(Type)</DisplayString>

   </Type>

 </AutoVisualizer>

这将显示我们有哪种类型的房间，就像这样：

在Visual Studio 2012，取得该显示将需要创建一个单独的<类型>元素为每种类型的房间。

请注意，使用美元（类型）是大小写敏感的。 $（TYPE）将无法正常工作。 此外，使用美元（类型）需要的基类来包含至少一个虚拟函数，因为没有一个V表的存在，调试器没有办法知道对象的实现类实际上是。

支持循环链表

在Visual Studio 2013中，<LinkedListItems>元素增加了圆形表指向回到列表的头部，表示终端的支持。 例如，用下面的源代码：

 class CircularList

 {

 private:

     struct Node

     {

         int m_value;

         Node* m_pNext;

     };

     Node* m_pFirst;

     Node* GetTail()

     {

         if (!m_pFirst)

             return NULL;

         Node* pNode = m_pFirst;

         while (pNode->m_pNext != m_pFirst)

             pNode = pNode->m_pNext;

         return pNode;

     }

 public:

     CircularList() : m_pFirst(NULL) {}

     ~CircularList()

     {

         Node* pNode = m_pFirst;

         while (pNode != m_pFirst)

         {

             Node* pNext = pNode->m_pNext;

             delete pNode;

             pNode = pNext;

         }

     }

     void AddTail(int i)

     {

         Node* pNewNode = new Node();

         if (m_pFirst)

             GetTail()->m_pNext = pNewNode;

         else

             m_pFirst = pNewNode;

         pNewNode->m_value = i;

         pNewNode->m_pNext = m_pFirst;

     }

 };

 int _tmain(int argc, _TCHAR* argv[])

 {

     CircularList list;

     list.AddTail(1);

     list.AddTail(2);

     list.AddTail(3);

        return 0;

 }

我们可以用一个简单的元素，像这样显示的“名单”的价值：

   <?xml version="1.0" encoding="utf-8"?>

 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">

   <Type Name="CircularList">

     <Expand>

       <LinkedListItems>

         <HeadPointer>m_pFirst</HeadPointer>

         <NextPointer>m_pNext</NextPointer>

         <ValueNode>m_value</ValueNode>

       </LinkedListItems>

     </Expand>

   </Type>

 </AutoVisualizer>

在Visual Studio 2013，输出是这样的：

在Visual Studio 2012年，名单将被假定为永远持续下去，因为列表节点的“下一个”指针从来都不是NULL，从而产生这样的输出：

写在最后

Visual Studio 2013旨在解决natvis框架缺陷，改进其可视化体验。