Wooley's LINQ Wonderings : LINQ, VB

Annoucing ThinqLinq.com

jwooley — Thu, 10 Jan 2008 05:46:00 GMT

You may have seen me present it at a speaking engagement. You may have watched the podcasts. You may have even downloaded the sample application. Now you can see it in action.

ThinqLinq.com is now live.

The site was designed completely in VB with LINQ as the data access mechanism. The base application was built in 2 hours from not knowing RSS to being able to import a RSS feed, displaying it on a form and producing a new feed from the imported data. The site is a testimate to the power of LINQ and the RAD capabilities that it brings. Head on over to the site and check it out.

Crossposted from http://devauthority.com/blogs/jwooley/default.aspx

VS 2008 Beta 2 VPC images will timebomb on 11/1/2007

jwooley — Fri, 26 Oct 2007 20:13:00 GMT

If you downloaded the VPC image version of Visual Studio 2008 beta 2, make sure to back-up your data and move anything off of the Team Foundation Server before November 1, 2007. I was just informed that the images will be time bombing on November 1 2007 rather than the originally intended March 15, 2008 date. If you don't download it now, you may not be able to retrieve your projects. More information is available at the VS 2008 beta 2 download site. If you installed the stand-alone version, you should be ok.

Crossposted from http://devauthority.com/blogs/jwooley/default.aspx

Adding RSS posts to ThinqLinq using System.ServiceModel.Syndication.SyndicationFeed

jwooley — Fri, 12 Oct 2007 02:58:00 GMT

When I originally started the ThinqLinq project I began by loading the RSS feed from my DevAuthority blog, and iterating over the results adding them to the PostItems table in the data context. With LINQ this is relatively easy. Loading the XML from the feed is done with a single line:

Dim Feed As System.Xml.Linq.XDocument = XDocument.Load("http://devauthority.com/blogs/jwooley/rss.aspx")

The xml document consists some basic informational elements which are not terribly important in this instance as we are only pulling from a single blog. Following the initial elements, the document contains a series of "item" elements that contain the actual post information. We can easily query the document and return an IEnumerable(Of XElement) object that we can iterate over and create new post items. Below is an excerpt from my original implementation.

For Each post As XElement In Feed...<item>
    Dim DataPost As New LinqBlog.BO.PostItem
    DataPost.Author = "Jim Wooley"
    DataPost.Description = post.Element("description").Value
    DataPost.PublicationDate = CDate(post.Element("pubDate").Value)
    DataPost.Title = post.Element("title").Value
    dc.PostItems.Add(DataPost)
Next

Once the records are added to the table, we can commit them to the database with a single call to SubmitChanges as follows:

dc.SubmitChanges()

Ok, so that is easy enough. There are a couple of things to mention before we continue on. The .Add method will be changed to .InsertOnSubmit when LINQ and the .NET 3.5 Framework is released. This will be a breaking change for anyone who is currently working with the beta builds.

Another item of note: this implementation does not bother importing the various sub-collections, including attachments, comments, categories, etc. We will address some of those in a future update.

In looking back at the code and being more familiar with LINQ, it is about time to update this code taking advantage of some of LINQ's more interesting features. First VB 9 allows us to eliminate some of the functional construction syntax. Instead of weakly accessing the post.Element("description").Value, we can refer to post.<description>.Value. If we import the namespace, we will even get intellisense on the xml document.

In addition, rather than iterating over the item elements explicitly, we can use a LINQ query to create an IEnumerable(Of PostItem) list using the object initializers in the select projection. We then fill the entire collection using the table's AddAll (changing to InsertAllOnSubmit with RTM). With this change, we eliminate the entire for each loop. Below is the revised code:

Dim Feed As System.Xml.Linq.XDocument = XDocument.Load("http://devauthority.com/blogs/jwooley/rss.aspx")

Dim dc As New LinqBlogDataContext()

dc.PostItems.AddAll(From post In Feed...<item> _
    Select New PostItem With { _
    .Author = "Jim Wooley", _
    .Description = post.<description>.Value, _
    .PublicationDate = CDate(post.<pubDate>.Value), _
    .Title = post.<title>.Value})

dc.SubmitChanges()

That's it. We've read the feed from the site, filled the object collection and saved the resulting objects to the database. Clean and simple.

But hold on... The title of this post refers to the System.ServiceModel.Syndication.SundicationFeed object. This is a new object as part of the WCF enhancements in the .NET 3.5 Framework. To use it, add a reference to the System.ServiceModel.Web library. This object lets you create and consume feeds in both RSS and ATOM formats and use a single object model against both options. It also gives easy access to a number of child object structures, including Authors, Categories, Contributors, and Links. Additionally it strongly types the results so that we don't need to explicitly cast the values ourselves (for example with the PublicationDate). Here is the complete code to load the feed using the SyndicationFeed.Load method, fill the PostItem collection and submit them to the database.

Dim feed As SyndicationFeed = SyndicationFeed.Load(New System.Uri("http://devauthority.com/blogs/jwooley/rss.aspx"))

Dim dc As New LinqBlogDataContext()

dc.PostItems.AddAll(From p In feed.Items _
    Select New PostItem With _
    {.Author = If(p.Authors.Count > 0, p.Authors(0).Name, "Jim Wooley"), _
    .Description = p.Summary.Text, _
    .PublicationDate = p.PublishDate, _
    .Title = p.Title.Text})

dc.SubmitChanges()

The code is substantially the same as the revised version using the XML Literals above. The advantage of using the Syndication services implementation is that it abstracts the feed structure (RSS/ATOM), giving direct and strongly typed access to the contents.

Now that we've set this up, maybe I can work on using the SyndicationFeed to generate the feeds in ThinqLinq and present that in a future post. Stay tuned.

Technorati tags: linq, orcas, vb, xml

Crossposted from http://devauthority.com/blogs/jwooley/default.aspx

Code Camp 2007 downloads

jwooley — Mon, 08 Oct 2007 23:22:00 GMT

I've uploaded the files for my presentations for the fall Code camp season which I just presented last weekend at the Birmingham, Alabama code camp. If you missed the talks, you can pick up the downloads at the following links. Also, I will be at the Charleston, South Carolina code camp this coming weekend (10/13) so you can catch me there. Additionally, the ThinqLinq talk is still available on the aspnetpodcasts.com. Links to all three parts of thie webcasts are available at http://www.devauthority.com/blogs/jwooley/archive/2007/07/27/66845.aspx.

Below are the links to each of the downloads for my three talks.

These and all of my demos are available via my downloads page at http://www.devauthority.com/files/13/jwooley/default.aspx?ppage=1. Don't let the license notice keep you from downloading the samples. It is just a boilerplate message that I'm not able to change at this point.

Technorati tags: linq, orcas,vb

Crossposted from http://devauthority.com/blogs/jwooley/default.aspx
Updated: 11/9/2007 to fix the invalid hyperlinks due to cross posting.

LINQ to SQL Compiled Queries

jwooley — Wed, 05 Sep 2007 03:20:00 GMT

As LINQ nears release, people are starting to consider the performance implications that the extra overhead brings. Currently there are two threads on this: thread1, thread2. For those that are intested in the performance implications, I highly recommend checking out the outstanding series of posts by Rico Mariani.

Ultimately if you want to get the best performance, you need to use the Compile function of the CompiledQuery class. Let's consider the following query (Note, turn this into C# by adding a semi-colon at the end if necessary):

From p In context.Products() _
Where (p.Price >= minimumPrice) _
Select p)

In this query, we are searching for the products that are "Expensive" in that their price exceeds a price value that we set. If we regularly consume this, we can eliminate the overhead of building the query pipeline. See the Matt Warren talk about this pipeline on the deep dive video at on Charlie Calvert's blog for more information regarding the overhead that is necessary to evaluate a query.

To compile the query, we can leverage the CompiledQuery.Compile method. This method takes an argument list as input and a result type. It returns a delegate as a variable that we will be able to consume. Thus in this case, we can pass the DataContext instance and the minimumPrice variable in. We will return a IQueryable(of Product) object. thus we can start the definition of our compiled query as follows:

VB:
     CompiledQuery.Compile( _
         Function(context As MyDataContext, minimumPrice As Decimal) _
            From p In context.Products() _
            Where (p.Price >= minimumPrice) _
                    Select p)

C#:
     CompiledQuery.Compile(
            (MyDataContext context, decimal minimumPrice) =>
                    from p in context.Products
                    where p.Price >= minimumPrice
                    select p);

In this case we are defining our query as a Lambda function which the Compile can convert to the corresponding expression tree representation. If you are unfamiliar with Lambdas in VB, check out Timothy Ng's recent MSDN Magazine article.

With the delegate functions declared, all that is left is to actually assign them to a variable that we can consume later. To do this, we define a static/shared function which returns the Func anonymous delegate type. By defining it as a static/shared function, the compilation will only occur once per AppDomain and will remain cached through the rest of the application's lifetime. Notice, we are defining the signature of the query, not the results. We are free to change the parameter without needing to re-compile the query's structure. Here's the completed function calls in VB and C#:

Public Shared ExpensiveProducts As Func(Of MyDataContext, Decimal, IQueryable(Of Product)) = _
       CompiledQuery.Compile(Function(context As MyDataContext, minimumPrice As Decimal) _
            From p In context.Products() _
            Where (p.Price >= minimumPrice) _
            Select p)

   public static Func<MyDataContext, decimal, IQueryable<Product>>
         ExpensiveProducts =
            CompiledQuery.Compile((MyDataContext context, decimal minimumPrice) =>
                    from p in context.Products
                    where p.Price >= minimumPrice
                    select p);

The syntax for using the compiled query takes a bit of thinking to get your head around. We are essentially creating a function which returns a function rather than returning a value. If you're familiar with functional programming such as OCaml and F#, this concept should be easy to grok. For the rest of us, piece out the individual method components as laid out above and you should be able to understand it after a while ;-)

To consume our new function, we simply instantiate a DataContext instance and pass it along with the minimumPrice we want to set as our minimum value.

Dim context As New MyContext(My.Settings.MyConnectionString)
Dim Items = ExpensiveProducts(context, minimumPrice)

Technorati tags: linq, orcas,vb, C#

Crossposted from http://devauthority.com/blogs/jwooley/default.aspx