Visual Basic 1002005 [A Developers Notebook] [Electronic resources] نسخه متنی

1.3. Look Inside an Object While Debugging

Visual Studio
has always made it possible for you to
peer into variables while debugging your code, just by hovering over
them with the mouse pointer. But there were always limitations. If
the variable was an instance of an object, all you could see was the
value returned by the ToString( ) method, which
more often than not was simply the fully qualified name of the class
itself. Moreover, you couldn't see the content of
public properties and indexers. The Watch and Locals windows provided
some improvement, but they weren't quite as
convenient or intuitive. Visual Studio 2005 changes the picture with
a new feature called debugger DataTips.

Note: In Visual Studio 2005, it's even easier to
take a look at the content of complex objects while
debugging.

1.3.1. How do I do that?

To use debugger DataTips, it helps to have a custom class to work
with. The code in Example 1-1 shows the declaration
for two very simple classes that represent employees and departments,
respectively.

Example 1-1. Two simple classes

Public Class Employee
Private _ID As String
Public ReadOnly Property ID( ) As String
Get
Return _ID
End Get
End Property
Private _Name As String
Public ReadOnly Property Name( ) As String
Get
Return _Name
End Get
End Property
Public Sub New(ByVal id As String, ByVal name As String)
_ID = id
_Name = name
End Sub
End Class
Public Class Department
Private _Manager As Employee
Public ReadOnly Property Manager( ) As Employee
Get
Return _Manager
End Get
End Property
Private _DepartmentName As String
Public ReadOnly Property Name( ) As String
Get
Return _DepartmentName
End Get
End Property
Public Sub New(ByVal departmentName As String, ByVal manager As Employee)
_DepartmentName = departmentName
_Manager = manager
End Sub
End Class

Now you can add some code that uses these objects. Add the following
event handler to any form to create a new Employee
and Department object when the form first loads.

Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
Dim Manager As New Employee("ALFKI", "John Smith")
Dim Sales As New Department("Sales", Manager)
End Sub

Now place a breakpoint on the final End
Sub, and run the application. When execution stops
on the final line, hover over the Sales variable.
An expanded ToolTip will appear that lists every private
and public member of the object.

Even better, if one object references another, you can drill into the
details of both objects. To try this out, click the plus sign (+)
sign next to the Manager property to see the
linked Employee object. Figure 1-5 shows the DataTip you'll see.

Figure 1-5. Peering into an object

Using debugger DataTips, you can also edit simple data types on the
fly. Just double click the property or variable, and edit the value.
In Figure 1-5, the private variable
_Name is currently being edited.

1.3.2. What about...

...working with exotic types of data? Using the .NET Framework,
it's possible to create design-time classes that
produce customized visualizations for specific types of data. While
this topic is outside the scope of this book, you can see it at work
with the three built-in visualizers for text, HTML, and XML
data.

For example, imagine you have a string variable that holds the
content of an XML document. You can't easily see the
whole document in the single-line ToolTip display. However, if you
click the magnifying glass next to the content in
the ToolTip, you'll see a list of all the
visualizers you can use. Select XML Visualizer, and a new dialog box
will appear with a formatted, color-coded, scrollable, resizable
display of the full document content, as shown in Figure 1-6.

Figure 1-6. Viewing XML content while debugging

1.3.3. Where can I learn more?

For more information about debugger visualizers, look for the
"Visualizers" index entry in the
MSDN help.