Thinq Linq

Filling an object from a DataReader with LINQ using DataContext.Translate

jwooley — Fri, 25 Jul 2008 09:49:00 GMT

One of the key things that LINQ to SQL does for us is offers a quick way to fill a set of objects with data from a database. Typically this is done by setting up some mapping and calling the GetTable method on the DataContext. There are cases, particularly when you already have an infrastructure set-up to populate objects using a DbDataReader, where it would be nice if you could just populate the columns without the need to set-up a mapping.

The DataContext has a little known method called Translate which can take a DBDataReader as a parameter and fill an IEnumerable list of objects without the need for mapping structures. To use it, specify the type you want to populate and pass the instance of the reader and let it do it's magic. Here's a sample:

Using cn As New SqlClient.SqlConnection(My.Settings.NorthwindConnectionString)
cn.Open()
Using cmd As New SqlClient.SqlCommand("SELECT * FROM Region", cn)
    Dim reader = cmd.ExecuteReader()
    Using nwind As New NorthwindDataContext

      Dim RegionList = nwind.Translate(Of Region)(reader)

      For Each item In RegionList
        Console.WriteLine(" {0}: {1}", item.RegionId, item.RegionDescription)
      Next
    End Using
End Using
End Using

In this case, we tell the context to translate the resultset of the reader into a generic IEnumerable(Of Region). There are number of caveats to keep in mind here:

The column name in the result set must correspond to the property name.The translation is quite forgiving however. It is not case sensitive.
If you have a row in the result set but no corresponding property, that row will be ignored (no exception will be thrown).
If you have a property in your object with no corresponding row in the result set, that property's value will not be set.
The translation must be done to a known type. You can not project into an anonymous type. You can return an object or simple IEnumerable if the type is not known and then use reflection to work with the results.
Since the translate method returns an IEnumerable, make sure not to close the connection or the reader before iterating over the results.

The Translate method supports 3 overloads as follows:

    Public FunctionTranslate(Of TResult)(ByVal reader As DbDataReader) As IEnumerable(Of TResult)
    Public Function Translate(ByVal reader As DbDataReader) As IMultipleResults
    Public Function Translate(ByVal elementType As Type, ByVal reader As DbDataReader) As IEnumerable

Translate does not require any mappings to be set. It simply sets the public property values based on the column names. If you have business logic in your Property Set implementations, that logic will run. As far as I can see, there is no way to instruct Translate to use the private storage field instead of the public property.

Chris Williams' Nine questions

jwooley — Fri, 25 Jul 2008 08:33:00 GMT

I had the honor of participating in Chris Williams "Nine Questions" project. If you are interested in getting to knowing a bit more about me other than just how I thinq, check it out on his blog.

ThinqLinq in multiple languages

jwooley — Fri, 18 Jul 2008 14:15:00 GMT

Former Atlanta luminary, Kirk Allen Evans reminded me about the Windows Live translator service that I tried unsucessfully to add to this site a couple months ago. I was able to get it to work this time based on the code he posted. All you need to do is add the following to your site and the magic translator will be added with no extra work for you:

<div id="translator">
<div id="trans">
    <br />
    <script type="text/javascript" src="http://translator.live.com/TranslatePageLink.aspx?pl=en"></script>
    <br />
</div>
</div>

I did take the liberty of correcting the code to make it XHtml complant by adding the end slash on the br tags. You can try it out by selecting the drop down list on the right hand site of this site that says "Translator", selecting the language you want and clicking the -> button.

As always, let me know what you Thinq.

Geek Speak podcasts are back

jwooley — Fri, 18 Jul 2008 14:07:00 GMT

Glenn just announced that the Geek Speak podcasts are available again. They were disabled right before my session on LINQ Migration Strategies came out. If you have a Zune or IPod and want to subscribe to the feed, it is available again.

LINQ to SQL on MSDN

jwooley — Fri, 18 Jul 2008 13:35:00 GMT

While I was away on vacation, Wriju posted a good list of MSDN documents he calls the "LINQ to SQL Missing Manual". It is a good list and addresses a number of items people regularly ask about concerning LINQ. Perhaps the most important ones are:

Customizing Insert, Update, and Delete Operations (LINQ to SQL)
Describes how to add validation code and other customizations.
Data Retrieval and CUD Operations in N-Tier Applications (LINQ to SQL)
Provides detailed information for multi-tier applications that use LINQ to SQL.
Object Identity (LINQ to SQL)
Describes object identity in the LINQ to SQL object model, and explains how this feature differs from object identity in a database.

There are a bunch of other topics over there. If you are using LINQ to SQL, you should definately check it out.

Fetching child records using Stored Procedures with LINQ to SQL

jwooley — Mon, 23 Jun 2008 08:14:00 GMT

You can consume stored procs rather than the standard dynamic sql for accessing child objects. To do this, set up your fetch stored procs and make sure that they return the correct data type (not the standard custom generated type for stored procedures). To load a child collection, create a method on the partial implementation of your context. Name the function "LoadCs" where "C" is the name of the child property accessor from the parent object in the designer. This function will take a type as the parent type as a parameter and return an IEnumerable of the Child type. The names you use must agree with the names of the types and properties in your entities in order for this to work.

Public Class CustomDataContext

‘Load a child collection

Public Function LoadCs(ByVal parent As T) As IEnumerable(Of C)

Return Me.LoadCs(parent.ID)

End Function

End Class

The process to load a single child is similar. In this case, the function needs to be the singularized version of your entity and the return type will be the actual entity type rather than an IEnumerable as follows:

‘Load a single child

Public Function LoadC(ByVal parent As P) As C

Return Me.LoadC(parent.CId).SingleOrDefault

End Function

Using these methods causes the context to lazy load the child objects. The default change tracking implementation will continue to work and if you have replaced the runtime behavior for the CUD operations with stored procedure implementations, they will be used just as if you fetched the objects through LINQ generated dynamic SQL.

Manning .Net Daily Drawing promotion

jwooley — Wed, 18 Jun 2008 21:10:00 GMT

If you haven't purchased LINQ in Action yet, or like it so much that you want to check out other Manning books, make sure to check out their new promotion starting Thursday, June 19, 2008. Here's the details if you are interested.

The “.NET Daily Drawing” starts June 19
This promotion will run for one month, from June 19 - July 17. Each day’s lucky winner can choose one free .NET ebook of their choice. And finally, on the last day of the drawing, we're awarding one lucky winner... the entire Manning .NET library! (That’s nearly a $3000 value...)

To participate, Click the button below and fill in the form.

LINQ is not about working with databases

jwooley — Fri, 13 Jun 2008 09:18:00 GMT

I don't know how many people I've talked to about LINQ concerned that it requires direct table access. Ok people, repeat after me:

LINQ is NOT about working with databases.

LINQ is an abstraction layer for working with data which allows for set based operations, projections, filters, etc on anything that can be enumerated over. It just happens to have providers for working with relational data (LINQ to SQL, LINQ to Datasets, LINQ to Entities).

Oh, BTW. Each of these providers support using Stored Procedures in addition to direct table acces in case you are interested.

Screen scraping and creating Word documents with LINQ to XML

jwooley — Thu, 12 Jun 2008 13:13:00 GMT

At TechEd Developers 2008 in Orlando, I had the pleasure of competing in Speaker Idol. In that competition, we had the opportunity to present a topic in 5 minutes. Unfortunately, the topic I choose really needed 10 minutes to cover at the level of detail it needed. Instead of limiting the topic, I decided to go ahead and present it a bit too fast.

If you want to see the video, or see how to use VB 9's XML Literals and LINQ to XML to fetch data from a web page (that must be XHtml compilant), manipulate it and insert it into a Word 2007 file, it is now available on the Developer Landing page, and the Library page. of the TechEd site. If you prefer, you can jump right to the video in either WMV or MP4 file formats. If you're not familiar with LINQ to XML, go ahead and download the video and just watch it at half speed ;-)

LINQ to SQL support for POCO

jwooley — Wed, 11 Jun 2008 21:24:00 GMT

One of the strengths that LINQ to SQL has over the upcoming Entity Framework is its support for POCO, or Plain Old Class Objects. With LINQ to SQL, the framework doesn't require any particular base classes, interfaces or even reliance on the 3.5 framework for the resulting objects. I demonstrated this in the talk I did at the Teched Tweener weekend. Download the demo project to see this in action.

In this sample, I created two separate projects. The first class library project, I created only targeting the 2.0 framework. As a result the project can not use any LINQ specific techniques. This will also allow us to consume the resulting objects in projects that do not have access to the newer framework, or to all of the namespaces. This is particularly important in cases like Silverlight. To call attention to the differences in the projects, I declared the 2.0 project in C# and the LINQ enabled project in VB.

The 2.0 class library project consists of a single class file. This represents the Subject entity from the Linq In Action database.

namespace UnmappedClasses

{

public class Subject

{

public Guid ID { get; set; }

public string Name { get; set; }

public string Description { get; set; }

}

Notice here, there are no interfaces, base classes or custom attributes. Excluding the attributes is critical here because the standard <Table> and <Column> attributes reside in the System.Data.Linq.Mapping namespace which would not be supported in the 2.0 framework.

Admittedly, it consists of three auto-implemented properties. Auto-implemented properties are used for brevity here and are consumable by the .Net 2.0 Framework because it relies on compiler features rather than runtime features.

Because we can't allow the class structure to include the attributes, we can't use the LINQ to SQL designer classes or SQL Metal to generate our classes. We do need to have a way to indicate the mapping to our data store. Here is where the XML Mapping file comes in handy.

When instantiating the DataContext, we can either rely on the inline attributes, or an external mapping file. Luckily, the XML mapping file's structure is concise and very similar to the attributes that would have been applied to the class otherwise. The main difference we need to do is indicate the Type that is used for a given table since we are not directly annotating the class itself. The other difference you may notice is that I don't include the Storage attribute. While there is nothing to stop me from using that in a Mapping source, we can't identify the backing field when using auto-implemented properties.

<?xml version="1.0" encoding="utf-8"?>

</Type>

</Table>

</Database>

Now, with that out of the way, we can get to the LINQ portion of the work. Actually, that is quite easy. In our 3.5 enabled project, we will create a XmlMappingSource, pass it into the constructor of the DataContext and then fetch the object from this context as we would any other LINQ enabled class.

Dim map = XmlMappingSource.FromXml(XDocument.Load("C:\Projects\LINQ\AdvancedLinqToSql\WinformDemo\lia.map").ToString)

Using dc As New DataContext(My.Settings.liaConnectionString, map)

Me.SubjectBindingSource.DataSource = dc.GetTable(Of UnmappedClasses.Subject)()

End Using

This example happens to bind the results to a Winform object binding source, but you could expose it to ASP directly, through an encapsulation layer, like a repository pattern, or a service interface.

ThinqLinq at TechEd Developers 2008

jwooley — Tue, 03 Jun 2008 10:36:00 GMT

If you're at Tech Ed Developer in Orlando, make sure to find me. If you miss me on the convention floor, I'll also be participating in Speaker Idol on Wednesday 6/4 at noon. In addition, I will be doing a book signing in the store at 1:00 on Thursday, 6/5. As you can see from this picture, they have a couple copies of the book that you can buy if you didn't bring your copy. I look forward to meeting you.

Danny Simmons compares the Entity Framework to similar technologies

jwooley — Tue, 27 May 2008 21:23:00 GMT

It seems that everyone else is chiming in on Danny Simmons' recent comparisons of the Entity Framework with other similar technologies. There are several items I wanted to address from his observations.

Regarding the EF vs. LINQ to SQL, he makes two basic points: 1) That there isn't a provider model for other data sources and 2) That LINQ to SQL requires a 1-1 table to object mapping. On the second item, there is no denying the limitation. While you can work around the issue with LINQ to SQL's support for views, stored procs, and functions, this is the key differentiator between LINQ to SQL and the Entity Framework. Danny's statements regarding inheritance limitations and entity splitting both stem back to the TPH (table per hierarchy) limitation of LINQ to SQL.

Regarding the issue with the provider model, the original intent was to have a full provider model which vendors would be able to consume. When the ADO vNext initiatives came out, it was fairly clear that the provider model would be supported in the Entity Framework. As a result, the provider model for LINQ to SQL was essentially shelved. That was the genesis of Matt Warren's series on building an IQueryable provider which basically outlines how one would go about building a provider for LINQ. Since Matt has basically handed the LINQ to SQL code base over to Danny's team, we'll see where this progresses.

In Danny's discussions of other technologies, he seemingly makes two contradictory statements. In the beginning he states,

"... the truth is that different problems merit different solutions."

He then goes on to the statement:

"This makes it easier to create a conceptual model which is how you want to think about your data and then reuse that conceptual model for a number of other services besides just building objects. Long-term we are working to build EDM awareness into a variety of other Microsoft products so that if you have an Entity Data Model, you should be able to automatically create REST-oriented web services over that model (ADO.Net Data Services aka Astoria), write reports against that model (Reporting Services), synchronize data between a server and an offline client store where the data is moved atomically as entities even if those entities draw from multiple database tables on the server, create workflows from entity-aware building blocks, etc. etc."

By this, he is indicating that the EF should be the defacto mechanism for building the entity structures around which the various components of your system will be built. Thus one tool to answer the various solutions. Is the EF really the best way to expose relational data from a reporting or analysis perspective, time and performance analyses will tell. He does go on in the comments to his post indicating that he is not necessarily advocating re-using the same entities for all of these various application components, but rather to use a similar tooling to create the potentially separate entities that each subsystem will consume. While it makes the programmatic portion easier, the jury is still out on the other areas.

I'm still getting up to speed on the EF, but do have concerns regarding the POCO (Plain Old Class Objects) story and some of the other requirements that the EF puts on your entity and database models.

ThinqLinq at Teched Developers

jwooley — Tue, 27 May 2008 20:24:00 GMT

If you're going to be at TechEd Developer '08, make sure to say hi if you see me. I'll be hanging out in the VB area of the Technology Learning Center for some of the conference. In addition, I'll be one of the contestants in Speaker Idol and appreciate all of my peeps coming out to show your support.

One of the other great things about this year's TechEd is the inclusion of a community lead weekend between TechEd Developer and TechEd IT. There are quite a number of different events, including a Tweener Weekend code camp put on by Dave Norderer and the South Florida guys. I'm honored to be speaking as part of this event on some more advanced features that LINQ to SQL offers to developers beyond the basic drag and drop experience of the designer.

I hope to see some of you at the event (or the various parties that come with these kinds of events.)

Anonymous Type property ordering in VB

jwooley — Fri, 16 May 2008 10:19:00 GMT

Many people have noticed when binding an anonymous type to a grid in VB that the order of the properties does not reflect the order that they were specified in the projection (Select) clause. Instead, they appear alphabetized. Consider the following query:

Dim query = From c In Customers _
Select c.LastName, c.FirstName, c.BirthDate

If you bind this query to a DataGrid or DataGridView and allow the columns to be generated automatically, the results will be displayed with the following column ordering: BirthDate, FirstName, LastName. Notice that the columns are ordered alphabetically based on the property name.

I just received word that this behavior is changing in the next update to VB. After this release, the property order should be retained from the projection clause, just as it is in C#.

VS 2008 SP1 beta

jwooley — Mon, 12 May 2008 12:15:00 GMT

For those of you who are wanting to live on the bleeding edge, Microsoft has just released a beta for the Visual Studio 2008 Service Pack 1. Soma has a listing of some of the new features that are included in this release on his blog. If you want to skip the description and jump straight to the bits, you should be able to download them here.

For LINQ fans, this release is important as it includes the nearly completed first release of the Entity Framework, ADO.Net Data Services (Astoria), and dynamic data controls. I'll likely start exploring those topics here in the near future, so go ahead and check them out if you haven't seen them before.

This release also points to an important change from previous versions of .NET and Visual Studio in that people are often waiting for a service pack to justify moving to a new technology. This service pack appears to be is coming out much faster than previous versions, so hopefully it will only help to increase adoption. Note that this release is only a beta of the service pack. The final release is still pending at this point.

Projecting into an unmapped property from a LINQ to SQL query

jwooley — Thu, 08 May 2008 18:25:00 GMT

On page 216 of LINQ in Action, I made a comment that unmapped properties in a mapped class cannot be used in a LINQ to SQL projection. This was true with the beta bits, but only partially true with the release bits. To begin, let's consider the Author table we have in the book samples.

The Author class has separate fields for the first and last name. Each of these is mapped to the corresponding fields in the Author table. In the book, we show how you can create a read only property in a partial class (so that it won't get clobbered when we regenerate our classes in the designer). The new property is trivial:

   Partial Public Class Author

        Public ReadOnly Property FormattedName() As String

Get

                Return Me.FirstName & " " & Me.LastName

            End Get

        End Property

    End Class

Notice here that there are no mapping attributes to this property. In part, that is because there is no corresponding field in the table. As we show in the book, you are free to query the author table and return Author objects. From there, you can display the FormattedName as follows:

           Dim authors = From a In context.Authors _

                          Select a

            For Each a In authors

                Console.WriteLine(a.FormattedName & "; " & a.WebSite)

            Next

This works fine because we are projecting the complete Author type. However, in early builds, we couldn't project the unmapped properties into an anonymous type like this:

            Dim authors = From a In context.Authors _

                          Select a.FormattedName, a.WebSite

If you tried to use this projection, you would get a runtime exception. In the RTM bits, the behavior was modified. Now, if you try to run the above query (sample 8.25 in the book samples for anyone following along). You will see that the query succeeds and the anonymous type is used. So how can they know how to populate the FormattedName when it is not mapped and doesn't exist in the table itself? No, the provider doesn't look inside the property, determine the mapped properties that are used, and fetch them. While that could work in our simple example, many unmapped properties would use significantly more resources, many of which may not be members of our class, or methods without direct translation in TSQL. If you look at the generated SQL that is issued when the query is consumed, you might be able to figure out what is happening in this case.

SELECT [t0].[ID], [t0].[LastName], [t0].[FirstName], [t0].[WebSite], [t0].[TimeStamp]
FROM [dbo].[Author] AS [t0]

Notice here, our select clause to the database is not optimized to only return the fields we requested. Instead, all of the fields are returned. So what's going on? They discovered in evaluating the Select clause that there were unmapped properties. At that point, they just turned around and populated a full author object. Using this object, the provider turns around and generates the anonymous type from the object rather than directly from the underlying data store directly. It's a bit of smoke and mirrors at this point.

So the question that came up asks if the next printing of the book needs to be adjusted to remove the statement that you can't project an unmapped property. While you can indeed project these properties, you can't use them elsewhere in the query. Thus if you wanted to sort the data based on the unmapped property, the exception would be thrown. Consider the following query./p>

            Dim authors = From a In context.Authors _

                          Order By a.FormattedName _

                          Select  a.FormattedName, a.WebSite

In this case when we try to run it, we get the following error:

"System.NotSupportedException: The member 'LinqInAction.LinqBooks.Common.VB.SampleClasses.Ch8.Author.FormattedName' has no supported translation to SQL."

Because of this, I plan to leave the note in the chapter warning you of using the unmapped property in your query. Unfortunately, I don't have enough space in the book to insert this complete explanation at this time. I hope this explanation helps some of you who are confused at this point.

Geek Speak discusses LINQ Migration Strategies

jwooley — Tue, 01 Apr 2008 06:35:00 GMT

Tomorrow, Wednesday 4/2/2008, I will be the guest speaker on the Geek Speak webcast. We will be discussing strategies for beginning to incorporate LINQ into your existing application infrastructure. In many cases, that does not mean replacing your entire data stack, but rather using pieces of LINQ to add functionality and in new components. Please join us. The Geek Speak webcasts are often driven by attendee questions. The more questions, the better the event.

When: Wednesday, April 02, 2008 12:00 -1:00 PM (GMT-08:00) Pacific Time (US & Canada) or 3:00 - 4:00 PM Eastern Time.

Where: Live Meeting

Registration URL:

http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032374380&Culture=en-US

Joining composite keys with LINQ

jwooley — Tue, 18 Mar 2008 00:48:00 GMT

LINQ makes working with data in its various guises easier. By intergating it into the language, we have rich integrated support for working with data. However, there are times where the syntax is slighly different from what you would typically expect with TSQL. Once case where this occurs is when trying to join two data sources that are related by more than one field (also know as a composite key). This differs from standard joins where one table has a primary key and the other table has a foreign key id. Here's a sample table structure for a standard join in Northwind between the Products and Categories:

With Linq, this join could be represented with the following query:

Dim query = _
     From p In dc.Products _
     Join c In dc.Categories _
     On p.CategoryID Equals c.CategoryID _
     Select p.ProductName, c.CategoryName

So far, there's not much new in this query. Here, "p" is the outer variable and "c" is the inner variable of the join. Likewise, p.CategoryID is the outerKeySelector and c.CategoryID is the InnerKeySelector in the Join extension method.

This works fine when we have single values that can be compared easily. However, how can we specify multiple fields for the KeySelectors on the join? In my work with reverse mortgages, we have a situation where the loan amount is based in part on the lending limits set forth by HUD. In their limits, they specify the State and County for each limit. In this case, I need to join those values against the loan property's state and county to come up with the limit amount. Let's consider the following partial table schemas.

In this case, we could join the tables in TSQL with the following query:

SELECT LendingLimits.Amount
FROM LendingLimits
INNER JOIN Property
ON LendingLimits.State=Property.State AND
LendingLimits.County=Property.County
WHERE PropertyId=@SearchValue AND
EffectiveDate = @TargetDate

Unfortunately, the Join extension method does not support the ability to provide the InnerKeySelector/OuterKeySelector as a series of expressions. However, when dealing with objects, we can compare objects to see if they equal each other. Therefore, the solution in this case is to join two anonymous types and compare them against each other. Here's the corresponding LINQ query. Notice the difference in the On clause. If you understand working with objects, this syntax should make sense.

Dim query1 = _
    From l In dc.LendingLimits _
    Join p In dc.Properties _
    On New With {l.County, l.State} Equals _
          New With {p.County, p.State} _
    Where p.PropertyId = SearchValue And _
          l.EffectiveDate = TargetDate _
    Select l.Amount

LINQ enabled Personal Web Starter Kit in C#

jwooley — Sun, 09 Mar 2008 21:36:00 GMT

I love it when projects take a life of their own. A while back, I posted my LINQ enabled Personal Web Starter Kit in VB and received several requests to provide a C# port. Thankfully, one brave soul stepped up and did the port for me. Thanks go to Stephen Murray for undertaking the challenge. As is often the case, one of the best ways to learn a technology is to use it.

If you're interested in this sample, you can check out the project at the MSDN code center. Specifically, you can access the original VB version or Stephen's C# Port. As always, let us know what you Thinq.

Querying the complete plays of Shakespeare using LINQ to XML

jwooley — Fri, 22 Feb 2008 17:46:00 GMT

I was working to come up with some creative uses of LINQ to XML for my new talk I'm giving at the Huntsville, AL Code Camp. I figured it would be good to include a sample which queries a large XML document. Remembering that the complete works of Shakespeare were available in XML form, I did a quick search and found a version at http://metalab.unc.edu/bosak/xml/eg/shaks200.zip. This file separates each play out into separate XML files. Since I wanted to find out which parts had the most lines across all plays, I wanted to put them into a single XML file. Rather than doing this manually, I went ahead and whipped up a quick LINQ query to fetch the xml documents and load them up into an array of XElements:

Dim plays = _
    From file In New System.IO.DirectoryInfo("C:\projects\ShakespeareXml").GetFiles() _
    Where file.Extension.Equals(".xml", StringComparison.CurrentCultureIgnoreCase) _
    Let doc = XElement.Load(file.FullName) _
    Select doc

Ok, now that out of the way, I really wanted to load up a single XML file with these resulting nodes. Pretty easy using XML Literals. Just wrap the query with a new root element:

Dim plays = _
  <Plays>
    <%= From file In New System.IO.DirectoryInfo("C:\projects\ShakespeareXml").GetFiles() _
    Where file.Extension.Equals(".xml", String Comparison.CurrentCultureIgnoreCase) _
    Let doc = XElement.Load(file.FullName) _
    Select doc %>
  </Plays>

Easy. Now I have a new XML document containing the complete plays of Shakespeare. Now, what can we do with it... Well, we can get a count of the plays in one line:

Console.WriteLine("Plays found: " & plays.<PLAY>.Count.ToString)

We could have done that without putting it into a new document. We do see that we have 37 plays represented, so we know the first query worked. Now, to count the number of lines (LINE) for each character (SPEAKER). The XML document groups each set of lines into a parent node called SPEECH. This SPEECH node then contains the SPEAKER element and a series of LINE elements. For example, here's the beginning of Juliet's fameous Romeo, Romeo speech:

<SPEECH>
    <SPEAKER>JULIET</SPEAKER>
    <LINE>O Romeo, Romeo! wherefore art thou Romeo?</LINE>
    <LINE>Deny thy father and refuse thy name;</LINE>
    <LINE>Or, if thou wilt not, be but sworn my love,</LINE>
    <LINE>And I'll no longer be a Capulet.</LINE>
</SPEECH>

So to achieve the goal of counting our lines by character, we find the descendent nodes of the plays element (plays...<SPEECH>) and group them by the speaker. Then we project out the name of the speaker and the number of lines they have. We don't care about the bit roles, so we'll order the results in descending form based on the number of lines (LineCount). We'll limit the results to the top 50 entries. Here's the resulting query:

Dim mostLines = _
  From speech In plays...<SPEECH> _
  Group By key = speech.<SPEAKER>.Value Into Group _
  Select Speaker = key, _
            LineCount = Group.<LINE>.Count _
  Order By LineCount Descending _
  Take 50

The amazing thing with this process, running all three queries here, including the one which loads the full XML from the various files takes less than a second. I haven't had time to do a full performance test, including memory load, but the initial results are quite impressive!

If you have other creative uses of LINQ to XML, let me know, I'd love to include them in future presentations. Also, if you're in the Huntsville, AL area on 2/23/2008, head on over to the code camp and see the entire presentation in person.