The Visual Basic Team : LINQ/VB9

Spot the Bug! – The Key to using Anonymous Types (Jonathan Aneja)

VBTeam — Tue, 17 Nov 2009 07:54:00 GMT

This one’s going to be long, but for those of you who’ve felt the first 3 in this series were too easy I promise this one’s tougher J.

Let’s say you want to list all the customers from a table in a ComboBox, and update the UI based on which one is selected. To do this we’ll need to bring back two fields from the database – the customer’s name and the customer’s ID. When a customer is selected we want the ComboBox’s SelectedValue property to equal the customer’s ID.

Here’s some quick code that gets us up and running (using Northwind and LINQ to SQL):

Dim db As New NorthwindDataContext

Dim query = From row In db.Customers _

Select row.CompanyName, row.CustomerID

ComboBox1.DataSource = query.ToList()

ComboBox1.DisplayMember = "CompanyName"

ComboBox1.ValueMember = "CustomerID"

But now let’s say your boss looks at the app and says “I want you to add an ‘All Customers’ option as the first item in the list.” How would you do that? You’d need to insert an anonymous type into an existing sequence of anonymous types, which is tricky given that you can never actually use the type’s name.

Thankfully there’s a trick that uses generic parameter inference that allows us to do this (it relies on the fact that the compiler will share (or “unify”) the definition of multiple anonymous types when they have the same number of members, in the same order, of the same type, with the same names, and the same mutability):

Dim db As New NorthwindDataContext

Dim query = From row In db.Customers _

Select row.CompanyName, row.CustomerID

Dim allOption = New With {.CompanyName = "All Customers", _

.CustomerID = "-1"}

ComboBox1.DataSource = AddOptionForAll(query, allOption).ToList()

ComboBox1.DisplayMember = "CompanyName"

ComboBox1.ValueMember = "CustomerID"

...

Function AddOptionForAll(Of T)(ByVal sequence As IEnumerable(Of T), _

ByVal allOption As T) As IEnumerable(Of T)

'wrap individual element in an array and then union the two sequences

Return (New T() {allOption}).Union(sequence)

End Function

As long as we have an anonymous type that’s compatible with the anonymous type that the query generated, the compiler will determine that sequence and allOption are actually the same type and this should work fine.

Ok so let’s get to the bug – well in this case spotting it is pretty simple (it doesn’t compile J), but fixing it is tricky (though I’ve already given two pretty big hints). Here’s the text of the compiler error (it’s on the line that calls AddOptionForAll):

Data type(s) of the type parameter(s) in method 'Public Function AddOptionForAll(Of T)(sequence As System.Collections.Generic.IEnumerable(Of T), allOption As T) As System.Collections.Generic.IEnumerable(Of T)' cannot be inferred from these arguments because they do not convert to the same type. Specifying the data type(s) explicitly might correct this error.

What’s wrong and how do we fix it?

Answer: We actually told the compiler to generate two different anonymous type definitions, and thus it can’t unify them because the types really are different.

From earlier: “…the compiler will share (or “unify”) the definition of multiple anonymous types when they have the same number of members, in the same order, with the same names, and the same mutability”

The anonymous type that the query generates will have ReadOnly properties, whereas the anonymous type that we generated (allOption) will have Read/Write properties. The fix is to allOption immutable so that its structure will match the result of the query:

Dim allOption = New With {Key .CompanyName = "All Customers", _

Key .CustomerID = "-1"}

The “Key” modifier tells the compiler to make those properties ReadOnly and to override Equals and GetHashCode such that they only consider “Key” properties when deciding if two instances of the same anonymous type are equal. (the other hint was in the title J). For the query above, the compiler automatically inserts the “Key” modifier - i.e. what we wrote is exactly equivalent to this:

Dim query = From row In db.Customers _

Select New With {Key row.CompanyName, Key row.CustomerID}

So with a simple fix to the allOption line we’re now using the same anonymous type definition and everything works fine.

VB’s anonymous type syntax is very flexible and provides three different options: immutable, fully mutable, or partially mutable (i.e. some fields are ReadOnly while others are not). Even for a simple scenario like adding an option to a list, the better you understand how things work under the covers the easier it’ll be to debug problems later J.

Linking Zune media items with LinQ, Part 2 (Matt Gertz)

VBTeam — Sat, 07 Nov 2009 16:00:00 GMT

In this post, I’ll continue on with coding the new playlist shuffler. If you haven’t read part 1 yet, I highly recommend it so that this post will make more sense. J

Code for the controls (continued)

The Title TextBox

When the title changes, we’ll want to indicate that the playlist has changed, and we’ll want to cache the change and update the menus. This is pretty simple:

Private Sub edtTitle_TextChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles edtTitle.TextChanged

playlistTitle = edtTitle.Text

FileChanged = True

ResetMenus()

End Sub

The ListBox

The listbox has only two events that we need to handle. The first is just handling whenever the selection changes – we’ll have to update the buttons in such a case:

Private Sub ListBox1_SelectedIndexChanged(ByVal sender As Object, _

ByVal e As System.EventArgs) Handles ShuffleListBox.SelectedIndexChanged

ResetButtons()

End Sub

The other event is the DrawItem event, which is called whenever a listbox element needs to be draw. Normally, this event is handled by the base class, but for this application, we’ll handle it so that we can decorate items which are linked. (We set this up by setting the DrawMode property of the listbox to OwnerDrawFixed.) Now, it even gets called when the listbox is empty, in order to draw the focus rectangle or whatever else should go into an empty list. Drawing isn’t too difficult. First, I’ll let it draw the background as usual:

Private Sub ShuffleListBox_DrawItem(ByVal sender As Object, _

ByVal e As System.Windows.Forms.DrawItemEventArgs) _

Handles ShuffleListBox.DrawItem

e.DrawBackground()

Then, assuming that the index is non-zero and we actually have some text, we’ll check to see if the item is linked. Anything linked with be written in bold, with the header node written in green, the tail node written in red, and anything in-between written in blue. The default, however, will be black text:

If e.Index >= 0 Then

Dim myBrush As Brush = Brushes.Black

which we will use if there are no links involved:

If elem.NextLinkedElement Is Nothing AndAlso elem.PrevLinkedElement Is Nothing Then

e.Graphics.DrawString(ShuffleListBox.Items(e.Index).ToString(), _

e.Font, myBrush, e.Bounds, StringFormat.GenericDefault)

but if there are links, we’ll have to use a bold font:

Else

Dim linkFont As Font = New Font(e.Font.Name, e.Font.Size, _

FontStyle.Bold, e.Font.Unit)

and set the colors appropriately:

If elem.NextLinkedElement IsNot Nothing _

AndAlso elem.PrevLinkedElement Is Nothing Then

myBrush = Brushes.Green ' Starting items are green

ElseIf elem.NextLinkedElement IsNot Nothing _

AndAlso elem.PrevLinkedElement IsNot Nothing Then

myBrush = Brushes.Blue ' Middle items are blue

ElseIf elem.NextLinkedElement Is Nothing _

AndAlso elem.PrevLinkedElement IsNot Nothing Then

myBrush = Brushes.Red ' End items are red

End If

e.Graphics.DrawString(ShuffleListBox.Items(e.Index).ToString(), _

linkFont, myBrush, e.Bounds, StringFormat.GenericDefault)

End If

Finally, regardless of what we drew, we’ll need to draw the focus rectangle (and dotted line around any selections:

e.DrawFocusRectangle()

End Sub

The Link and Unlink buttons

I’ve been chattering a lot about linked files, but without walking through the process of actually linking them, it may be hard to see how they work in practice. When Link is chosen, we’ll take all of the selected files, move them together, and point them at each other as a doubly-linked list. We can then use the existence of these links to change the behavior the program when drawing the items (as we have already done), shuffling them, or even saving them (more on that later).

To link the files, first we need to know how many:

Private Sub LinkBtn_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles LinkBtn.Click

Dim numToLink As Integer = ShuffleListBox.SelectedItems.Count

Then, we need to iterate through each of those and link them.:

For index As Integer = 0 To numToLink - 1

Dim elem As xmlMediaEntry = ShuffleListBox.SelectedItems(index)

elem.NextLinkedElement = If(index <> numToLink - 1,_

CType(ShuffleListBox.SelectedItems(index + 1), xmlMediaEntry), _

Nothing)

elem.PrevLinkedElement = If(index <> 0, _

CType(ShuffleListBox.SelectedItems(index - 1), _

xmlMediaEntry), Nothing)

Note that I am using the If() ternary function above, which takes three arguments. The first is the condition to test, the second is code to run if the condition is true, and the third is code to run if the condition is false. In this case, I’m checking to see if we are at the first or last of the selected items, and linking accordingly. Since header nodes shouldn’t have a “previous” and tail nodes shouldn’t have a “next”, I set these to Nothing under those conditions – otherwise, they are set to reference the adjacent node in the appropriate direction.

Now, I want to physically move the linked tracks together so that they will actually play together. I’ll get the first one where it is, and move the others up right behind it. I do this by removing them from the listbox and adding them back in at the right spot, and then remind the listbox that they should still be selected:

If index <> 0 Then

ShuffleListBox.Items.RemoveAt(ShuffleListBox.SelectedIndices(index))

ShuffleListBox.Items.Insert(ShuffleListBox.SelectedIndices(index - 1) + 1, elem)

ShuffleListBox.SetSelected(ShuffleListBox.SelectedIndices(index - 1) + 1, True)

End If

Be careful here; we are making two assumptions in all of this. First, we will be assuming that the list of selected indices is ordered from lowest to highest, and also that the list of selected objects is in the same order as the selected indices (although we could work around the latter point). These are safe assumptions to make, as near as I can tell. Second, we need to remember that the contents of SelectedIndices are indices into the Items() collection – that is, the contents of the 0^th index of the SelectedIndices might refer to the 4^th entry of Items() – that can get confusing.

Anyway, once we’ve moved them together and linked them, we need to tell the listbox to repaint so that it redraws the linked items appropriately. To do this, we invalidate the control, and then tell it to update the invalidated regions:

ShuffleListBox.Invalidate()

ShuffleListBox.Update()

Finally, we need to update the buttons and menus, because we have changed the playlist and we are in a condition where we could unlink now:

FileChanged = True

ResetMenus()

ResetButtons()

End Sub

Unlink is sort of the opposite of Link, as you might expect, but there is a catch – we might not have the entire chain in the selection. This means that we’ll have to navigate back to the head node for a chain before navigating through and unlinking. We’ll use a helper function to do this; the unlink handler simply checks each selected item to see if it is part of a chain and calls the helper function if so, then invalidates/repaints/updates:

Private Sub UnlinkBtn_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles UnlinkBtn.Click

For Each item As xmlMediaEntry In ShuffleListBox.SelectedItems

If item.PrevLinkedElement IsNot Nothing _

OrElse item.NextLinkedElement IsNot Nothing Then

FlushLinkSetFromBeginningToEnd(item)

End If

ShuffleListBox.Invalidate()

ShuffleListBox.Update()

FileChanged = True

ResetMenus()

ResetButtons()

End Sub

Note that FlushLinkSetFromBeginning to End will clean out the whole linked chain for that item, so even if other members of that chain were part of the selection, it won’t be called a second time when those members are hit in the loop – they’ll already have had their links cleaned out. To prove that, here’s the code, which is identical to the link-crawling code we all learned in college (if we’re that old yet J):

Private Sub FlushLinkSetFromBeginningToEnd(ByVal elem As xmlMediaEntry)

Dim current As xmlMediaEntry = elem

' Rewind to the head of the linkage

While current.PrevLinkedElement IsNot Nothing

current = current.PrevLinkedElement

End While

' Now destroy the links in this chain, front to back:

Do While current.NextLinkedElement IsNot Nothing

current.PrevLinkedElement = Nothing

current = current.NextLinkedElement

current.PrevLinkedElement.NextLinkedElement = Nothing

Loop

current.PrevLinkedElement = Nothing

End Sub

Move Up and Move Down buttons

After moving the items during the Link, this code will look pretty tame. We’ll create a helper function to do the removal in either direction. We’ll verify that the helper function is told to move up or down exactly one, and return without doing anything otherwise:

Private Sub MoveEntry(ByVal direction As Integer)

If direction <> 1 AndAlso direction <> -1 Then Return

Now we’ll get the item and see if it’s linked. Moving a linked item will put the links out-of-sync with the playlist order, so we will flush the links out, since the assumption is that it was a bad chain to begin with:

Dim index As Integer = ShuffleListBox.SelectedIndices(0)

Dim item As xmlMediaEntry = ShuffleListBox.Items(index)

If item.PrevLinkedElement IsNot Nothing OrElse item.NextLinkedElement IsNot Nothing Then

FlushLinkSetFromBeginningToEnd(item)

End If

Then we remove and insert the item appropriately, keep it selected, and do the usual updating:

ShuffleListBox.Items.RemoveAt(index)

ShuffleListBox.Items.Insert(index + direction, item)

ShuffleListBox.SetSelected(index + direction, True)

ShuffleListBox.Invalidate()

ShuffleListBox.Update()

FileChanged = True

ResetMenus()

ResetButtons()

End Sub

We can then call this helper function from the event handlers, specifying -1 for “up” and +1 for “down”:

Private Sub MoveUpBtn_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MoveUpBtn.Click

MoveEntry(-1) ' Move in the negative direction

End Sub

Private Sub MoveDownBtn_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MoveDownBtn.Click

MoveEntry(1) ' Move in the positive direction

End Sub

The Shuffle Button

If you’ve read the posts that I did on my earlier attempts to shuffle a playlist, then this should be pretty familiar territory – we’ll create a new list, do an insertion from the first list to a random place in the second list (bringing along linked items), and then point the playlist to the new list. The big difference in this case is that we won’t be removing items from the first list until we’re all done. Why? Because the listbox (i.e., the original list) is an active control, and we don’t want it to have it flashing at the user during the shuffle.

First,we’ll create the storage list into which we will insert, and get the number of songs to move:

Private Sub Shuffle_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles ShuffleBtn.Click

Dim newList As New List(Of xmlMediaEntry)

Dim numberOfSongs As Integer = ShuffleListBox.Items.Count

Next, we walk through the original list and start moving things to random locations in the new list. There are two cases: the item is a header node for a linked set, or it is not. If it is a header node, we’ll move all of the associated files (middle and tail nodes) together with it, and increment the loop counter appropriately past all of those:

For index As Integer = 0 To numberOfSongs - 1

Dim mediaItem As xmlMediaEntry = ShuffleListBox.Items(index)

If mediaItem.NextLinkedElement IsNot Nothing Then

Dim placeToInsert As Integer = FindInsertionLocation(newList)

Dim count = 0

Insert(placeToInsert + count, mediaItem, newList)

count += 1

mediaItem = mediaItem.NextLinkedElement

Loop While mediaItem IsNot Nothing

index += count

(FindInsertionLocation() and Insert() are helper functions; we’ll get to those in a second.) In the normal unlinked case, we just insert the file to a random location in the new list:

Else

Insert(mediaItem, newList)

End If

(Again, bear with me – I’ll describe Insert() in a bit.) The new list is ready to go now, so we’ll flush all of the old items all at once using Clear(), and then reinsert the items in the new order.

ShuffleListBox.Items.Clear()

For Each m In newList

ShuffleListBox.Items.Add(m)

' This is a playlist change, so react accordingly:

FileChanged = True

ResetMenus()

ResetButtons()

End Sub

(You could also simply remove and insert items to random location in the listbox without creating a second list – that would save some memory, but not enough to counter the elegance of operating beginning-to-end with minimal flickering in the listbox. If you are interested in that sort of randomization, check out the shuffle routine in my Euchre game series of posts.)

Now, to our helper functions: FindInsertionPoint needs to find a location in the new list that isn’t in the middle of a set of linked songs. We’ll do this in a simple way: generatea number, and if it’s in the middle of a list, then just rewind and use the location before the chain of songs. Of course, if the list is empty, we’d insert at 0. This is fundamentally identical to the version of this function from my earlier posts, so I won’t go into too much detail:

Private Function FindInsertionLocation(ByVal newList As List(Of xmlMediaEntry)) As Integer

If newList.Count = 0 Then

Return 0

Else

Dim placeToInsert As Integer = _

Math.Truncate(Microsoft.VisualBasic.Rnd() * (newList.Count + 1))

If placeToInsert = newList.Count Then Return placeToInsert ' Insert at end

Dim mediaItem As xmlMediaEntry = newList.Item(placeToInsert)

Dim itemEntry As xmlMediaEntry = mediaItem.PrevLinkedElement

If itemEntry IsNot Nothing Then

While itemEntry IsNot Nothing

itemEntry = itemEntry.PrevLinkedElement

placeToInsert -= 1

End While

Return If(placeToInsert >= 0, placeToInsert, 0)

End If

Return placeToInsert

End If

End Function

Insert() just wraps a normal insertion by checking for the condition where the index is at the end of the list, so that Add is used instead in that case:

Private Sub Insert(ByVal place As Integer, ByVal mediaItem As xmlMediaEntry, _

ByVal newList As List(Of xmlMediaEntry))

If place = newList.Count Then

newList.Add(mediaItem)

Else

newList.Insert(place, mediaItem)

End If

End Sub

And its overload (used in the simple file case) just calls FindInsertionLocation to get an index, then calls into its sibling:

Private Sub Insert(ByVal mediaItem As xmlMediaEntry, ByVal newList As List(Of xmlMediaEntry))

Dim place As Integer = FindInsertionLocation(newList)

Insert(place, mediaItem, newList)

End Sub

Persisting Linkage Information from Session to Session

We’re almost done now. Using what we’ve got, we can load in a playlist, link music items, shuffle it, and save it out. The linkage information, however, won’t persist – the next time we load in the playlist, it will be gone. In order to preserve this information so that the PC or Zune won’t stomp on it, we’ll avoid using metadata and instead we’ll persist a second hidden file which keeps this information handy. The information will be stored as XML in this format:

<body>

<mlink>

<media…/>

</mlink>

<mlink>

<media…/>

</mlink>

</body>

So, each <mlink> tag set will contains an arc of linked songs in sequential order.

We’ll save this information to a hidden file with a name identical to that of the playlist, but with the suffix “.links” added to it. After loading the link file after the playlist file, we’ll use this information to relink the files in the listbox. If Zune has changed the corresponding playlist (i.e., if the user has removed, added, or rearranged songs from within Zune), that’s OK; we’ll ignore any songs that we can’t identify.

First, let’s concentrate on saving the information. We’ll create a trivial helper function to create the hidden file’s name:

Private Function GetHiddenFileName() As String

Return FilePath & ".links"

End Function

Now, in EmitXML, we’ll add the following code at the end of the method:

Dim hiddenLinkInfo = <?xml version="1.0"?>

<body>

<%= GetLinkInfo() %>

</body>

This is similar to the other emit code – I create a schema for my XML document, but defer to a helper function to fill in the actual XML elements. Next, I need to determine if a previous version of the hidden file already exists. If it does, I’ll need to un-hide and delete it:

Dim hiddenPath As String = GetHiddenFileName()

If My.Computer.FileSystem.FileExists(hiddenPath) Then

File.SetAttributes(hiddenPath, FileAttributes.Normal)

My.Computer.FileSystem.DeleteFile(hiddenPath, FileIO.UIOption.OnlyErrorDialogs, FileIO.RecycleOption.DeletePermanently)

End If

Finally, I’ll save it and hide it:

' Save it and hide it.

hiddenLinkInfo.Save(hiddenPath)

File.SetAttributes(hiddenPath, File.GetAttributes(hiddenPath) Or FileAttributes.Hidden)

Next, I’ll create the helper function. To show how nicely this all nests, I’ll use one helper function for the <mlink> tags, and then one for the media items within those tags. Here’s GetLinkInfo:

Private Function GetLinkInfo() As IEnumerable(Of XElement)

Dim linkInfos As New List(Of XElement)

For Each m As xmlMediaEntry In ShuffleListBox.Items

If m.NextLinkedElement IsNot Nothing And m.PrevLinkedElement Is Nothing Then

Dim linkInfo = <mlink><%= GetLinkSet(m) %></mlink>

linkInfos.Add(linkInfo)

End If

Return linkInfos

End Function

As you can see, the code iterates through the listbox and finds the next header node for a linked arc of songs. It generates a <mlink> tag for the set, and then uses yet another helper function to get eh media items, called GetLinkSet, which does a standard link crawl and returns the XELements in a list:

Private Function GetLinkSet(ByVal m As xmlMediaEntry) As IEnumerable(Of XElement)

Dim linkSet As New List(Of XElement)

linkSet.Add(m.xmlElem)

m = m.NextLinkedElement

Loop While m IsNot Nothing

Return linkSet

End Function

I really like this solution; it is extremely elegant! But now we have to load it all back in when opening a playlist, so we add the following code to Open() right before the FileChanged = False line:

Try

Dim hiddenPath As String = GetHiddenFileName()

Dim xmlLinks As XElement = XElement.Load(hiddenPath)

Dim linkSets = From links In xmlLinks...<mlink> _

Select links

That opens the hidden file and gets the all of the <mlink> elemets. Next, for each of the <mlink> elements, we’ll retrieve the media elements and see if they exist in the listbox that we just populated earlier in Open(). If they do, we can throw them into a list to link up again as if the user had selected them. If we can’t find a particular song, we just skip it and work with whatever we’ve got.

For Each linkSet In linkSets

Dim linkedFiles = From media In linkSet.<media> _

Select media

Dim listOfElements As New List(Of Integer)

For Each m In linkedFiles

Dim entry As Integer = ShuffleListBox.FindStringExact(xmlMediaEntry.CreateMediaString(m))

If entry <> -1 Then

listOfElements.Add(entry)

End If

Link(listOfElements)

(Link() is a helper function which I’ll describe in a second.) Note that we are using the publically shared method of getting a file’s identifier from its title and artist. That should hopefully be enough to identify the song uniquely – if not, we can change CreateMediaString to return some other value, bearing in mind that whatever we choose will show up in the listbox. (Or, we can slowly step through the listbox and look for an exact match on all of a song’s attributes, but that’s not much fun…)

If we can’t open the hidden file, it might not exist, so we’ll just ignore that condition:

Catch ex As Exception

End Try

The final thing we need to do is define the Link() helper function. It’s very similar to the code we wrote to link selected items, except of course the items are not selected, and forcing a temporary multi-selection just for the purposes of linking would be an ugly hack. The biggest difference is that the items are drawn from a list of indices that we created in Open, we don’t have a SelectedItems list to help us, and we don’t need to set any file state – that’s done by the “Open” command. Otherwise, it’s very similar, and if we worked hard enough at it, we could probably combine the two functions (I’m feeling lazy):

Private Sub Link(ByVal linkList As List(Of Integer))

Dim numToLink As Integer = linkList.Count

For index As Integer = 0 To numToLink - 1

Dim elem As xmlMediaEntry = ShuffleListBox.Items(linkList(index))

elem.NextLinkedElement = If(index <> numToLink - 1, _

CType(ShuffleListBox.Items(linkList(index + 1)), xmlMediaEntry), _

Nothing)

elem.PrevLinkedElement = If(index <> 0, _

CType(ShuffleListBox.Items(linkList(index - 1)), xmlMediaEntry), _

Nothing)

If index <> 0 Then

ShuffleListBox.Items.RemoveAt(linkList(index))

ShuffleListBox.Items.Insert(linkList(index - 1) + 1, elem)

End If

ShuffleListBox.Invalidate()

ShuffleListBox.Update()

End Sub

And that’s it! As usual, the full code can be found on my Temple of VB site.

‘Til next time,

--Matt--*

Linking Zune media items with LinQ, Part 1 (Matt Gertz)

VBTeam — Fri, 06 Nov 2009 22:17:00 GMT

Way back in October 2007, I wrote up a few posts (here and here) on my experiments with the Windows Media Player object model. The problem I was trying to solve was that, when I had a playlist set to “shuffle,” WMP would break up songs that should always play together (for example, Jackson Browne’s “The Load-Out” and “Stay”, or Pink Floyd’s “Brain Damage” and “Total Eclipse”). In those posts, I worked around this by building my own shuffler which would emit a new randomized playlist which preserved those links, and then playing that playlist. A few months later, after I bought my Zune 80, I updated the program to copy the playlist to a ZPL format, since the format was essentially identical to WPL.

Although this was a good investigation into the WMP object model, I’ve never been happy with the program. First of all, for the program to work, I had to add metadata to the actual music tracks, and anything could come along and blow that metadata away. Second, the tracks had to already be adjacent in the parent playlist for it to work at all. Third, I had to bring up the WMP just to shuffle a playlist, which is pretty heavyweight. Finally, since I mostly care about Zune playlists these days and not WMP at all, it seemed the height of hackery to bring up the WMP to generate something for Zune (since the Zune object model is not public).

So, last week, after seeing my metadata blown away again when I carelessly updated my tracks after upgrading to Windows 7, I decided to work on a more permanent solution. Why bring up the WMP at all (or Zune, for that matter), when the playlists themselves are just XML, and the track just entries into those?

After some experiments with parsing the XML by following the parent/child chain, which seemed kludge to me, I came across a post by Avner in which he discusses porting iTunes playlists to Zune, leveraging LinQ to help with the data parsing. I realized right away that I could do something very similar in this case, and came up with what I think is a pretty elegant solution.

So here’s the plan: the application will:

(1) Load in a playlist that the user chooses

(2) Allow the user to rearrange the playlist

(3) Allow the user to link certain tracks together (and unlink them)

(4) Shuffle the playlist on command, preserving the linkages

(5) Allow the user to change the title of the playlist

(6) Allow the user to cave the playlist (or a copy of it)

(7) And, most important, persist the linkage data between sessions in such a way that the information won’t get blown away.

Let’s get started!

The form

Create a Windows Form Application (about 430 x 300) containing the following:

(1) A ListBox, about 290 x 180 and positioned on the left side, with the SelectionMode property set to “MultiExtended” and the DrawMode set to “OwnerDrawFixed.”

(2) Above that, a Label and EditBox, with the Label text set to “&Title”.

(3) To the right of those, five Buttons going down the right side, labeled “Link”, “Unlink”, “Move Up”, “Move Down”, and “Shuffle”.

(4) A MenuStrip. Select it, and on the right side of the strip, click the tiny right-pointing triangle icon and choose “Insert Standard Items” from the resulting popup. Now, go back and remove all of the items except File (Open, Close, Save, Save As, Exit) and Help (About). The Edit and Tools menu can be completely removed; we won’t be using those.

(5) An OpenFileDialog and a SaveFileDialog. The Filter property of both should be set to “Zune playlists|*.zpl” (without the quotes).

In my example, I also disabled the Maximize box in the form, added an icon and title to the form and application, etc., but those aren’t strictly necessary for the exercise.

The Zune playlist

The format of a Zune playlist (version 2.0) looks like this (memorize this, it will be useful later):

<smil>

<head>

<title> (some title) </title>

</head>

<body>

<seq>

<media … /> (etc… one for each track)

</seq>

</body>

</smil>

Code for the controls

The rest of this post will be organized based on the controls, starting from the top.

The Form

The only code associated with the form itself is the event handler for Load, a few member variables, and a helper class. Let’s take those in reverse order:

The helper class, xmlMediaEntry

We’ll be reading the Zune playlist using the XDocument class, and then we’ll be using LinQ to retrieve individual <media>…</media> tag pairs representing each track. These will be handed to us as XElements, and as we will want to add each of the tracks to the listbox, we’ll want to wrap these in an object that will expose the proper information to the ListBox – namely, a human-readable string. We will also want to have a way to link a track to another track, and we’ll be using a doubly-linked list to do this. So:

Class xmlMediaEntry

Public xmlElem As XElement

Public PrevLinkedElement As xmlMediaEntry = Nothing

Public NextLinkedElement As xmlMediaEntry = Nothing

That code allows us to cache the XElement and also point to other elements of this class backwards and forward. The header node for a chain of linked songs will have PrevLinkedElement remaining as Nothing; the tail node will have NextLinkedElement remain as Nothing; songs in the middle of the chain will have both of those set to some other node.

The following constructor allows us to initialize the object with the XElement to be cached.

Sub New(ByVal xelem As XElement)

xmlElem = xelem

End Sub

This code, exposed publically as a shared method, allows us to create a canonical (and readable) way to refer to a track in an XElement. To use one of my previous examples, the resulting value might be “The Load-Out (Jackson Browne)”:

Public Shared Function CreateMediaString(ByVal elem As XElement) As String

Return elem.Attribute("trackTitle").Value & _

" (" & elem.Attribute("trackArtist").Value & ")"

End Function

I can then leverage that function to override the ToString for the xmlMediaEntry:

Public Overrides Function ToString() As String

Return CreateMediaString(xmlElem)

End Function

End Class

And that’s all I need in that class. Once I add an instance of it to the ListBox, it will show up with nice readable text, and I’ll be able to navigate between it and any other linked songs (if any).

Member Variables

I’ll need a few variables to keep track of the state of the file, and these should all be self-explanatory:

Private FileLoaded As Boolean = False ' Do we have a file loaded into the listbox?

Private FileChanged As Boolean = False ' Has the playlist changed since it was last loaded/saved?

Private FilePath As String ' Where was the file last loaded from/saved to?

Private FileDirectory As String ' What directory was the file last loaded from/saved to?

We’ll also need to keep track of some of the playlist’s metadata. Each playlist has a GUID associated with it (if you don’t know what a GUID is, don’t worry about it – think of it as a unique identifier); if we do a “Save As” to a different file, we’ll want a different GUID. The user might also change the title of the playlist, and we should cache our creatorId format since it might be unique to the user’s situation:

Private playlistGuid As String ' What is the GUID of this playlist?

Private playlistTitle As String ' What is the title of this playlist?

Private playlistCreatorId As XElement ' What is the creator information of this playlist?

Events

The Form only has two events to handle that we care about – the Load event, and the FormClosing event. For the Load event, we’ll want to make sure that our menu items and buttons are enabled appropriately, and that we appropriately generate random numbers later on:

Private Sub VBShuffleForm_Load(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles MyBase.Load

Microsoft.VisualBasic.Randomize()

ResetButtons()

ResetMenus()

End Sub

We will be using those helper functions quite a lot, so it’s worth going over them. For ResetMenus, the “Open” commands will always be available, so we’ll apply a little overkill and ensure that. “Save As” and “Close” will be available whenever a file is loaded (otherwise, we’d have nothing to save or close!), and “Save” will be available if a file is loaded and has been changed since the last time that it was saved or loaded:

Private Sub ResetMenus()

OpenToolStripMenuItem.Enabled = True

CloseToolStripMenuItem.Enabled = FileLoaded

SaveAsToolStripMenuItem.Enabled = FileLoaded

SaveToolStripMenuItem.Enabled = FileLoaded AndAlso FileChanged

edtTitle.Enabled = FileLoaded

End Sub

Somewhat more complicated is ResetButtons. Each button reacts to one of three situations – nothing is selected in the listbox, exactly one thing is selected in the listbox, or multiple things are selected in the listbox. The breakdown is as follows:

· “Link” is only available if multiple things are selected. You can’t link if nothing is selected, and you can’t link a file to itself. It’s also OK to link files that are already linked, since you might be adding more files to the chain of songs.

· “Unlink” is available if at least one item in the selection has a link. You don’t have to select an entire link set to unlink it; it’s sufficient just to select one of the members of the link chain. If the selection contains elements from multiple link chains, then all of the associated chains will be unlinked. We can examine the “PrevLinkedElement” and “NextLinkedElement” values to determine if an item has a link.

· “Move Up” or “Move Down” moves one song, so they are only available if exactly one song is selected.

· “Shuffle” is available whenever a file is loaded.

So:

Private Sub ResetButtons()

If ShuffleListBox.SelectedIndices.Count = 0 Then

LinkBtn.Enabled = False

UnlinkBtn.Enabled = False

MoveDownBtn.Enabled = False

MoveUpBtn.Enabled = False

ElseIf ShuffleListBox.SelectedIndices.Count = 1 Then

LinkBtn.Enabled = False

MoveDownBtn.Enabled = (ShuffleListBox.SelectedIndices(0) <> _

ShuffleListBox.Items.Count() - 1)

MoveUpBtn.Enabled = (ShuffleListBox.SelectedIndices(0) <> 0)

UnlinkBtn.Enabled = (CType(ShuffleListBox.SelectedItems(0), _

xmlMediaEntry).PrevLinkedElement IsNot Nothing OrElse _

CType(ShuffleListBox.SelectedItems(0), xmlMediaEntry).NextLinkedElement _

IsNot Nothing)

Else

LinkBtn.Enabled = True

MoveDownBtn.Enabled = False

MoveUpBtn.Enabled = False

Dim enableBn As Boolean = True

For Each item In ShuffleListBox.SelectedItems

If CType(item, xmlMediaEntry).PrevLinkedElement Is Nothing AndAlso _

CType(item, xmlMediaEntry).NextLinkedElement Is Nothing Then

enableBn = False

Exit For

End If

UnlinkBtn.Enabled = enableBn

End If

ShuffleBtn.Enabled = FileLoaded

End Sub

The FormClosing event handler needs to prompt the user if there are unsaved changes before closing the application. (Note that this is the event generated from the clicking the “X” on the form’s title bar – not the “Close” menu item! We’ll implement that other one later.) The user will have an opportunity to save his/her work before closing (if applicable), or else canceling the Close operation altogether.

First, we’ll define the code which determines if it’s OK to close:

Private Function OKToUnload() As Boolean

If Not FileLoaded OrElse Not FileChanged Then

Return True

End If

Dim result As MsgBoxResult = _

MsgBox("Do you want to save your changes?", _

MsgBoxStyle.YesNoCancel, "Save changes?")

If result = MsgBoxResult.Cancel Then

Return False

Else

If result = MsgBoxResult.Yes Then

Return SaveAs()

End If

Return True

End Function

If there is no file loaded, or if the file is loaded but hasn’t changed, then it’s of course OK to proceed, and we return True. Otherwise, we pop up a MessageBox prompting the user if they want to save their changes. If the user chooses “Cancel,” then we simply return False to indicate that it is not OK to proceed. If the user chooses “Yes,” then we call SaveAs() (which we’ll define later) and return whatever the results are from that call. That just leaves “No,” which means the user doesn’t want to save changes, so we return True indicating that it’s OK to proceed. (The strings for the message box should be stored in the resources so that they can be localized, of course, but that makes the blog less readable. J)

Now, we can use that helper function in the event handler for Close:

Private Sub VBShuffleForm_FormClosing(ByVal sender As Object, _

ByVal e As System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing

If Not OKToUnload() Then

e.Cancel = True

End If

End Sub

In other words, if it’s not OK to close the application, then we set e.Cancel to True indicating that the event should be canceled.

The Menu Strip

Now, we start getting into the meat of the code. Let’s go through these one by one:

FileàOpen

Open is pretty trivial to implement, as you can see:

Private Sub OpenToolStripMenuItem_Click(ByVal sender As Object, _

ByVal e As System.EventArgs) Handles OpenToolStripMenuItem.Click

Open()

End Sub

OK, I’m kidding. I moved all of the handling for this into a helper function, in case I ever wanted to open the file in some other way than the menu click. Here’s the actual implementation:

Private Function Open() As Boolean

Try

If Not OKToUnload() Then

Return False ' User canceled; just return.

End If

As you can see, we first leverage the “OKToUnload” helper function to make sure that the user doesn’t lose any work in progress. We’ll also wrap the functionality in a Try construct in case something goes wrong with the opening of the file.

Next, we’ll get the name of the playlist to be opened. If we’ve recently loaded from (or saved to) a directory, we’ll start out there; otherwise, we’ll default to the Music directory as our initial location with no particular file in mind to load:

If String.IsNullOrEmpty(FileDirectory) Then

ShuffleOpenFileDialog.InitialDirectory = My.Computer.FileSystem.SpecialDirectories.MyMusic

Else

ShuffleOpenFileDialog.InitialDirectory = FileDirectory

End If

ShuffleOpenFileDialog.FileName = ""

Dim result As DialogResult = ShuffleOpenFileDialog.ShowDialog

If result = Windows.Forms.DialogResult.Cancel Then

Return False ' User canceled; just return

End If

And we’ll need to cache that information for later usage. (I cache the directory separately, so that I can easily use it to initialize the Save dialog’s initial location later on):

FilePath = ShuffleOpenFileDialog.FileName

Dim fileData As FileInfo = My.Computer.FileSystem.GetFileInfo(FilePath)

FileDirectory = fileData.DirectoryName

Next, we’ll close any open playlist. We’ll use a helper function to do this:

ClosePlaylist()

Where ClosePlaylist() is defined to just flush out our caches, and the listbox:

Private Sub ClosePlaylist()

' Get rid of all items and clear the member variables.

ShuffleListBox.Items.Clear()

FileLoaded = False

FileChanged = False

edtTitle.Text = ""

playlistGuid = ""

playlistTitle = ""

playlistCreatorId = Nothing

End Sub

Finally, we get to the part where we load the file! As I mentioned before, we’ll be using XElements to store the items, and reading in the file in such a case is really easy:

Dim xmlElements As XElement = XElement.Load(FilePath)

If you’re debugging this, take a moment to look at the result in the watch window. You’ll see that this is a fairly deep structure that is difficult to plumb, and so digging though it to find the media items would be quite a chore. Fortunately, LinQ to XML is here to help us, and we can use it liberally. First, let’s get and cache the GUID, so that we can spit it out again if we save back to the same file:

Dim guids = From guidEntry In xmlElements...<guid> _

Select guidEntry

playlistGuid = guids(0).Value

Looks trivial, doesn’t it? But we just saved ourselves about twenty lines of code that we would have had to write to navigate the XElement structure. Basically, I told link to search for the GUID element, nested somewhere under the root of the document (hence the “…” before the <guid> tag) and return me a list (actually an IEnumeration) of all such tags. I happen to know that there’s only one in this schema, so I’ll cache the first (and only) one returned to me.

I can do something similar for the title:

Dim titles = From titleEntry In xmlElements...<title> _

Select titleEntry.Value

playlistTitle = titles(0)

edtTitle.Text = playlistTitle

But creatorId is tricker – it’s not a tag itself, but an attribute on another tag called “<meta>.” There are several other <meta> tags which could be in any order, so I can’t simply grad the first and be done with it. Fortunately, I can use “Where” and the “@” qualifiers to narrow down the field to just the one that I want:

' Get the creatorId metatag

Dim cIds = From metaEntry In xmlElements...<meta> _

Where metaEntry.@name = "creatorId" _

Select metaEntry

playlistCreatorId = cIds(0)

But it’s the media entries that we’re most interested in. We can retrieve those similar to the way we got the title and guid information:, but this time we’ll save the results to a list that we can iterate over. Once we have that list, we will create an xmlMediaEntry for each XElement in that list, and throw it into the ListBox:

Dim mediaEntries = From media In xmlElements...<media> _

Select media

Dim mediaList As List(Of XElement) = mediaEntries.ToList

For Each m In mediaList

ShuffleListBox.Items.Add(New xmlMediaEntry(m))

The files are loaded, so we can update our state appropriately and return a “success:”

FileChanged = False

FileLoaded = True

ResetButtons()

ResetMenus()

Return True

Of course, if something went wrong, we need to tell the user, and return a failure code:

Catch ex As Exception

MsgBox("Error opening file: " & ex.Message, MsgBoxStyle.OkOnly)

Return False ' Oops, problems loading the playlist file.

End Try

End Function

FileàSave and FileàSaveAs

Here’s the other half of the file work. As with Open, we’ll do all of the work in a helper function, which we’ll then be able to leverage in other conditions:

Private Sub SaveToolStripMenuItem_Click(ByVal sender As Object, _

ByVal e As System.EventArgs) Handles SaveToolStripMenuItem.Click

Save()

End Sub

This, in turn, will call another function to emit the XML, after which it will clear the “FileChanged” flag and reset the menus, catching any errors that happen:

Private Function Save() As Boolean

Try

EmitXML()

FileChanged = False

ResetMenus()

Return True

Catch ex As Exception

MsgBox("Error saving file: " & ex.Message, MsgBoxStyle.OkOnly)

Return False

End Try

End Function

EmitXML, as you might guess, is where all of the work happens. But the work itself is pretty simple. Rather than opening a file and spitting in XML tags line by line, we’ll leverage an XML literal to build up the document and then we’ll save it wholesale to the file:

Private Sub EmitXML()

Dim playlist = <?xml version="1.0"?>

<?zpl version="2.0"?><smil>

<head>

<%= playlistCreatorId %>

</head>

<body>

<seq>

<%= GetMediaElements() %>

</seq>

</body>

</smil>

playlist.Save(FilePath)

End Sub

How cool is that? The playlistGuid, playlistCreatorId, and playlistTitle will automatically be replaced by whatever we cached, and the media will be generated within the context of the XML by a helper function called GetMediaElements(), the form of which is very simple:

Private Function GetMediaElements() As IEnumerable(Of XElement)

Dim media As New List(Of XElement)

For Each m As xmlMediaEntry In ShuffleListBox.Items

media.Add(m.xmlElem)

Return media

End Function

In other words, we just iterate through the listbox, pull the XElement out of each item, and add it to a list which gets passed back to the XML. That’s it; that’s all there is to it.

Now, we can leverage this for the Save As command; first the event handler:

Private Sub SaveAsToolStripMenuItem_Click(ByVal sender As Object, _

ByVal e As System.EventArgs) Handles SaveAsToolStripMenuItem.Click

SaveAs()

End Sub

And then the helper function. First, we get the name of the file to save, setting the initial directory to what we cached earlier, and defaulting the filename to the name of the title (instead of the original filename, reasoning that, if the user was saving to the same file, they would have used “Save” and not “SaveAs”):

Private Function SaveAs() As Boolean

ShuffleSaveFileDialog.FileName = playlistTitle

ShuffleSaveFileDialog.InitialDirectory = FileDirectory

Dim result As DialogResult = ShuffleSaveFileDialog.ShowDialog()

If result = Windows.Forms.DialogResult.Cancel Then

Return False

End If

We should supply a new GUID if the filename is going to change:

If FilePath <> ShuffleSaveFileDialog.FileName Then

playlistGuid = "{" & System.Guid.NewGuid.ToString() & "}"

End If

Then we cache the name and directory:

FilePath = ShuffleSaveFileDialog.FileName

Dim fileData As FileInfo = My.Computer.FileSystem.GetFileInfo(FilePath)

FileDirectory = fileData.DirectoryName

And having done that, we can just call Save() to do the rest of the work:

Return Save()

End Function

That’s it for the file work – for now. We’ll revisit Open and Save later when we persist the linkage info.

FileàClose and File->Exit

In the case of Close, we’re closing the playlist, not the application; for Exit, we close the application as well. The code for this is pretty trivial, as we have already written both of the helper functions involved:

Private Sub CloseToolStripMenuItem_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles CloseToolStripMenuItem.Click

If OKToUnload() Then

ClosePlaylist()

End If

End Sub

Private Sub ExitToolStripMenuItem_Click(ByVal sender As Object, _

ByVal e As System.EventArgs) Handles ExitToolStripMenuItem.Click

If OKToUnload() Then

Close()' This is Form.Close, of course.

End If

End Sub

HelpàAbout

This is pretty trivial to handle, and I’ve described it before in earlier posts, but here goes: right-click on the project, choose “Add New Item,” and add an About Dialog. Then, right-click the project again and choose “Properties.” In the resulting properties document, select the Application tab (if it isn’t already selected) and click the “Assembly Information…” button. Fill in the information however you prefer. Then, we can hook up the dialog to the command pretty easily as follows:

Private Sub AboutToolStripMenuItem_Click(ByVal sender As System.Object, _

ByVal e As System.EventArgs) Handles AboutToolStripMenuItem.Click

Dim dlg As New VBSmartShuffleAbout

dlg.ShowDialog()

End Sub

That’s all I’m going to cover in this post… it’s getting too long, and I’ve got nine more pages to go! I’ll post the next set in a separate post, and we’ll wrap this up then.

‘ Til next time,

--Matt--*

Dynamic Searching using LINQ - Dataset + Joins

VBTeam — Sat, 11 Jul 2009 03:22:00 GMT

About two years ago I posted some code that shows how to dynamically construct LINQ queries at runtime. On average there's a couple questions per month about trying it in some edge case, and usually the support already exists within the API. Recently though someone posted a question that has to do with Datasets and Joins that raised some interesting issues:

I have a dataset with two datatables (One Loaded From A CSV file) and (the other loaded from a query) what I would like to be able to do is set the criteria (i.e dtCSV.Field1=dtQuery.Field7 AND (dtCSV.Field5 != dtQuery.Field4 or dtCSV.Field5 != dtQuery.Field9)

Returning dtQuery.Field1, dtCSV.Field5

Previously the API supported conditions of the form "object.property=value", but here we have something of the form "object1.property = object2.property". It's still a completely valid expression, but it means the API will need to generate a different expression tree.

Let's walk through how you can add this support to the API:

1. At the end of Module DynamicQuery add the following extension method:

'Extension method that can be called off any type that implements IEnumerable(Of T),

'which constructs a Condition with T as the element type and compares one property (or field) with another

<Extension(), EditorBrowsable(EditorBrowsableState.Always)> _

Public Function CreateMutliColumnCondition(Of T)(ByVal dataSource As IEnumerable(Of T), _

ByVal propName As String, _

ByVal condType As condition.Compare, _

ByVal propName2 As String) As Condition(Of T)

Return Condition.CreateMutliColumn(dataSource, propName, condType, propName2)

End Function

2. Add this method to the Condition class:

'Constructs a Condition with T as the element type that compares one field/property with another

Public Shared Function CreateMutliColumn(Of T)(ByVal dataSource As IEnumerable(Of T), _

ByVal propertyName As String, _

ByVal condType As Compare, _

ByVal propertyName2 As String) As Condition(Of T)

Return New Condition(Of T)(propertyName, condType, propertyName2)

End Function

3. Add the following code to the Condition(Of T) class:

'Returns a MemberExpression for a property or field access. Also handles nesting scenarios

Private Function GetPropertyExpression(ByVal propName As String, ByVal paramExpr As ParameterExpression) As MemberExpression

'Split the string to handle nested property access

Dim s = propName.Split("."c)

'Get the PropertyInfo instance for propName

Dim pInfo = GetType(T).GetProperty(s(0))

Dim callExpr = Expression.MakeMemberAccess(paramExpr, pInfo)

'For each member specified, construct the additional MemberAccessExpression

'For example, if the user says "myCustomer.Order.OrderID = 4" we need an

'additional MemberAccessExpression for "Order.OrderID = 4"

For i = 1 To UBound(s)

pInfo = pInfo.PropertyType.GetProperty(s(i))

callExpr = Expression.MakeMemberAccess(callExpr, pInfo)

Return callExpr

End Function

Friend Sub New(ByVal propName As String, ByVal condType As Compare, ByVal propName2 As String)

Dim paramExpr = GetParamInstance(GetType(T))

Dim b As Expression = CombineExpression(GetPropertyExpression(propName, paramExpr), _

condType, _

GetPropertyExpression(propName2, paramExpr))

LambdaExpr = Expression.Lambda(Of Func(Of T, Boolean))(b, New ParameterExpression() {paramExpr})

'Compile the lambda expression into a delegate

del = DirectCast(LambdaExpr.Compile(), Func(Of T, Boolean))

End Sub

4. (optionally) the old constructor in this method should be refactored to use the helper method we introduced in #3.

Friend Sub New(ByVal propName As String, ByVal condType As Compare, ByVal value As Object, ByVal valueType As Type)

Dim paramExpr = GetParamInstance(GetType(T))

Dim callExpr = GetPropertyExpression(propName, paramExpr)

'ConstantExpression representing the value on the left side of the operator

Dim valueExpr = Expression.Constant(value, valueType)

Dim b As Expression = CombineExpression(callExpr, condType, valueExpr)

LambdaExpr = Expression.Lambda(Of Func(Of T, Boolean))(b, New ParameterExpression() {paramExpr})

'Compile the lambda expression into a delegate

del = DirectCast(LambdaExpr.Compile(), Func(Of T, Boolean))

End Sub

Now that the API supports it, we can do joins against Datasets:

'The code in this method is equivalent to the following query, but constructed dynamically

'Dim filteredQuery = From csvRow In dtCSV _

' Join orderRow In dtOrders On csvRow.CustomerID Equals orderRow.CustomerID

Dim dtCSV As New myDataset.dtCSVDataTable

dtCSV.Rows.Add(1, "Redmond")

dtCSV.Rows.Add(2, "Toronto")

dtCSV.Rows.Add(3, "Seattle")

Dim dtOrders As New myDataset.dtOrdersDataTable

dtOrders.Rows.Add(10001, 1)

dtOrders.Rows.Add(10002, 3)

dtOrders.Rows.Add(10003, 4)

dtOrders.Rows.Add(10004, 2)

Dim query = From csvRow In dtCSV _

From orderRow In dtOrders

Dim c = query.CreateMutliColumnCondition("csvRow.CustomerID", Compare.Equal, "orderRow.CustomerID")

Dim filteredQuery = query.Where(c)

DataGridView1.DataSource = (From row In filteredQuery _

Select row.orderRow.OrderID, row.csvRow.CustomerID, row.csvRow.City).ToList()

The key line here is this one:

Dim c = query.CreateMutliColumnCondition("csvRow.CustomerID", Compare.Equal, "orderRow.CustomerID")

Instead of comparing a column to a value we can now compare one column to another (either in the same table or in a different table).

<geeky overload resolution details>

Why did I name the method CreateMultiColumnCondition instead of just adding another overload called CreateCondition? To avoid introducing a breaking change! If you had code that called CreateCondition with the last parameter as a String, the compiler would infer the type parameter at that position to be String. But now with a new overload that also has a parameter of type String in that position, the compiler would now choose the new overload because that method is "less generic" (i.e. a closer match).

I don't like the idea of having to think through advanced overload resolution details to figure out which method will actually get called, so it seemed easier to just rename the method :)

</geeky>

A better (and likely more performant) implementation would actually introduce an overload of Join similar to this one for Where:

'Filters an IEnumerable(Of T) according to the specified condition

<Extension()> _

Public Function Where(Of T)(ByVal source As IEnumerable(Of T), _

ByVal condition As Condition(Of T)) As IEnumerable(Of T)

Return source.Where(condition.del)

End Function

This would involve a bit more work in the API though as the Join method takes 3 delegates rather than 1. (so Condition(Of T) would have to generate 3 smaller trees rather than one big one). It's already almost 6 on a Friday though and I'm lazy, so this is left as an exercise to the reader :)

Full VS2008 .sln is attached.

Jonathan

XML Literals, WCF and LINQ Article by Steele Price (Lisa Feigenbaum)

VBTeam — Sun, 03 May 2009 00:02:00 GMT

Steele wrote a great article in last month's issue of Visual Studio Magazine on XML Literals, WCF and LINQ. He shows how to use these three technologies together to produce more responsive ASP.NET pages, and more readable code. Lots of great tips for VB 2008.

VSM's "On VB" Column: XML Literals, WCF and LINQ by Steele Price

When using LINQ to XML why don’t I get results if I don’t import a XML namespace (Daniel Walzenbach)?

VBTeam — Thu, 30 Apr 2009 03:20:00 GMT

Hi,

I posted a bit of code the other day which I used to get a list of all Code Snippets we ship in Visual Studio. In a nutshell, I used XElement.Load to create a new XML document from a filename from which I then read elements from (There are way to many ‘”from” in this sentence ;-) ). Unfortunately, I forgot to import the XML Namespace in the code I posted which caused my code not to return any results (but instead provided me with a brilliant opportunity to write another post. hehe :-) ).

Let’s have a look at the code which is causing trouble and a Code Snippets to understand what’s going on (you can find the complete code including the Snippet class in the aforementioned post):

Dim query = _

From file In My.Computer.FileSystem.GetFiles( _

"C:\Program Files\Microsoft Visual Studio 10.0", _

FileIO.SearchOption.SearchAllSubDirectories) _

Where file.EndsWith(".snippet") _

Order By file

Dim snippets As New List(Of Snippet)

Dim snippetDocument As XElement

Dim snippet As Snippet

For Each item In query

snippetDocument = XElement.Load(item)

If snippetDocument...<Title>.Value IsNot Nothing Then

snippet = New Snippet With {.Title = snippetDocument...<Title>.Value.ToString _

, .Description = snippetDocument...<Description>.Value.ToString _

, .Path = item _

, .Size = New System.IO.FileInfo(item).Length}

snippets.Add(snippet)

End If

Code Snippet

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

<Title>Activate a Running Application by Name</Title>

<Author>Microsoft Corporation</Author>

<Description>Activates a running application using the name of the application.</Description>

<Shortcut>appActNa</Shortcut>

</Header>

<Namespace>Microsoft.VisualBasic</Namespace>

</Import>

</Imports>

<ID>applicationName</ID>

<Type>String</Type>

<ToolTip>Replace with the name of the application. This is often the title of the application window.</ToolTip>

<Default>"Untitled - Notepad"</Default>

</Literal>

</Declarations>

</Snippet>

</CodeSnippet>

</CodeSnippets>

As you can see there is a <Title> element in the the Code Snippet to which we are referring to in the code above… or are we?

Let’s dig a bit deeper, open the compiled program in .NET Reflector and disassemble it (if you don’t have .NET Reflector you have to stop reading NOW and get it!! Seriously, this tool is a life-safer and I’ve learned soooo much using it!).

If you focus on the parts I highlighted in red in the above picture you can see that <Title> consists out of the XML name and the XML namespace (check out XName..::.Get Method (String, String)). Since I didn’t import the namespace in my program an empty namespace got used resulting in the qualified name Title which doesn’t fit the namespace of the Code Snippet {http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet}Title, hence my program didn’t return any results.

To solve this problem I added the following line of code to my program

Imports <xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">

and – finally – all is good :-)

Hopefully this solved the mystery of the missing results ;-)

Best!

Daniel

How to get a list of all files of a directory (subdirectories included) (Daniel Walzenbach)?

VBTeam — Thu, 23 Apr 2009 21:53:00 GMT

I needed to create a list of all Code Snippets we ship in Visual Studio the other day containing their title, description and path on disc and size. As you might know, Code Snippets are stored in multiple directories below "%ProgramFiles%\Microsoft Visual Studio 10.0" so I had to traverse all the subdirectories of the aforementioned path to find all snippets.

Fortunately – linq to the rescue – this came down to a few lines of code :-)

Dim query = From file In My.Computer.FileSystem.GetFiles("C:\Program Files\Microsoft Visual Studio 10.0", FileIO.SearchOption.SearchAllSubDirectories) _

Where file.EndsWith(".snippet") _

Order By file

This statement gives you a List of Strings (or, to be a bit more precise, a System.Linq.IOrderedEnumerable(Of String)) which you can walk over to do all kinds of crazy things.

Here is what I did to solve the problem I described above:

Imports <xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">

Public Class Form1

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

Dim query = From file In My.Computer.FileSystem.GetFiles(txtPath.Text, FileIO.SearchOption.SearchAllSubDirectories) _

Where file.EndsWith(".snippet") _

Order By file

Dim snippets As New List(Of Snippet)

Dim snippetDocument As XElement

Dim snippet As Snippet

For Each item In query

snippetDocument = XElement.Load(item)

If snippetDocument...<Title>.Value IsNot Nothing Then

snippet = New Snippet With {.Title = snippetDocument...<Title>.Value.ToString _

, .Description = snippetDocument...<Description>.Value.ToString _

, .Path = item _

, .Size = New System.IO.FileInfo(item).Length}

snippets.Add(snippet)

End If

DataGridViewSnippets.AutoGenerateColumns = True

DataGridViewSnippets.DataSource = snippets

End Sub

End Class

Public Class Snippet

Private _Title As String

Private _Description As String

Private _Path As String

Private _Size As Long

Public Property Title() As String

Get

Return _Title

End Get

Set(ByVal value As String)

_Title = value

End Set

End Property

Public Property Description() As String

Get

Return _Description

End Get

Set(ByVal value As String)

_Description = value

End Set

End Property

Public Property Path() As String

Get

Return _Path

End Get

Set(ByVal value As String)

_Path = value

End Set

End Property

Public Property Size() As Long

Get

Return _Size

End Get

Set(ByVal value As Long)

_Size = value

End Set

End Property

End Class

Btw, if you bind the result to a DataGridView you can copy&paste from there into excel. Needo :-)

Cheers!

Daniel

Edited April 29, 2009: Included the "Imports" statement and did some cleanup work.

Community Article: Scaling ADO.NET DataTables (Beth Massi)

VBTeam — Thu, 18 Dec 2008 20:00:00 GMT

We we released a new community article onto the Visual Basic Developer Center by one of our MVPs, Jeff Certain, called Scaling ADO.NET DataTables. In this article Jeff shows shows us how to query and aggregate data using the built in DataTable methods as well as LINQ to DataSets. He compares the performance on indexed and non indexed DataTables in a variety of scenarios. See for yourself what Jeff recommends on large sets of data.

Enjoy,
-Beth Massi, Visual Studio Community

Video: Microsoft Visual Basic 2008 Tips and Tricks (Lisa Feigenbaum)

VBTeam — Sat, 06 Dec 2008 19:00:53 GMT

I've blogged the session materials for this presentation before, but now we finally have the video available too!

Here are some section markers:

Enjoy!

http://www.microsoft.com/emea/teched2008/developer/tv/default.aspx?vid=79

Tutorial: Functional Programming with Visual Basic 9.0 (Lisa Feigenbaum)

VBTeam — Tue, 25 Nov 2008 04:06:00 GMT

Using Visual Basic, and thinking about Functional Programming? Here's an excerpt from Eric White's blog, explaining why you should:

Functional Programming (FP) has the potential to reduce program line count by 20% to 50%, reduce bugs and increase robustness, and move us in the direction of taking advantage of multiple core CPUs.

He believes that the reasons many developers don't take advantage of functional programming are the learning curve and the unfamiliarity. If that's what's been holding you back, check out Eric's step-by-step tutorial on functional programming using VB 9.0. VB 9.0 and it's new language features revolving around LINQ make Visual Basic a great language for doing functional programming. Here's the tutorial to learn how:

Announcement

Tutorial

TechEd Barcelona: Session Materials (Lisa Feigenbaum)

VBTeam — Mon, 10 Nov 2008 22:33:00 GMT

I'm here at TechEd Barcelona, and the week has gotten off to a great start. Jason Zander did the keynote this afternoon, and announced lots of great tooling support that will be included in Visual Studio 2010! Exciting stuff.

I have 4 sessions here, starting tomorrow. I've attached the materials at the end of this post, in case you want to follow along during the talks!

TLA325 Conquering XML with Visual Basic 9.0

*CLICK HERE FOR SESSION MATERIALS*

Tuesday, November 11 09:00 - 10:15, Room 121

Primary Speaker(s): Lisa Feigenbaum

Track(s): Developer Tools and Languages

Level: 300 - Advanced

Session Type: Breakout Session

Abstract: XML is used in most modern applications; business documents, configuration files, object serialization, SOAP, RSS and Open XML are just a few examples. Even your Visual Studio project files and configuration settings are XML files. However, XML processing currently requires you to learn a new set of concepts and its text-based format is not easy to deal with programmatically... until now! In Visual Basic 9.0, XML becomes a built-in data type with a rich editing experience that completely eliminates the conceptual barrier between the code that you write and the XML you're trying to manipulate. In this session you will learn how to easily create, query and transform XML with Visual Basic's powerful yet easy to use syntax. We will discuss features like XML IntelliSense, XML literals, embedded expressions and using language constructs instead of a DOM to navigate the XML hierarchy. In addition, we'll explore tips, tricks and "gotchas". Say goodbye to XSLT and hello to Visual Basic 9!

TLA304 Microsoft Visual Basic 2008 Tips and Tricks

*CLICK HERE FOR SESSION MATERIALS*

Tuesday, November 11 13:30 - 14:45, Room 119 (DEV)

Primary Speaker(s): Lisa Feigenbaum

Track(s): Developer Tools and Languages

Level: 300 - Advanced

Session Type: Breakout Session

Abstract: In this session, learn how to turn yourself into a Visual Basic 2008 guru with the new language and IDE features. Tips and tricks covered include how to maximize your IntelliSense experience, leverage Refactoring features and improve the performance of your query and XML code. We go deep into integrated XML and show you how to navigate XML gotchas and express what you wish in fewer lines of code. With respect to LINQ, we explore best practices, pitfalls to avoid and answer the most frequently asked questions.

TLA02-IS Meet the Microsoft Visual Basic Team

Wednesday, November 12 09:00 - 10:15, Room 132

Primary Speaker(s): Jonathan Aneja, Lisa Feigenbaum, Karen Liu, Paul Yuknewicz

Track(s): Developer Tools and Languages

Level: 200 - Intermediate

Session Type: Interactive Session

Abstract: Join members of the Visual Basic team as we discuss Microsoft Visual Studio 2008 and plans for our next release of Visual Basic. This is a good opportunity to get to know team members, to ask questions, give suggestions and ask for guidance. Come prepared to chat, to listen, to ask questions and to laugh.

TLA06-IS Microsoft Visual Studio Languages Chat

Wednesday, November 12 10:45 - 12:00, Room 128

Primary Speaker(s): Jonathan Aneja, Ale Contenti, Lisa Feigenbaum, Curt Hagenlocher, Luke Hoban, Marian Luparu, Tarek Madkour, Mads Torgersen, Paul Yuknewicz

Track(s): Developer Tools and Languages

Session Type: Interactive Session

Abstract: In this session, we will discuss Microsoft’s core languages (Visual Basic, Visual C#, and Visual C++), functional language (F#) and dynamic languages (IronRuby and IronPython). Each language has its own style and advantages. Come chat with representatives from the Microsoft Visual Studio product teams, bring your questions, and get ready for a fun discussion!

Ask the Experts:

My time slot is Wednesday, November 12 at 12:45-13:15. Hope to see you there!

Visual Basic at TechEd SouthEast Asia (Lisa Feigenbaum)

VBTeam — Thu, 04 Sep 2008 00:29:00 GMT

This is a follow-up to my presentations at TechEd SouthEast Asia. Please find all the descriptions and materials for the presentations on the following resource page: http://code.msdn.microsoft.com/techedsea

Here are some direct links to the materials:

TLA 314 - Visual Basic 2008 Tips and Tricks

TLA 323 - Best Practices for the VB9.0 and CSharp 3.0 Features that Make LINQ Work

TLA 335 - Conquering XML with Visual Basic 9.0

And now, some pictures below. :)

Visual Basic at TechEd South Africa 2008 (Lisa Feigenbaum)

VBTeam — Wed, 03 Sep 2008 01:22:00 GMT

Thanks to those of you who attended my sessions at TechEd South Africa 2008. As promised here are the presentation materials I used, so you try out the examples yourself! I've created a Code Gallery resource page to host the material, with all the session abstracts, powerpoints, and solutions. That resource page is available here: http://code.msdn.microsoft.com/tesalf/

More details on the individual sessions are below. Please click the talk names to view their downloadable materials.

DEV311 - Visual Basic 2008 Tips and Tricks

Abstract: In this session, learn how to turn yourself into a Visual Basic 2008 guru with the new language and IDE features. Tips and tricks covered include how to maximize your IntelliSense experience, leverage Refactoring features, and improve the performance of your query and XML code. We go deep into integrated XML and show you how to navigate XML gotchas and express what you wish in fewer lines of code. With respect to LINQ, we explore best practices, pitfalls to avoid, and answers to most frequently asked questions.

DEV312 - Best Practices for the VB9.0 and CSharp 3.0 Features that Make LINQ Work

Abstract: VB 9.0 and C# 3.0 introduce a number of new language features such as anonymous types, lambda expressions, extension methods, local type inference and more. These are all features that can help improve your code; however, they also present new opportunities to make mistakes. This talk explains how to use and how not to use the new features of VB and C#. Each feature will be introduced with a small example, and you should be able to follow even if you’re not already familiar with it. Finally, the talk will culminate by showing how all these features come together in the VB and C# compilers to enable the most powerful language feature in the 2008 release: LINQ!

This talk was adapted from a presentation by Charlie Calvert. To view LINQ content from Charlie, please see his LINQ Farm resource page.

DEV313 - Conquering XML with Visual Basic 9.0

Abstract: XML is used in most modern applications. Business documents, configuration files, object serialization, SOAP, RSS, and Office Open XML are just a few examples. Even your Visual Studio project files and configuration settings are XML files. However, XML processing currently requires you to learn a new set of concepts, and its text-based format is not easy to deal with programmatically… until now! In Visual Basic 9.0, XML becomes a built-in data type with a rich editing experience that completely eliminates the conceptual barrier between the code that you write and the XML you're trying to manipulate. In this session you’ll learn how to easily create, query and transform XML with Visual Basic’s powerful yet easy to use syntax. We’ll discuss features like XML IntelliSense, XML literals, embedded expressions and using language constructs instead of a DOM to navigate the XML hierarchy. In addition, we’ll explore tips, tricks, and “gotchas”. Say goodbye to XSLT and hello to Visual Basic 9!

This talk was adapted from a presentation by Beth Massi. To view Beth's webcast, please click here.

CNT01 - Q&A: .Net, A Multi-Language Platform

Abstract: Lisa, the Microsoft program manager for Visual Basic’s Editor and Debugger, and Bart de Smet, former Visual C# MVP, will share their thoughts on .NET Languages and give you ample time for questions. Come prepared to chat, to listen, to ask questions, and to laugh.

VB 2008 Language Deep Dive - Presentation Materials (Jonathan Aneja)

VBTeam — Thu, 21 Aug 2008 07:55:00 GMT

Last week I got the chance to visit the Toronto .NET User Group and give a talk on all the great new language features in VB2008. It was great to see so much excitement around LINQ and especially XML Literals!

The slides and demo code are posted at the link below; here’s the session abstract (with links inserted so you can find more info on each topic):

Language Integrated Query (LINQ) is a new platform feature in Visual Studio 2008 that allows you to access objects, databases, and XML through a common query syntax (in both VB and C#). In this talk, we’ll take a deep dive into the language features that LINQ uses internally to process your query, and see how they can be used in your own code. Topics we’ll cover include:

- Query expressions
- XML Literals
- Type Inference
- Anonymous Types
- Extension Methods
- Lambda expressions
- Closures
- Expression Trees
- Partial Methods
- Relaxed Delegates
- Performance/Deferred Execution
- LINQ to Dataset
- Dynamically constructing a LINQ query

We’ll also look at some of the cool new IDE features as well as free add-ons such as Refactor! which can greatly improve your day-to-day productivity. If you want to learn what makes VB the most powerful language for working with data then come on out!

Some of the resources mentioned on the last slide:

- VB Team blog (well, you’re already here J)

- Paul Vick’s blog (http://panopticoncentral.net)

- Beth Massi’s blog (http://blogs.msdn.com/bethmassi)

- MSDN VBasic site (http://msdn.com/vbasic)

For those of you who were asking about dynamically constructing LINQ queries at runtime, you can find more information on that here and here.

There were a ton of great questions from the audience so I’ll probably post an FAQ sometime next week. In the meantime don't forget to download VS2008 SP1, which allows you to use LINQ against SQL Server 2008.

Article: Sharpening Your Axis with Visual Basic 9 (Beth Massi)

VBTeam — Tue, 01 Jul 2008 03:30:00 GMT

In the July/August issue of CoDe Magazine there's an article I wrote with Avner Aharoni (the Program Manager on XML literals) called Sharpening Your Axis with Visual Basic 9. (They just opened up online access to even non-subscribers today!) I highly recommend this article which shows you from the beginning how XML literals, embedded expressions and axis properties work in Visual Basic.

I start with the basic syntax and definitions and then walk through the XML to Schema tool (which has been added to VS2008 SP1) to enable XML IntelliSense, as well as show some practical examples of using these features with LINQ. Avner describes how IntelliSense works and discusses advanced scenarios with XML namespaces. We end with tips-and-tricks which get you thinking about using XML literals in other text generation/manipulation scenarios.

If you like this topic, so do I! Check out the XML topic feed from my blog for more resources.

Enjoy,
-Beth Massi, VS Community