The Visual Basic Team : Young Joo

Petzold WPF Book Sample Conversion - Final Chapters (Young Joo)

VBTeam — Wed, 30 Jan 2008 02:02:00 GMT

I've just posted a final set of chapters (Chapters 25 - 31). This completes our conversion efforts and you now have access to entire sample code from Petzold's book in VB. I would like to thank Evan and Ged who have been working with me on this. You guys rock!!!

A few things to note:

I moved all the code to the new MSDN Code Gallery. This is a central place where we can share sample applications and code snippets. You can also participate and contribute your own sample code. I've created a new gallery just for Petzold VB Sampe code. You can access it at http://code.msdn.microsoft.com/petzoldsamplevb.
I also updated the main page here (http://blogs.msdn.com/vbteam/pages/Petzold-WPF-VB-Samples.aspx) to point to the code gallery page.
In case you haven't noticed, Chapter 20 was missing XAMLCruncher project. We were having a bit of problem getting it property converted to VB. Ged was able to complete the conversion and I've uploaded the updated ZIP file for Chapter 20 which includes the XAMLCruncher project. Be sure to read the README.txt file to find out how you can address the potential issue of running the application in Debug mode from VS.

Hope you enjoy this!

Thanks!

Young Joo

Petzold WPF Book Sample Conversion - New Chapters (Young Joo)

VBTeam — Mon, 07 Jan 2008 22:59:00 GMT

Happy new year! Hope you enjoyed your holiday break! And hopefully you found some time to read Petzold's book and try out VB samples we've posted so far. :)

Evan and Ged had been working very hard to convert rest of chapters throughout December and I just posted Chapters 13 - 24 to Applications = Code + Markup (Charles Petzold) Visual Basic Code Sample page. We also have several more chapters converted but since we have a couple of chapters missing between sets, I will hold off posting them until we have those missing chapters ready.

I've also added a link to the single download file that contains all chapters converted so far. This should make the download much easier for you. The linked file will be updated as I post subsequent chapters.

Enjoy!

Petzold WPF Book Sample Conversion Update (Young Joo)

VBTeam — Sat, 24 Nov 2007 15:21:00 GMT

Been a while since I posted Chapter 3 of Petzold's WPF book converted to VB. In case you missed it, Patrick started working on this project which I took over early this month. Anyway, I am very excited to tell you about progress we've been able to make so far.

First, we now have a separate article page, Applications = Code + Markup (Charles Petzold) Visual Basic Code Sample, where you can grab all the converted sample packages. We will be updating this article page as we continue with our conversion project. We did this to make it easier for you to find all sample codes without looking through old blog posts.

Remember that I told you about extra help we got, Evan Lim from Foothill Community College? Well, Evan is a trooper and he finished converting Ch. 4 - 12. They are posted in the article page now! Thanks Evan!

Another exciting news. Ged Mead, a VB MVP, has also decided to join the project recently and he already started working on converting several chapters. With Evan and Ged working together, I think we will be able to finish converting the entire book very soon.

By the way, I would like to know if this project is being helpful to you guys. Are you guys actually looking at the converted sample code while reading the book? Does it help to have both C# and VB code available?

Thanks!

Petzold Chapter 3 (Young Joo)

VBTeam — Mon, 05 Nov 2007 09:55:00 GMT

I am Young Joo, PM @ VB team. I will be helping out Patrick on converting samples in Charles Petzold's WPF book (Applications = Code + Markup) to Visual Basic. This is an exciting project and I hope you enjoy this as much as I do. Another exciting news is that we have an extra help for this project. Evan Lim who currently teaches WPF & Blend courses at Foothill Community College in Los Altos, CA, has decided to help us with this. He already has a lot of chapters converted. So we will be able to release them much more quickly.

Attached is VB sample for chapter 3.

Enjoy!

Channel 9 Interview - LINQ to SQL and the O/R Designer in VS 2008 (Beth Massi)

VBTeam — Tue, 28 Aug 2007 01:55:00 GMT

I just posted another great interview on Channel 9 with Young Joo talking about LINQ to SQL and the new O/R Designer in Visual Studio 2008. He demos a typical business client-server scenario and shows how LINQ to SQL classes make it much easier to work with relational data in SQL Server 2005. Young also talks about architectures where he sees using LINQ to SQL having the most benefits.

Learn more about the O\R Designer and LINQ to SQL by viewing our "How Do I" video LINQ series on the Visual Basic Developer Center.

Enjoy!
-Beth Massi, VS Community

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.