(1 item) |
|
(1 item) |
|
(5 items) |
|
(1 item) |
|
(1 item) |
|
(2 items) |
|
(2 items) |
|
(4 items) |
|
(1 item) |
|
(6 items) |
|
(2 items) |
|
(4 items) |
|
(1 item) |
|
(4 items) |
|
(2 items) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(2 items) |
|
(2 items) |
|
(5 items) |
|
(3 items) |
|
(1 item) |
|
(1 item) |
|
(1 item) |
|
(3 items) |
|
(1 item) |
|
(1 item) |
|
(2 items) |
|
(8 items) |
|
(2 items) |
|
(7 items) |
|
(2 items) |
|
(2 items) |
|
(1 item) |
|
(2 items) |
|
(1 item) |
|
(2 items) |
|
(4 items) |
|
(1 item) |
|
(5 items) |
|
(1 item) |
|
(3 items) |
|
(2 items) |
|
(2 items) |
|
(8 items) |
|
(7 items) |
|
(3 items) |
|
(7 items) |
|
(6 items) |
|
(1 item) |
|
(2 items) |
|
(5 items) |
|
(5 items) |
|
(7 items) |
|
(3 items) |
|
(7 items) |
|
(16 items) |
|
(10 items) |
|
(27 items) |
|
(15 items) |
|
(15 items) |
|
(13 items) |
|
(16 items) |
|
(15 items) |
I was a little confused by Julia Lerman's recent
post on how you can see inside a DataSet
from the debugger in VS.NET 2005.
I was confused because the screenshots show nothing you can't do with VS.NET 2003, which has been shipping for a while now...
The first screenshot seems to show a
DataSet
's Tables
collection being expanded. Here is the exact same thing being done
with a DataSet
I'm working on at the moment.
It looks less pretty, which is the giveaway that I'm using VS.NET 2003 rather than VS.NET 2005, but it's showing
pretty much the same information as Julia's screenshot. The main difference is that my example is using a strongly-typed DataSet
,
so some of the type names are different. (In fact drilling into strongly-typed DataSet
s is much easier than this - you don't need
to dive into the Tables
collection at all - you can just go straight to the named table.)
VS.NET 2003 also lets you drill into the Columns
collection as Julia's second screenshot shows VS.NET 2005 doing. And most importantly, VS.NET 2003 also lets you expand the Rows
property of a table to see the actual data. (The Columns
property just shows you metadata.) I'm assuming VS.NET 2005 supports that
too.
It looked to me like VS.NET 2005 wasn't offering anything here I didn't already have in VS.NET 2003, so I contacted Julia to find out
what I was missing. After a short spell of confusion caused by each of us seeing different results, we eventually realised that the
VB.NET lifestyle is what I was missing. I put together a project that passes a DataSet
between a C# and a VB.NET component, and
the debugger presents the same DataSet
object differently depending on the language of the code you happen to be looking at it
from! In C# you get the full guts of the DataSet
as shown above, but in VB.NET you get a much smaller selection.
I didn't previously realise that VB.NET showed less information than C# does for the exact same object. You would kind of think that
a given object from the .NET Framework Class Library would look the same in the debugger regardless of language - a DataSet
doesn't
change the way it works just because I'm using it from VB.NET. But the key to understanding this is that VS.NET attempts to present
all objects to you in a way that looks right for whatever language you're using. It therefore requires each language to provide an 'expression evaluator'
- this is a component used by the debugger to work out how to present information in the debugger. Presumably it was just a limitation in the VB.NET
expression evaluator that was preventing you from drilling into a DataSet
in the debugger in VS.NET 2003.
So beta 1 of VS.NET 2005 just brings VB.NET up to the same level that C# has always had. This is slightly disappointing, as I was
hoping that they would be using the new data visualisation features in VS.NET 2005 to present the contents of the DataSet
in an easier to
read fashion. Maybe that's coming in the next beta...