The Visual Basic Team : Data_Design

VB Video Tutorials on ASP.Net Dynamic Data (Lisa Feigenbaum)

VBTeam — Sat, 11 Oct 2008 19:00:00 GMT

Bill Burrows, VB MVP, has released some great videos on the ASP.Net Dynamic Data features that were added in VS2008 SP1. What is Dynamic Data?

"ASP.Net Dynamic Data provides a framework that enables you to quickly build a functional data-driven application, based on a LINQ to SQL or Entity Framework data model. It also adds great flexibility and functionality to the DetailsView, FormView, GridView, and ListView controls in the form of smart validaton and the ability to easily change the display of these controls using templates."

Bill's videos demonstrate the variety of tasks and customizations that you can do using this framework.

http://www.myvbprof.com/2007_Version/Dynamic_Data_Tutorial.aspx

How LINQ to Dataset works in VB (Jonathan Aneja)

VBTeam — Thu, 15 May 2008 02:52:00 GMT

LINQ at its core requires any data source to be queryable, which basically means it must implement IEnumerable. (It’s actually a bit more complicated than that, for a full explanation see section 11.21.2 of the Visual Basic 9.0 Language Specification). Now when working with LINQ to Dataset we have a problem: DataTable does not implement IEnumerable, so how can we query over it?

As we saw yesterday, Visual Studio 2008 includes an assembly called System.Data.DataSetExtensions.dll, which defines an extension method called AsEnumerable(). Here’s what this method looks like:

<Extension()> _

Public Function AsEnumerable(source As DataTable) As EnumerableRowCollection(Of DataRow)

Basically this takes in a DataTable and sends back something that implements IEnumerable(Of T), which LINQ can then consume using the standard query operators. So all you have to do is import System.Data (which is done by default in the project templates) and then you can use LINQ against a Dataset by calling AsEnumerable().

Dim customers = TestDS.Tables("Customers")

Dim franceCustomers = From cust In customers.AsEnumerable() _

Where cust!Country = "France" _

Select cust

Now one of the interesting things about the way LINQ works in VB is you don’t actually have to call AsEnumerable() explicitly for the code above to compile. Even though DataTable does not implement IEnumerable, the compiler helps out here by looking for methods that can turn it into something queryable. When the VB compiler encounters a LINQ query over a type that does not implement IEnumerable, IEnumerable(Of T), IQueryable, or IQueryable(Of T) it then does the following, in order:

1. See if there is a conforming Select method available on the type.

2. See if the type has an instance method named AsQueryable which returns a type that is queryable.

3. See if the type has an extension method in scope named AsQueryable which returns a type that is queryable.

4. See if the type has an instance method named AsEnumerable which returns a type that is queryable.

5. See if the type has an extension method in scope named AsEnumerable which returns a type that is queryable.

If at any point the compiler finds a method that matches, it inserts a call to it. When the System.Data namespace is imported, the compiler finds a match for DataTable on step 5, and inserts the call to AsEnumerable for you. As a result you can write LINQ to Dataset code like this example from the 101 LINQ Samples:

Dim customers = TestDS.Tables("Customers")

Dim franceCustomers = From cust In customers _

Where cust!Country = "France" _

Select cust

What this means is that you can LINQ-enable your types by providing an AsEnumerable extension method that returns something that is queryable.

Note that for strongly-typed Datasets you don’t need to call AsEnumerable, as they inherit from TypedTableBase(Of T) which implements IEnumerable. This is a new type in VS2008; in VS2005 the Dataset Designer would generate code that inherited from DataTable and then explicitly implemented IEnumerable itself.

TableAdapter and Multiple Result Sets

VBTeam — Tue, 13 Mar 2007 21:16:00 GMT

Several people asked me whether TableAdapter can be used to retrieve multiple result sets from stored procedures. The quick answer is... No, you can't do that with TableAdapter.Fill() method that gets generated as a part of Typed Dataset. But there's a very simple work-around.

DataAdapter.Fill() & Multiple Result Sets

TableAdapter.Fill() method calls DataAdapter.Fill() to retrieve data from database. And DataSet.Fill() method allows you to retrieve multiple result sets from a stored procedure. In order to retrieve multiple result sets, an overload of DataAdapter.Fill() that takes Dataset as a parameter needs to be used. If you do that, you get back a Dataset that contains multiple data tables filled with result sets returned by your stored procedure.

Here's a simple example that shows you how this works.

Let's say that you have a stored procedure called dbo.spSelectCustomersOrders in Northwind database.

CREATE PROCEDURE spSelectCustomersOrders
AS
BEGIN
    SET NOCOUNT ON;
    SELECT * FROM Customers
    SELECT * FROM Orders
END
GO

Below code will call this stored procedure and fill Dataset with both result sets.

Dim myConn As New System.Data.SqlClient.SqlConnection
Dim myAdapter As New System.Data.SqlClient.SqlDataAdapter
Dim mySelectCommand As New System.Data.SqlClient.SqlCommand
Dim myDataset As New System.Data.DataSet

myConn.ConnectionString = "Data Source=.\SQLExpress;Initial Catalog=Northwind;Integrated Security=True"
mySelectCommand.Connection = myConn
mySelectCommand.CommandText = "dbo.spSelectCustomersOrders"
myAdapter.SelectCommand = mySelectCommand
myAdapter.Fill(myDataset)

For Each table As System.Data.DataTable In myDataset.Tables
Console.WriteLine("Table Name:" & table.TableName)
Next

Output of this code looks like this.

Table Name: Table
Table Name: Table1

As you can see, DataAdapter.Fill() method executed the stored procedure and put each result set into two separate DataTables.

TableAdapter Solution

But why doesn't TableAdapter.Fill() correctly handle multiple result sets? It's because TableAdapter.Fill() calls DataAdapter.Fill() overload that takes DataTable, not Dataset. This can be easily addressed by creating a new Fill method in TableAdapter that calls DataAdapter.Fill() overload that takes Dataset.

Assume we have NorthwindDataset.xsd that contains both Customers and Orders. And let's use the above stored procedure for our new Fill method. Add following code to your partial class file. You can create a partial class file by either double-clicking on the Dataset Designer surface, right-click on the Dataset Designer surface and choose "View Code" or add an empty class file manually.

Namespace NorthwindDataSetTableAdapters
    Partial Public Class CustomersTableAdapter
        Public Function FillCustomersOrders(ByVal dataSet As NorthwindDataSet) As Integer
            Dim multiSelectCommand As New System.Data.SqlClient.SqlCommand
            Dim returnValue As Integer

            multiSelectCommand.Connection = Me.Connection
            multiSelectCommand.CommandText = "dbo.spSelectCustomersOrders"
            Me.Adapter.SelectCommand = multiSelectCommand
            '' Map auto-created Table1 that holds the second result-set (Orders rows) to
            '' Orders DataTable in our Dataset.
            Me.Adapter.TableMappings.Add("Table1", "Orders")
            returnValue = Me.Adapter.Fill(dataSet)

            Return returnValue
        End Function
    End Class
End Namespace

Couple of key points to note.

First, this new FillCustomersOrders takes Dataset as a parameter. This way, when we call DataAdapter.Fill() we can retrieve both result sets and fill Dataset appropriately.

Second, notice how we use TableMapping to map automatically created DataTable to Orders DataTable in our Dataset. When result sets are retrieved by DataAdapter.Fill() method, each result set is stored in separate DataTables in Dataset. By default, these DataTables are named as Table, Table1, Table2, etc. In order to map these DataTables to typed DataTables defined in our Dataset, we need to use TableMapping. If you open up code behind file for NorthwindDataset.xsd, for example, and browse to InitAdapter() method of one of TableAdapter class, you will see something similar to below.

tableMapping.SourceTable = "Table"
tableMapping.DataSetTable = "Customers"
'' Colum mapping code skipped
...
Me._adapter.TableMappings.Add(tableMapping)

This block of code ensures that what gets returned by DataAdapter.Fill method maps to the correct typed DataTable in our Dataset. In our case with FillCustomersOrders, we know that the second result set contains Orders rows. So we need to create a mapping between Table1 and Orders to make sure Orders DataTable gets filled correctly.

After you add above code to the partial class file, you can call FillCustomersOrders to fill both Customers and Orders with just one round-trip to database.

CustomersTableAdapter.FillCustomersOrders(Me.NorthwindDataSet)

Performance Consideration

I can see how this kind of capability could be helpful in some cases. But you have to remember that this comes with its own issues. Although you might think that avoiding multiple trips to database would help in terms of performance, you could end up hurting performance by retrieving large set of data when you only need a sub-set. A lot of times, it is much better to retrieve smaller set of data, only what you need at the moment, and make another call to database when you need other sets of data. ADO.NET does a pretty good job of optimizing connection pooling so making multiple connections to database doesn't cause performance bottleneck in many cases. Rule of thumb. Only retrieve what you need.

But I can see how retrieving multiple result sets can be helpful in some cases. So, make use of the technique I described here and just make sure you consider performance issues always.

Additional Resources

DataAdapter.Fill(DataSet): http://msdn2.microsoft.com/en-gb/library/377a8x4t.aspx
DataTableMapping Class: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemdatacommondatatablemappingclasstopic.asp
How to: Extend the Functionality of a Dataset: http://msdn2.microsoft.com/en-us/library/ms171896(VS.80).aspx

New Data Tools Features in Visual Studio Orcas

VBTeam — Tue, 13 Mar 2007 21:09:00 GMT

Here's a list of new data tools features in Visual Studio. I will be discussing each one in more detail in upcoming posts.

Object Relational Designer

The object relational mapping technology lets you map relational databases to objects. Once the mapping is done, you can manipulate mapped objects as normal objects and easily submit changes back to relational database without writing complex data access logic. It is the latest enhancement in data access technology and there are many different implementations out there currently. However, no O/R implementation comes with a graphical designer that makes it easy to create and modify mapping.

The Object Relational Designer in Visual Studio is Microsoft's answer to how O/R mapping should be done. It's a graphical designer which lets you easily map database objects such as tables and stored procedures to LINQ To SQL classes and methods. You can just drag out database objects from the Database Explorer onto the designer. Designer then takes care of creating mapping and generating proper LINQ To SQL code. You can also modify different aspects of mapping through the designer and let the designer take care of updating the code automatically. Association and inheritance relationships can also be easily created easily. The stored procedure support is also a very unique feature. Instead of letting LINQ To SQL generate INSERT, UPDATE and DELETE SQL statements, you can map methods created based on the stored procedures to each behavior.

If you've tried May CTP of LINQ, you probably remember a version of the O/R Designer we included. It was called DLinq Designer. What you see in March CTP of Visual Studio Orcas is the next generation of DLinq Designer and it's now called the O/R Designer.

Hierarchical Update in Typed Dataset

Keeping track of all inserts, updates and deletes across multiple related datatables and sending those changes in the right order back to the server is not an easy task. How do you make sure that new orders for your customer are added correctly to the system while updating the shipping address of the same customer and deleting one of old orders that had been cancelled all at the same time?

With hierarchical update support in Typed Dataset, all you need to do is to call UpdateAll() method of the new TableAdapterManager component we've added. It takes care of collecting all changes and sending them back to the server in the right order. Of course, everything is wrapped into a transaction.

We believe this would significantly improve the productivity of developers using Typed Dataset to create data applications. You can try this new feature in March CTP of Visual Studio Orcas.

N –Tier Support in Typed Dataset

I admit. Typed Dataset code we generate in Visual Studio 2005 is not N-Tier ready. If you open up the code file, you will notice that we've done a great job separating types from data access logic. Dataset and typed datatables are declared in one Typed Dataset class and all TableAdapter classes are declared under a separate namespace. But we generate both sets in one code file. For a lot of applications this is not an issue. But when you are building multi-tiered applications, having them in one file doesn't really help. This exact problem is discussed in detail on Splitting Typed Datasets from TableAdapters blog entry from Steve Lasker. The solution proposed in this blog entry was to open up the generated code and manually copy and paste type declaration out into a new class file. Although this did allow you to use Typed Dataset in N-Tier scenario, it had one major problem. Since you are manually modifying generated code, anytime you make a change to Typed Dataset via Dataset Designer, you have to remember to copy and paste code. That was painful.

In Orcas, you can instruct the designer to generate Dataset portion of the code into another project in your solution. No more manual copy/paste. You can even make changes to Typed Dataset from the designer and it will make sure that updated code is generated into the specified project. You can still choose to stay in 2-Tier model. Designer will continue to generate everything in a single file. When you are ready to take your 2-Tier application to N-Tier, just tell the designer which project is the Dataset project and you are done. It's that simple. A preview of this feature is in March CTP of Visual Studio Orcas and you will be able to try the polished version in Beta 1.

Local Data Cache with SQL Compact Edition

SQL Compact Edition enables many exciting scenarios for developers. The most interesting scenario is to use SQL Compact Edition database file as a local cache of data that do not change often. For instance, your application might keep a list of products in local cache while exchanging order information with remote server. Once in a while, you can synch products list from the remote server but you will mostly use local cache.

Since SQL CE is light-weight database that has very little overhead, it's the perfect candidate for the local cache store. You can use the Sync Service for ADO.NET to synchronize data between remote database server and local SQL CE database file. Sounds great, right? But how do you set everything up so that you can do this?

Visual Studio Orcas includes new project item template "Local Data Cache". Adding "Local Data Cache" to your project creates .sync file which is an XML file that describes what gets synched and how. This file comes with the designer that lets you configure different aspects of synchronization easily. Designer also creates SQL CE .sdf database file to be used as local cache store as well as synchronization code necessary to interact with the Sync Service. A preview of this feature is in March CTP of Visual Studio Orcas and you will be able to try the polished version in Beta 1.

Other Enhancements to Data Tools

Above four are major data tools features in Visual Studio Orcas. But there are tons of other enhancements we've made to existing data tools. I will be dedicating a separate post to describe other important enhancements we've made.

Visual Studio 2005 SP1 and Visual Basic 2005 Command-line Compiler (VBC.exe) Hotfix Released!

VBTeam — Wed, 03 Jan 2007 21:46:00 GMT

Visual Studio 2005 SP1 is now available for download. We’d like to thank everyone in the Visual Basic community for providing feedback on SP1 and helping us identify and address issues for this service pack. In some areas, more than 50% of the bugs addressed were reported by customers through the MSDN Product Feedback Center. Overall, SP1 offers customers improvements in responsiveness, stability and performance for Visual Basic 2005.

This service pack rolls up all of the Visual Basic 2005 hotfixes we’ve made to date and provides you the best overall performance and stability when developing in Visual Basic 2005.

We recommend VB developers install SP1. You can get SP1 at:

http://msdn.microsoft.com/vstudio/VS2005SP1

Service Pack 1 Update to Visual Basic 2005 Command-line Compiler (Vbc.exe)

This hotfix provides the SP1 improvements for the Visual Basic 2005 command line compiler, (vbc.exe).

After installing SP1, install this hotfix to development and deployed machines to get the SP1 fixes for vbc.exe if any of the following apply:

You are developing web sites with ASP.NET 2.0 in Visual Basic 2005
You are deploying ASP.NET 2.0 web sites written in Visual Basic 2005
You are building Visual Basic 2005 projects outside the IDE using VBC.exe

http://go.microsoft.com/fwlink/?LinkID=78807

Thanks for your contribution to Visual Studio 2005 SP1. We welcome your feedback on this release.

Chris Mayo

Visual Basic Program Manager

Check out "Live from Redmond series #3" from the .NET FX product teams

VBTeam — Wed, 11 Oct 2006 02:27:00 GMT

The .NET Framework teams are providing several Live Meeting presentations spanning application technologies like Smart Clients, Web 2.0 (AJAX) and Mobile. Check out SimonMu's blog for more information:
http://blogs.msdn.com/simonmu/archive/2006/10/09/The-next-series-of-team-member-Live-From-Redmond-webcasts.aspx

Simon also pointed me to a great video archive:
http://www.asp.net/learn/videos/default.aspx?tabid=63#ajax

If you're a VB developer and you're interested in these modern .NET app types, I think you'll want to check this out. Enjoy!

Best,

Paul Yuknewicz
Visual Basic Team

EMEA Tour Followup

VBTeam — Fri, 21 Apr 2006 01:55:00 GMT

PaulYuk and I just returned from the EMEA tour where we demoed tons of new VB 2005 features to groups in Brussells, Amsterdam, Stockholm, Belfast, and Dublin. Here (as promised) are links to more information on what I presented. If you didn't make it to the presentations, check out the below. Lots of interesting material!

Was good to visit everyone on the trip. Paul and I had a great time visiting everyone.

Start Clients Using Office:

Main page -> http://msdn.microsoft.com/office/understanding/vsto/default.aspx

Good overview -> http://msdn.microsoft.com/office/understanding/vsto/default.aspx?pull=/library/en-us/odc_vsto2005_ta/html/officewhatsnewinvsto2005.asp

My.Blogs Location -> http://msdn.microsoft.com/library/default.asp?url=/library/en-us/odc_vsto2005_ta/html/odc_vstoOutlookMyBlog.asp

http://msdn.microsoft.com/VBasic/Downloads/Code/MyBlogs/

Smart Clients Using Mobile Devices:

Main page -> http://msdn.microsoft.com/vbasic/learning/mobile/

Tips/Tricks

Community

VB Forums -> http://forums.microsoft.com/MSDN/default.aspx?ForumGroupID=10&SiteID=1

Submit bugs/suggestions -> http://lab.msdn.microsoft.com/productfeedback/default.aspx

Main VB web site -> http://msdn.microsoft.com/vbasic/

VB6 Migration site -> http://msdn.microsoft.com/vbrun/

IDE

Refactor for VB -> http://msdn.microsoft.com/vbasic/downloads/tools/refactor/

Snippit editor -> http://msdn.microsoft.com/vbasic/downloads/tools/snippeteditor/

IDE Customization -> Go under Tools/Import-Export Settings

XML Comments à Shows you how to customize this! http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=321766&SiteID=1

Find all References à http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsintro7/html/vxtsksearchingobjectss.asp

AutoCorrect -> Should be obvious from using it

Incremental Search -> http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wcepbguide5/html/wce50tskFindingaStringUsingIncrementalSearch.asp

Debugger

Immediate Window -> http://blogs.msdn.com/vbteam/archive/2005/12/05/500252.aspx

Edit & Continue -> Modify your code while in break model

Debugging Attributes -> Really good article on things you can do: http://msdn.microsoft.com/msdnmag/issues/04/05/VisualStudio2005Debugging/

Debugging Visualizers -> Example of creating them in VB http://blogs.msdn.com/deeptanshuv/archive/2005/03/21/400194.aspx

Command Window -> http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsintro7/html/vxurfcommandmodecommandwindow.asp

TracePoints -> Right-click on line of code and choose insert tracepoint

Language Improvements

My Extensibility -> http://msdn.microsoft.com/msdnmag/issues/05/07/My/

Generics -> http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnvs05/html/vb2005_generics.asp

Using Statement -> http://msdn2.microsoft.com/en-us/library/htd05whh.aspx

Continue / Isnot -> Simple, but new for VB 2005

Warnings -> You can customize these from Compile project designer page

Winforms Improvements

These features are not new to this version, but are new to VB6 users. They are easily found in help

Anchoring/Docking

Tab order/Menu Editor

Inherited Forms

Forms Localization

New features:

Background Worker object

Bind to settings

Document outline window

New Containers

Table/Flow layout

Splitter

This article has links to all these features and much more http://msdn2.microsoft.com/en-us/library/35f2fe4h.aspx

Application Model

Good general link: http://msdn2.microsoft.com/en-us/library/tzdks800.aspx

VB6 Interop

Great series of articles on using .net components from VB6 http://msdn.microsoft.com/vbrun/vbfusion/

Feel free to contact me (toddap@microsoft.com) if you have any questions about code samples or information that was given in the talks. Thanks again for attending!

Todd Apley

New VB9 Bloggers

VBTeam — Fri, 17 Mar 2006 04:02:00 GMT

By Amanda Silver

I just wanted to let you know that we’re working furiously on turning the VB9 features into an actual product, understanding how the debugger and editor should support them, and getting another CTP out to you all. Your feedback so far as been invaluable. Hopefully you’ll see that we’ve responded to your feedback in the next CTP (due out this spring.) One of the things you’ll see is changes to the syntax for XML LateBinding as Avner talks about. Brian Beckman has posted some cool entries on writing a VM using VB9 and hash joins with VB9. And Erik Meijer comes out with a gem every once in a while as a guest blogger on lambda the ultimate.

Overall, there’s been some pretty great blogging going on with regards to the new Language Integrated Query and XML features in VB9. I just wanted to point out some bloggers you should keep your eye on:

Please keep the feedback coming on the VB9 features…

What do you think of the XML namespace support?
What do you think about dynamic interfaces?
What do you think of DLinq?

NEW VB LINQ CTP: Now live on MSDN!

VBTeam — Mon, 23 Jan 2006 21:14:00 GMT

By Amanda Silver

I’m very excited to announce that the next tech preview of Visual Basic 9.0 which includes support for Language INtegrated Query (codename LINQ) and XML integration atop the XLinq API is now available on the VB Future and the LINQ project websites. This is the result of a ton of hard work for a significant portion of the team and we’re very happy to get it out to you.

This is an additive release to that which came out in the PDC timeframe. It expands the XML integration in both the language and IDE, provides some editor features for the LINQ syntax, and enables DLinq for VB.

What’s new?

LINQ Intellisense: Query statements now have statement completion, Intellisense, and Pretty Printing to improve overall discovery and readability of VB queries.

DLinq support: Previous tech previews of the LINQ CTP did not fully support leveraging the DLinq technology which is for querying against relational data stores, such as SQL Server. DLinq support in this release is limited in that only the working query syntax over objects will extend to DLinq.

Editing support for Xml Literals: The Visual Basic background compiler provides immediate feedback, with this release this support has extended to integrated XML. Specifically, XML literals are now automatically indented and XML literals plug into auto-correction. The XML literals are now completely colorized with customizability through the VS 2005 options, fonts & colors.

Xml Late binding:

1. Import Xml namespaces: Xml namespaces can be imported to the VB program using similar mechanism to importing CLR namespace. Xml namespace must have an alias. The following is an example for import of Xml namespace:
Imports ns = "http://www.w3.org/1999"

2. Accessing elements with namespaces: Once an Xml namespace was imported, you can use qualified identifiers to access elements with namespaces. The qualified identifiers are in the form of 'Xml Namespace Alias' + '::' + 'Element/Attribute name'. For example:
book.ns::title

3. Indexer for IEnumerable(Of T): An indexer was added to IEnumerable of any type. This enables easy access to any element from a generic IEnumerable, specifically for accessing the first XElement from the XElements collection that is returned from Xml late binding expressions. For example the following code prints the title of a book:

Imports ns = "http://www.w3.org/1999"

Module Module1

Sub Main()

Dim book = _

<Title>Learning Programming Using Visual Basic</Title>

</Book>

Console.WriteLine( CStr( book.ns::Title(0) ) )

End Sub

End Module

What’s changed?

VB expression holes in Xml literals: The previous tech preview supported parentheses for expression holes inside the element tag. In this release we unified the syntax for expression hole and its now <%= %> for element content and the element tag.

The reason we’re giving you these previews so early in the product cycle is that we need your feedback! The features in the CTPs are preliminary designs and are subject to change based on your thoughts; please blog, talk, write articles, gloat, gripe, rant and rave about these bits!

Visual Basic 2005 is now available!

VBTeam — Tue, 08 Nov 2005 03:00:00 GMT

Today is the official launch day of the new version of Visual Basic:

This page links to the relevant information (how to get it, what's new, etc…)

http://msdn.microsoft.com/vbasic/

You can also download the FREE Visual Basic 2005 Express Edition from here:

http://msdn.microsoft.com/vstudio/express/vb/

Happy coding,

Luca Dellamore

Visual Basic Test Team