The Visual Basic Team : Doug Rothaus

Testing Events for Nothing/Null (Doug Rothaus)

VBTeam — Fri, 25 Sep 2009 20:10:00 GMT

While helping some Windows API folks with some sample code this week, I stumbled upon...uh...I mean “carefully researched” an issue that you might find handy.

You may be aware that the RaiseEvent statement automatically checks to verify if an event handler exists before raising the event. If the event is Nothing, then there’s no event handler and RaiseEvent terminates. If the event is not Nothing, then RaiseEvent triggers the event.

However, what if you want to follow a different code path if the event is Nothing? Unfortunately, the RaiseEvent statement doesn’t return a value that could indicate whether the event was fired. So, what’s a developer to do?

The answer? When the VB compiler sets up your event, it creates a private variable for the event in the form of <event name>Event. So, if I set up an event named TriggerMe, the VB compiler creates an event variable named TriggerMeEvent. You can test this variable for Nothing. It’s as simple as that! (Note: You won't see this variable using Intellisense, but you can find it when debugging or through reflection.)

Here’s a quick example:

Public Event SolutionFound As EventHandler

Private Sub OnSolutionFound()

If SolutionFoundEvent IsNot Nothing Then

RaiseEvent SolutionFound(Me, New EventArgs())

Else

' No event handler has been set.

MsgBox("There is no event handler. That makes me sad.")

End If

End Sub

Implicit Line Continuation (Kathleen McGrath)

VBTeam — Fri, 19 Jun 2009 23:32:53 GMT

In the second part of my interview with Doug Rothaus, he describes the new implicit line continuation feature in Visual Basic 2010. Learn about the most common scenarios that no longer require the underscore character (_) in the topic, Statements in Visual Basic.

See the Video: implicit Line Continuation

--Kathleen McGrath
http://blogs.msdn.com/kathleen

Auto-Implemented Properties (Kathleen McGrath)

VBTeam — Sat, 13 Jun 2009 00:46:04 GMT

In this interview, Doug Rothaus, a programming writer on the Visual Studio User Education team, describes the auto-implemented properties in Visual Basic 2010. He also demonstrates some of the code examples in his Help topic: Auto-Implemented Properties.

See the Video: Auto-Implement Properties.

--Kathleen

Community Interview with Doug Rothaus (Beth Massi)

VBTeam — Tue, 11 Nov 2008 19:00:03 GMT

This past month we've been posting interviews with the team from our Italian Visual Basic MVP Alessandro Del Sole. This time we have Doug Rothaus, a writer on the documentation side. Doug has blogged up an XML cookbook here on the team blog with a bunch of "recipes" on how to use different features of XML Literals and LINQ to XML in Visual Basic.

Check out the Visual Basic Team page for pictures and bios and visit the home page of the Visual Basic Developer Center for a link to all these interviews as well.

Here's the interview with Doug:

1. Nice to meet you Doug! Let’s begin by asking a simple question: where are you from?

I live in Woodinville, in Washington State. It’s about 6 miles (10 kilometers) from the main Microsoft campus in Redmond. I grew up in Washington, so it’s nice to work so close to home.

2. We all know that you’re a Visual Basic Team member, but could we know something more about your role inside the Team?

My official title is “Programmer/Writer”. I write reference, samples, and so on that you read in the product documentation. I feel very strongly about getting useful documentation out to the community and customers. If we don’t document it, how are you going to use it?

3. What’s your favorite Visual Basic feature regarding the language and/or the IDE?

Being a “data guy” from way back, I love LINQ. To be more specific, though, I love the XML Literals and XML Axis properties that come with VB and LINQ to XML. Most of the source data that I work with is stored in XML and XML literals make my life much easier.

4. How long have you been working for Microsoft and what was your occupation before joining the VB Team?

I have worked for Microsoft for almost eleven years. I started in Developer Support answering questions and troubleshooting problems over the phone, by e-mail, and in chat sessions for customers working with ASP, ADO, and Visual Interdev. For the last seven years I have been writing documentation and samples for ADO.NET, ASP.NET/Visual Web Developer, and for the last (almost) two years, Visual Basic and Visual Studio.

Before Microsoft, I worked as an application developer, security analyst, and instructor for a large aerospace company in the Northwest US that you may have heard of.

5. Why do you think VB is such a great language?

I love that VB serves all developers well from the novice to the expert. I think one reason for this is the way VB is descriptive in much of the language. For example, “NotInheritable” is more descriptive than “sealed”.

6. Have you ever been to Italy?

I did take a trip to Italy (and other European countries) when I was seventeen years old. I visited Florence, Venice, Pisa, Rome, Naples, Pompeii, and Sorrento. I loved Sorrento. Someday I plan on visiting there again. Of course, everywhere I went in Italy the food was delicious. (My friends tell me I describe every place I’ve been to in terms of food)

7. Would you like to tell us something about your life outside the office (how do you like to spend your free time, what do you like to do when/if you go out in the evening or when you’re at home and so on)?

Most of my time is spent with my wife and three children. I also play/sing quite a bit of music in my free time. I have a small home studio and a collection of instruments (2 electric basses, four guitars, one mandolin, one keyboard/workstation, congas/percussion). My other hobby is motorcycles. I ride them and race them at the track. I’m a MotoGP and World Superbike fan as well. Have they heard of Valentino Rossi in Italy? :-)

8. Who is your favorite musician?

I have to pick one? Out of a very long list, I will submit Mark King (of Level 42). Awesome bass player—and he flawlessly sings lines counter to what he’s playing.

9. What’s your favorite food?

Pizza. It contains all of the four necessary food groups!

Thank you very much for taking time to answer these questions and telling us more about you!

VB XML Cookbook, Recipe 6: Writing an XSLT Transform in VB (Doug Rothaus)

VBTeam — Tue, 07 Oct 2008 01:25:00 GMT

Most XSLT programmers are familiar with this XSLT transform to copy an XML file.

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

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:output method="xml" indent="yes"/>

<xsl:template match="@* | node()">

<xsl:copy>

<xsl:apply-templates select="@* | node()"/>

</xsl:copy>

</xsl:template>

</xsl:stylesheet>

This XSLT is commonly used for identity transforms as it allows you to copy an entire XML document and “touch” each XML node and attribute. If you add a matching template, then you can transform just that attribute or node that has a match in place. Unmatched nodes and attributes are simply copied.

We can also do this in Visual Basic with XML Literals (including LINQ to XML and XML Axis Properties). Our VB code will allow us to “touch” each node or element by recursively navigating through an XML document based on the following pseudo-code:

Starting with the root element, perform the following whenever you encounter a node

If the node is an element

If the element has attributes, transform or copy each attribute

If the element has child nodes, transform or copy each node

If the node is text, transform or copy the text

If the node is CData, transform or copy the CData

If the node is a comment, transform or copy the comment

If the node is a processing instruction, transform or copy the processing instruction

For this cookbook entry, we’ll create an abstract (MustInherit) base class that performs this pseudo-coded recursive navigation of an XML document. We can then create a class that inherits from that base class to perform specific transforms. First, we’ll create the abstract class and the “starting point,” a function called Transform that takes the XML document (XDocument) to be transformed as input and returns the transformed document.

Public MustInherit Class VBXmlTransform

Public Overridable Function Transform(ByVal xmlDoc As XDocument) As XDocument

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

<%= ProcessElement(xmlDoc.Root) %>

End Function

End Class

Next, we add the logic that is called for each XML node (XNode) encountered. This includes elements, text, CData, and so on. Our code needs to determine the type of XML node and call the related function to transform or copy the node type and return the result, which is either a copied or transformed node. This method is called ProcessNode and is shown here.

Public Overridable Function ProcessNode(ByVal xmlNode As XNode) As XNode

' This method ignores DTD (XDocumentType) content.

Dim nodeType = xmlNode.GetType()

' Because XCData inherits from XText, check for the XCData type before checking

' for XText.

If nodeType Is GetType(XCData) Then Return ProcessCData(xmlNode)

If nodeType Is GetType(XText) Then Return ProcessText(xmlNode)

If nodeType Is GetType(XElement) Then Return ProcessElement(xmlNode)

If nodeType Is GetType(XComment) Then Return ProcessComment(xmlNode)

If nodeType Is GetType(XProcessingInstruction) Then Return _

ProcessProcessingInstruction(xmlNode)

Return xmlNode

End Function

Next, we can add the strongly-typed functions that process each of the node types as well as attributes. The function to process an element is unique, so we’ll leave that out for now and cover that next. The functions to process the other node types and attributes are rather simple. Because the default behavior of the base class is to simply copy a document, each function just returns the input value. The reason that we have created this code is to provide strongly-typed functions that we can override in our inheriting class with specific behavior. Here are the strongly-typed functions (without the ProcessElement function).

Public Overridable Function ProcessAttribute(ByVal xmlAttribute As XAttribute) As XAttribute

Return xmlAttribute

End Function

Public Overridable Function ProcessCData(ByVal xmlCData As XCData) As XCData

Return xmlCData

End Function

Public Overridable Function ProcessText(ByVal xmlText As XText) As XText

Return xmlText

End Function

Protected Overridable Function ProcessComment(ByVal xmlComment As XComment) As XComment

Return xmlComment

End Function

Public Overridable Function ProcessProcessingInstruction( _

ByVal pi As XProcessingInstruction) As XProcessingInstruction

Return pi

End Function

Now let’s look at the ProcessElement function. Processing elements is unique because elements can have both attributes as well as child nodes. Those attributes and child nodes need to be transformed or copied as well, so we must provide code that calls the ProcessAttribute function for each attribute, and calls the ProcessNode function for each child node. We’ll encapsulate this code in a function called CopyElement. The ProcessElement function will look like the other strongly-typed functions, except that it will return a call to the CopyElement function instead of just the input element. The CopyElement function uses XML Literals, embedded expressions, and LINQ to XML to create the copy of the XML element as shown here.

Public Overridable Function ProcessElement(ByVal xmlElement As XElement) As XElement

Return CopyElement(xmlElement)

End Function

Public Overridable Function CopyElement(ByVal xmlElement As XElement) As XElement

Return <<%= xmlElement.Name %>

<%= From attribute In xmlElement.Attributes() _

Select ProcessAttribute(attribute) %>>

<%= From node In xmlElement.Nodes() _

Select ProcessNode(node) %>

</>

End Function

That’s the extent of our abstract class. Now we can make use of it for very simple or very complex identity transforms. Let’s see an example.

Creating a Transform

Our example will use the same source XML file that was posted with the Recipe 1 post. It has mixed content from several namespaces, providing a nice testing sample. The mixed content in our sample file is found in the <AdditionalContactInfo> element identified in the http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo schema. In the additional contact info, there can be address information, which consists of three different element names: homePostalAddress, physicalDeliveryOfficeName, and registeredAddress. The addressType type has a required element named PostalCode. We can create a simple class to transform the <PostalCode> element and rename it to <ZipCode>.

First, we need to import the different schemas found in our source document. The abstract VBXmlTransform class does not need to know about these schemas, which are specific to the source document, but our inheriting class does.

Imports <xmlns="http://SampleSchema/AWContacts">

Imports <xmlns:aci="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo">

Imports <xmlns:act="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">

Imports <xmlns:crm="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactRecord">

Next, we create a class that inherits the VBXmlTransform class. In this class, called AWTransform, we override the base class and add the code to perform whatever transform we want. In this case, we’ll override ProcessElement, because we’re searching for any element named PostalCode. If we find that element, we’ll transform it. If not, we’ll defer to the ProcessElement method of the base class.

Class AWTransform

Inherits VBXmlTransform

' Rename <act:PostalCode> to <ZipCode>.

' Create an XName object to use for comparisons. This will perform better than comparing

' xmlElement.Name.LocalName to a string.

Private postalCodeXName As XName = _

XName.Get("PostalCode", _

"http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes")

Public Overrides Function ProcessElement(ByVal xmlElement As XElement) As XElement

Select Case xmlElement.Name

Case postalCodeXName

Return TransformPostalCode(xmlElement)

Case Else

Return MyBase.ProcessElement(xmlElement)

End Select

Return Nothing

End Function

Public Function TransformPostalCode(ByVal postalCodeElement As XElement) As XElement

Return <ZipCode><%= postalCodeElement.Value %></ZipCode>

End Function

End Class

Transforming the Document

To call this transform, we create an instance of our inheriting class, AWTransform, and then pass the source XML document to the Transform method as shown here:

Dim xmlPath = My.Application.Info.DirectoryPath & "\..\..\AWContacts.xml"

Dim savePath = My.Application.Info.DirectoryPath & "\..\..\TransformSave.xml"

Dim xmlDoc = XDocument.Load(xmlPath)

Dim transform As New AWTransform()

Dim transformedDoc = transform.Transform(xmlDoc)

transformedDoc.Save(savePath)

Other Examples

Let’s look at some other examples we could add to our AWTransform class.

The following code example shows how we can transform the content of an existing attribute. If the transform finds an attribute named date, it transforms the date value into the general date and time format.

Private dateXName As XName = XName.Get("date")

Public Overrides Function ProcessAttribute(ByVal xmlAttribute As XAttribute) As XAttribute

If xmlAttribute.Name.Equals(dateXName) Then Return TransformDateAttribute(xmlAttribute)

Return MyBase.ProcessAttribute(xmlAttribute)

End Function

Public Function TransformDateAttribute(ByVal dateAttribute As XAttribute) As XAttribute

Dim dateValue As New DateTime()

If DateTime.TryParse(dateAttribute.Value, dateValue) Then _

dateAttribute.Value = dateValue.ToString("G")

Return dateAttribute

End Function

The following code example shows how we can remove data from the transformed document. If the transform finds a CData section, it returns Nothing so that the CData section is not included in the resulting document.

Public Overrides Function ProcessCData(ByVal xmlCData As XCData) As XCData

Return Nothing

End Function

VB XML Cookbook, Recipe 5: The “Halloween” Problem (Doug Rothaus)

VBTeam — Thu, 08 May 2008 19:47:00 GMT

In the last two XML cookbook entries, we talked about the technique of using the ReplaceWith method to perform an identity transform. While this technique may meet your needs, it can introduce a problem in your code commonly referred to as the “Halloween” problem. Let’s take a look at what the problem is, and how to solve it. (For details on the “Halloween” problem and recommended solutions, see this topic in the documentation.)

The “Halloween” problem describes a scenario where you have a set of data that is updated in some fashion while enumerating through that data set. As a result, you can encounter a null reference exception, or worse, you can end up modifying the wrong data. For example, consider this snippet of code based on the previous two XML cookbook recipe posts:

Private Sub Recipe5(ByVal xmlPath As String)

Dim xmlDoc = XDocument.Load(xmlPath)

Dim info = xmlDoc.<Contacts>.<Contact>.<aci:AdditionalContactInfo>

' Replace e-mail address tags with mailto links.

For Each email In info...<act:eMail>

TransformEmail(email)

End Sub

Private Sub TransformEmail(ByVal email As XElement)

Dim emailHtml = <div class="Email">

<a href=<%= "mailto:" & email.<act:eMailAddress>.Value %>>

<%= email.<act:eMailAddress>.Value %>

</a> 

</div>

email.ReplaceWith(emailHtml)

End Sub

If you ran this code, you would encounter a null reference error as shown here:

The reason for the error is that the For…Each loop is looping through the results of a query for <eMail> elements. During the first call to the TransformEmail function, the <eMail> element is replaced with HTML. As a result, the query references an XML element that no longer exists.

How do you solve the problem then? There are a couple of solutions. The first is what you may have noticed in the previous cookbook entries: return the query results as a List using the ToList method. That is, the following code:

For Each email In info...<act:eMail>

Is changed to…

For Each email In info...<act:eMail>.ToList()

Returning a List means that we’re no longer dealing with a query. Hence, an update that would affect the query, such as replacing an XML element with HTML, does not affect the List.

The other common solution to the “Halloween” problem is to write your code so that it does not modify the original document. Instead, you project your results into a new XML document. In the next cookbook post, we’ll look at an example of how to do this.

VB XML Cookbook, Recipe 4: Get Inner XML from the Nodes Property (Doug Rothaus)

VBTeam — Fri, 02 May 2008 02:50:00 GMT

Recipe 3 showed one way to work with mixed XML content using the XML Descendant axis property and the ReplaceWith method. This is one way to do an identity transform and we’ll look at another method in a later post. There is a key capability not mentioned in Recipe 3 that you will need for fully-functioning identity transforms. That is the concept of copying the inner XML of an element. You get the inner XML of an element from the Nodes property.

Recipe 3 transformed e-mail objects from our AdventureWorks sample document into hyper-links in an HTML document and preserved the original formatting by performing an identity transform. To keep things simple in Recipe 3, however, I left out the fact that the schema for the <eMailAddress> element (found in the ContactTypes.xsd schema file) allows for both an <eMail> element that contains the e-mail address, and also a <SpecialInstructions> element for additional instructions such as phone numbers to use in place of an e-mail, when to call, and so on. The <SpecialInstructions> element can contain any of the other elements identified in ContactTypes.xsd. To include all of the information for an <eMailAddress> element, we must also include any special instructions. (Note: You can download the XML document and related schemas from the Recipe 1 post).

Transforming the <eMail> element from an e-mail address is simple because the <eMail> element contains only the e-mail address value. However, transforming the <SpecialInstructions> element is not as simple because the element value can contain sub- elements as well as values. If you embedded the Value of a <SpecialInstructions> element, you would get the text found within the element, but any XML found would be stripped out. This is also referred to as the inner text of an element.

If you’re familiar with the classes in the System.Xml namespace, you will immediately recognize this behavior. The solution is to embed the inner XML of the element rather than the inner text (the Value property). While the System.Xml classes expose both InnerText and InnerXml properties, LINQ to XML does not. Inner text is returned from the Value property, and inner XML is returned from the Nodes property. Why the difference? The InnerXml property returns a string of XML, which would have to be re-parsed into XML objects. The Nodes property returns a collection of LINQ to XML objects, which you can manipulate or embed as a whole into XML Literals making the Nodes property a powerful tool for transforming XML.

So, with all of this in mind, let’s look at both the Value (inner text) and Nodes (inner XML) properties in an example. Here we have a function (template), TransformEmail, that transforms the XML source into HTML. The e-mail address is retrieved using the Value property and also a call to the GetSpecialInstructions function to embed the HTML for any special instructions that may be included. The GetSpecialInstructions method returns HTML markup and the inner XML of the <SpecialInstructions> element as it can contain mixed markup including text, or other XML.

Private Sub TransformEmail(ByVal email As XElement)

Dim emailHtml = <div class="Email">

<a href=<%= "mailto:" & email.<act:eMailAddress>.Value %>>

<%= email.<act:eMailAddress>.Value %>

</a> 

<%= GetSpecialInstructions(email.<act:SpecialInstructions>) %>

</div>

email.ReplaceWith(emailHtml)

End Sub

Private Function GetSpecialInstructions( _

ByVal instructions As IEnumerable(Of XElement)) As IEnumerable(Of XElement)

If instructions IsNot Nothing Then _

Return From instruction In instructions _

Select <span class="SpecialInstructions">

<%= instruction.Nodes %>

</span>

Return Nothing

End Function

VB XML Cookbook, Recipe 3: Identity Transforms (Doug Rothaus)

VBTeam — Fri, 25 Apr 2008 21:19:00 GMT

An identity transform in XSLT does just what the name implies: replace the identity of an element or attribute with a new identity. Identity transforms are especially critical when dealing with XML markup that is less rigid in its structure. Consider a documentation structure for news articles. Whenever a title is referred to within an article, it is highlighted with italics. However, the XML schema for the article does not specify italics, it specifies that the term is some type of title so that different transforms can handle the term in their own fashion. When you transform XML such as this into a readable format, such as HTML, you need to preserve the structure of the text around the highlighted term so that the original intent remains intact. That is…

<Paragraph sequenceID=”1”>This week a remastered version of the movie <title type=”movie”>Raider’s of the Lost Ark</title> was released.</Paragraph>

becomes…

<p>This week a remastered version of the movie <i>Raider’s of the Lost Ark</i> was released.</p>

In a browser you see…

This week a remastered version of the movie Raider’s of the Lost Ark was released.

(Note: I have no idea if they are really releasing a remastered version of Raider’s of the Lost Ark, I just typed the first thing that popped into my head).

You can perform an identity transform using Visual Basic and XML Literals by combining XML Axis properties and the ReplaceWith method for LINQ to XML objects.

Let’s look at a more complete example. In the AdventureWorks contacts source document that we used in previous recipes (you can download the XML document and related schemas from the Recipe 1 post), there is an <AdditionalContactInfo> element that contains information about the contact such as phone numbers, shipping and billing addresses, and so on. To keep things simple, we’ll just look at the <eMail> element. The <eMail> element can show up in a number of places in the contents of the <AdditionalContactInfo> element. As a result, you can use the XML Descendant axis property discussed in Recipe 2 to retrieve all of the references to <eMail> elements. You can then iterate through the query results and call the ReplaceWith method for each <eMail> element and replace it with a new identity. For example:

Dim emails = (From email In _

xmlDoc.<Contacts>.<Contact>.<aci:AdditionalContactInfo>...<act:eMail>).ToList()

For Each email In emails

TransformEmail(email)

In this example, the output is HTML and the <eMail> element is replaced with an anchor element that specifies a mailto: link to the e-mail address. The previous code snippet passes the <eMail> XElement object to the function TransformEmail, which does the actual replacing.

Private Sub TransformEmail(ByVal email As XElement)

Dim emailHtml = <div class="Email">

<a href=<%= "mailto:" & email.<act:eMailAddress>.Value %>>

<%= email.<act:eMailAddress>.Value %>

</a>

</div>

email.ReplaceWith(emailHtml)

End Sub

A simple class that creates the HTML document using these samples is shown here.

Imports <xmlns="http://SampleSchema/AWContacts">

Imports <xmlns:aci="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo">

Imports <xmlns:act="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">

Public Class Recipe3

Public Function GetContactsHtml(ByVal xmlDoc As XDocument) As XElement

' Replace e-mail address tags with mailto links.

Dim emails = (From email In xmlDoc.<Contacts>.<Contact>.<aci:AdditionalContactInfo>...<act:eMail>).ToList()

For Each email In emails

TransformEmail(email)

' Create the HTML document

Return <html>

<body>

<%= From contact In xmlDoc.<Contacts>.<Contact> _

Select <tr>

<%= contact.<FirstName>.Value & " " & contact.<LastName>.Value %>

</td>

<%= contact.<aci:AdditionalContactInfo> %>

</td>

</tr> _

</table>

</body>

</html>

End Function

Private Sub TransformEmail(ByVal email As XElement)

Dim emailHtml = <div class="Email">

<a href=<%= "mailto:" & email.<act:eMailAddress>.Value %>>

<%= email.<act:eMailAddress>.Value %>

</a>

</div>

email.ReplaceWith(emailHtml)

End Sub

End Class

In XSLT, the same transform would look like the following:

<?xml version='1.0'?>

<xsl:stylesheet

version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:aw="http://SampleSchema/AWContacts"

xmlns:aci="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo"

xmlns:act="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">

<xsl:output method="html" indent="yes"/>

<xsl:template match="aw:Contacts">

<html>

<body>

<xsl:apply-templates select="aw:Contact" />

</table>

</body>

</html>

</xsl:template>

<xsl:template match="aw:Contact">

<tr>

<xsl:value-of select="aw:FirstName"/>

<xsl:text> </xsl:text>

<xsl:value-of select="aw:LastName"/>

</td>

<xsl:apply-templates select="aci:AdditionalContactInfo" />

</td>

</tr>

</xsl:template>

<xsl:template match="aci:AdditionalContactInfo">

<xsl:copy>

<xsl:apply-templates select="@* | node()" />

</xsl:copy>

</div>

</xsl:template>

<xsl:template match="act:eMail">

<a>

<xsl:attribute name="href">

<xsl:text>mailto:</xsl:text>

<xsl:value-of select="act:eMailAddress" />

</xsl:attribute>

<xsl:value-of select="act:eMailAddress" />

</a>

</div>

</xsl:template>

</xsl:stylesheet>

Grouping by Element Type

One thing that you can take advantage of in Visual Basic is the ability to group transforms by element type. For example, the ContactTypes.xsd file that we have been using in our AdventureWorks samples defines an address type, and e-mail type, and a phone number type. ContactTypes.xsd also identifies three different element names that are the address type and five different element names that are the phone number type. In XSLT, you would create a template for each address type and end up with three different templates for information that is, essentially, formatted the same. In Visual Basic, you can easily create a query for all different address or phone number elements and pass that to the same VB function, which acts as your XSLT template. For example:

Dim addresses = (From addr In info...<act:homePostalAddress>).Union( _

From addr In info...<act:physicalDeliveryOfficeName>).Union( _

From addr In info...<act:registeredAddress>).ToList()

For Each address In addresses

TransformAddress(address)

...

Private Sub TransformAddress(ByVal address As XElement)

Dim addressHtml = _

<%= address.<act:Street>.Value %><br/>

<%= address.<act:City>.Value & ", " %> 

<%= address.<act:StateProvince>.Value %> 

<%= address.<act:PostalCode>.Value %><br/>

<%= address.<act:CountryRegion>.Value %><br/>

<%= _

GetSpecialInstructions(address.<act:SpecialInstructions>.ToList()) %>

</div>

address.ReplaceWith(addressHtml)

End Sub

VB XML Cookbook, Recipe 2: Descendants and Ancestors (Doug Rothaus)

VBTeam — Thu, 20 Mar 2008 02:23:00 GMT

This entry in the cookbook shows how you can access descendant and ancestor elements in an XML document using Visual Basic, XML Axis properties, and LINQ to XML objects.

Descendants

Visual Basic provides XML Axis properties that enable you to easily refer to child nodes and attributes. As is often the case with XML, you may need to reference sub-elements that show up in different levels of the XML hierarchy. In that case, you can use the XML Descendant axis property.

The XML Descendant axis property is identified using three periods followed by the XML element that you want to refer to. For example, in the AdventureWorks contacts source document that we used in Recipe 1 (you can download the XML document and related schemas from the Recipe 1 post), there is an <AdditionalContactInfo> element that contains information about the contact such as phone numbers, shipping and billing addresses, and so on. The phone numbers in the content of the <AdditionalContactInfo> element can show up anywhere within the value of the element. As a result, you would need to use the XML Descendant axis property to refer to the phone number elements. For example:

Dim xmlDoc = XDocument.Load("AWContacts.xml")

' Return all descendant <telephoneNumber> elements

Dim telephoneNumbers = _

xmlDoc.<Contacts>.<Contact>.<aci:AdditionalContactInfo>...<act:telephoneNumber>

The XML descendant axis property returns a collection of all of the matching elements “down” the XML hierarchy. Let’s look at a more complete example. The following Function returns a list of contact names and phone numbers using the XML Descendant axis property.

Imports <xmlns="http://SampleSchema/AWContacts">

Imports <xmlns:s="sample-output">

Imports <xmlns:aci="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo">

Imports <xmlns:act="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">

Public Class Recipe2

Public Function GetPhoneNumbers(ByVal xmlDoc As XDocument) As XElement

Return <s:ContactPhoneNumbers>

<%= From contact In xmlDoc.<Contacts>.<Contact> _

Where contact.<aci:AdditionalContactInfo>...<act:telephoneNumber>.<act:number>.Count > 0 _

Select <s:Contact>

<s:Name><%= contact.<FirstName>.Value & " " & _

contact.<LastName>.Value %></s:Name>

<s:PhoneNumbers>

<%= From number In _

contact.<aci:AdditionalContactInfo>...<act:telephoneNumber>.<act:number> _

Select <s:Number><%= number.Value %></s:Number> _

</s:PhoneNumbers>

</s:Contact> _

</s:ContactPhoneNumbers>

End Function

End Class

In XSLT, the same transform would look like the following:

<?xml version='1.0'?>

<xsl:stylesheet

version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:aw="http://SampleSchema/AWContacts"

xmlns:s="sample-output"

xmlns:aci="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo"

xmlns:crm="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactRecord"

xmlns:act="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">

<xsl:output method="xml" indent="yes" />

<xsl:template match="aw:Contacts">

<s:ContactPhoneNumbers>

<xsl:apply-templates select="aw:Contact" />

</s:ContactPhoneNumbers>

</xsl:template>

<xsl:template match="aw:Contact">

<xsl:if test="count(aci:AdditionalContactInfo//act:telephoneNumber/act:number) > 0">

<s:Contact>

<s:Name>

<xsl:value-of select="aw:FirstName"/>

<xsl:text> </xsl:text>

<xsl:value-of select="aw:LastName"/>

</s:Name>

<xsl:apply-templates select="aci:AdditionalContactInfo" />

</s:Contact>

</xsl:if>

</xsl:template>

<xsl:template match="aci:AdditionalContactInfo">

<s:PhoneNumbers>

<xsl:for-each select=".//act:telephoneNumber/act:number">

<s:Number>

<xsl:value-of select="."/>

</s:Number>

</xsl:for-each>

</s:PhoneNumbers>

</xsl:template>

</xsl:stylesheet>

It is important to note that you should not use the XML Descendant axis property when the location of a sub-element is always the same. Your code will perform much better if you use the XML Child axis property to refer to a specific location in the XML hierarchy than if you use the XML Descendant axis property to search the entire XML hierarchy for matches.

Ancestors

XML Axis properties make searching “down” the XML hierarchy quick and easy. However, what if you need to search “up” the XML hierarchy? In that case, you can use the Ancestors method of the XNode class. Because XML literals expose the functionality of LINQ to XML classes, you can use the additional capabilities of those LINQ to XML classes when the need arises.

The Ancestors() method searches “up” the XML hierarchy for an XML element that matches the supplied element name. The element name that you supply to the Ancestors method, however, must include the XML namespace for the element as well. You can use the GetXmlNamespace operator to return an XML namespace based on a supplied XML prefix. For the default XML namespace, call the GetXmlNamespace operator and don’t pass it a prefix. If you are searching for an element in the same XML namespace as an element that you already have a reference to, you can access the XML namespace of the referenced element using the Name.Namespace property.

For example, the following sample takes a list of <telephoneNumber> elements (actually, any element of type phoneNumberType as identified in the ContactTypes.xsd file) from the AdventureWorks contacts sample document and returns a list of the phone numbers as well as the name of the related contact for the phone number. The sample calls the Ancestors() method to search up the XML hierarchy for the owning <Contact> node.

Imports <xmlns="http://SampleSchema/AWContacts">

Imports <xmlns:s="sample-output">

Imports <xmlns:aci="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo">

Imports <xmlns:act="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">

Public Class Recipe2

Public Function GetPhoneList(ByVal numberList As IEnumerable(Of XElement)) As XElement

Return <s:PhoneNumberList>

<%= From number In numberList _

Let contact = number.Ancestors(GetXmlNamespace() + "Contact") _

Select <s:PhoneNumber>

<s:Number type=<%= number.Name.LocalName %>>

<%= number.<act:number>.Value %>

</s:Number>

<s:Owner><%= contact.<FirstName>.Value & " " & _

contact.<LastName>.Value %></s:Owner>

</s:PhoneNumber> _

</s:PhoneNumberList>

End Function

End Class

In XSLT, the same transform would look similar to the following:

<?xml version='1.0'?>

<xsl:stylesheet

version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:aw="http://SampleSchema/AWContacts"

xmlns:s="sample-output"

xmlns:aci="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo"

xmlns:crm="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactRecord"

xmlns:act="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">

<xsl:output method="xml" indent="yes" />

<xsl:template match="aw:Contacts">

<s:PhoneNumberList>

<xsl:apply-templates select="aw:Contact//act:telephoneNumber" />

</s:PhoneNumberList>

</xsl:template>

<xsl:template match="aw:Contact//act:telephoneNumber">

<s:PhoneNumber>

<s:Number>

<xsl:attribute name="type">

<xsl:value-of select="name()" />

</xsl:attribute>

<xsl:value-of select="./act:number"/>

</s:Number>

<s:Owner>

<xsl:value-of select="ancestor::aw:Contact/aw:FirstName"/>

<xsl:text> </xsl:text>

<xsl:value-of select="ancestor::aw:Contact/aw:LastName"/>

</s:Owner>

</s:PhoneNumber>

</xsl:template>

</xsl:stylesheet>

VB XML Cookbook, Recipe 1: XML Transformations using XML Literals (Doug Rothaus)

VBTeam — Thu, 21 Feb 2008 23:22:00 GMT

I was working on a blog entry about replacing XSLT transforms with Visual Basic XML Literals. As the entry progressed, I noticed that it was really, really long. So, Avner Aharoni and I talked things over and we decided to break it up into multiple entries and start a series, much like the LINQ Cookbook that was started a few months back.

Introducing the VB XML Cookbook. We’ll use these entries to show quick and easy solutions using XML Literals in Visual Basic. In many cases we’ll reference XSLT and XPath where there’s a direct (or very close) replacement of functionality. You’ll find that consuming and transforming XML is quick and easy using XML Literals, XML Axis Properties, and LINQ to XML—all of which are available starting with Visual Basic 2008.

In this first entry, we’ll show how you can perform simple XML transformations using XML Literals and LINQ. Each sample uses an embedded expression that returns a collection of XML Literals from a LINQ query or another source, such as a property or function that returns a collection of XML Literals. You will see how you can replace an entire XSLT transform with just a few lines of Visual Basic code.

Let’s look at our first example. Attached to this blog entry is an XML file that contains a portion of the Contacts from the AdventureWorks sample database for SQL Server in an XML document (AWContacts.xml). Each <Contact> element has an <EmailAddress> sub-element. The following code creates a new XML document with just the e-mail addresses from the source document.

Imports <xmlns="http://SampleSchema/AWContacts">

Public Class XMLCookbook

Private Sub Recipe1()

Dim xmlDoc = XDocument.Load("AWContacts.xml")

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

<%= xmlDoc.<Contacts>.<Contact>.<EmailAddress> %>

</EmailAddresses>

emailDoc.Save("EmailAddresses.xml")

End Sub

End Class

This would take considerably more effort using an XSLT transform. Here, you simply use Visual Basic to create a “template” function, and use XML Literals to load and save the XML, as well as create the new XML document. The XML Child Axis property references the collection of <EmailAddress> sub-elements. In place of the <xsl:copy-of> element, you use an embedded expression to add the collection of elements to the new document. In the end, you’ve transformed the document without XSLT or XPath. Let’s take a look at what the XSLT (and Visual Basic Code) would look like for the same sample.

Recipe1.xslt

<?xml version='1.0'?>

<xsl:stylesheet

version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:aw="http://SampleSchema/AWContacts"

xmlns:aci="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo"

xmlns:crm="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactRecord"

xmlns:act="http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">

<xsl:output method="xml" indent="yes"/>

<xsl:template match="aw:Contacts">

<xsl:copy-of select="aw:Contact/aw:EmailAddress"/>

</EmailAddresses>

</xsl:template>

</xsl:stylesheet>

Recipe1_XSLT Visual Basic Code

Public Class XMLCookbook

Sub Recipe1_XSLT()

Dim xslTransform As New System.Xml.Xsl.XslCompiledTransform

xslTransform.Load("recipe1.xslt")

Dim reader = Xml.XmlReader.Create("AWContacts.xml")

Dim sw As New System.IO.StreamWriter("Recipe1.xml")

Dim writer = Xml.XmlWriter.Create(sw)

xslTransform.Transform(reader, writer)

sw.Close()

End Sub

End Class

The XSLT version turns out to be about twice the amount of code and, to be honest, took me much longer to create than the VB version. Notice that the XML namespace support in Visual Basic is simpler than XSLT (1.0) as I can define a default XML namespace for XML elements that do not have an XML namespace identified.

Another important thing to mention is that part of the productivity gain comes from the Intellisense support provided with XML Literals in Visual Basic. By adding the schema files that are also attached to this blog entry and then importing the namespaces for the schemas, I get word completion lists for XML child and descendant elements as well as attributes. For more information, see XML Intellisense in Visual Basic.

Using LINQ

To go further, you can add query functionality to your transform using LINQ. In XSLT, you might use the <xsl:for-each> element to loop through results and the <xsl:if> element to test for a particular condition. Using LINQ, you can accomplish this rather easily.

For example, in our source document, each <Contact> element has an <EmailPromotion> sub-element that identifies whether the contact would like to receive promotion e-mails from the company. The following code creates the same document, but only containing e-mail addresses of contacts that want to receive e-mail promotions.

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

<%= From contact In xmlDoc.<Contacts>.<Contact> _

Where contact.<EmailPromotion>.Value > 0 _

Select contact.<EmailAddress> %>

</EmailPromotionList>

Comparable XSLT code would look like the following.

<xsl:template match="aw:Contacts">

<xsl:for-each select="aw:Contact">

<xsl:if test="aw:EmailPromotion > 0">

<xsl:copy-of select="aw:EmailAddress"/>

</xsl:if>

</xsl:for-each>

</EmailAddresses>

</xsl:template>

For the last example, we’ll go one step further and transform the contents of the source XML document to a new format. You can accomplish this by having a LINQ query return a collection of XML Literals. You can use embedded expressions to copy values from the source document into elements and attributes of the new XML Literal. For this example, the transformed document will rename the <EmailAddress> element to <Email>, and include the value of the <EmailPromotion> element as an attribute of the transformed <Email> element.

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

<%= From contact In xmlDoc.<Contacts>.<Contact> _

Where contact.<EmailPromotion>.Value > 0 _

Select <Email

promotion=<%= contact.<EmailPromotion>.Value %>>

<%= contact.<EmailAddress>.Value %>

</Email> %>

</EmailPromotionList>

Comparable XSLT code would look like the following.

<xsl:template match="aw:Contacts">

<xsl:for-each select="aw:Contact">

<xsl:if test="aw:EmailPromotion > 0">

<Email>

<xsl:attribute name="promotion">

<xsl:value-of select="aw:EmailPromotion"/>

</xsl:attribute>

<xsl:value-of select="aw:EmailAddress"/>

</Email>

</xsl:if>

</xsl:for-each>

</EmailPromotionList>

</xsl:template>

To sum things up, we’ve seen how Visual Basic, XML Literals and LINQ can be used in place of the <xsl:copy-of>, <xsl:for-each>, <xsl:template>, <xsl:if>, <xsl:value-of>, and <xsl:attribute> elements as well as using XML Axis Properties in place of XPath to create a powerful, yet simple tool for XML transformations.

Stay tuned for more...

LINQ Cookbook, Recipe 12: Calculate the Standard Deviation (Doug Rothaus)

VBTeam — Wed, 19 Dec 2007 02:09:00 GMT

Ingredients:

· Visual Studio 2008 (Beta2 or Higher)

Categories: LINQ to Objects

Introduction:

LINQ Cookbook, Recipe 11 showed how you can use LINQ queries to perform calculations on sets of data using a set of standard aggregate functions such as Average, and Sum. In this recipe, you will learn how to add an extension method so that you can include your own custom aggregate function in a LINQ query.

This recipe adds two extension methods: StDev (standard deviation) and StDevP (standard deviation for the entire population). Because the extension methods are added to the IEnumerable(Of T) type, you can use the custom aggregate functions in the Into clause of an Aggregate, Group By, or Group Join query clause. Notice that there are two overloads of each extension method: one that takes input values of type IEnumerable(Of Double), and another that takes input values of type IEnumerable(Of T). This enables you to call the custom aggregate functions whether your LINQ query returns a collection of type Double, or any other numeric type. The overload that takes input values of type IEnumerable(Of T) uses the Func(Of T, Double) lambda expression to project a the numeric values as the corresponding values of type Double before calculating the standard deviation. When calculating the standard deviation for values of type Double, you can simply call the StDev() or StDevP() overloads. When calculating the standard deviation for values of numeric types other than Double, you need to pass the value to the StDev(value) or StDevP(value) overloads to ensure that the value is projected as type Double.

Instructions:

· Create a Console Application.

· After the End Module statement of the default Module1 module, add the following class, which contains both the StDev and StDevP functions.

Class StatisticalFunctions

Public Shared Function StDev(ByVal values As Double()) As Double

Return CalculateStDev(values, False)

End Function

Public Shared Function StDevP(ByVal values As Double()) As Double

Return CalculateStDev(values, True)

End Function

Private Shared Function CalculateStDev(ByVal values As Double(), _

ByVal entirePopulation As Boolean) As Double

Dim count As Integer = 0

Dim var As Double = 0

Dim prec As Double = 0

Dim dSum As Double = 0

Dim sqrSum As Double = 0

Dim adjustment As Integer = 1

If entirePopulation Then adjustment = 0

For Each val As Double In values

dSum += val

sqrSum += val * val

count += 1

If count > 1 Then

var = count * sqrSum - (dSum * dSum)

prec = var / (dSum * dSum)

' Double is only guaranteed for 15 digits. A difference

' with a result less than 0.000000000000001 will be considered zero.

If prec < 0.000000000000001 OrElse var < 0 Then

var = 0

Else

var = var / (count * (count - adjustment))

End If

Return Math.Sqrt(var)

End If

Return Nothing

End Function

End Class

· After the StatisticalFunctions class, add the following module to add the extension methods to IEnumerable to calculate the standard deviation for both IEnumerable(Of Double) and IEnumerable(Of T).

Module StatisticalAggregates

' Calculate the stdev value for a collection of type Double.

<Extension()> _

Function StDev(ByVal stDevAggregate As IEnumerable(Of Double)) As Double

Return StatisticalFunctions.StDev(stDevAggregate.ToArray())

End Function

' Project the collection of generic items as type Double and calculate the stdev value.

<Extension()> _

Function StDev(Of T)(ByVal stDevAggregate As IEnumerable(Of T), _

ByVal selector As Func(Of T, Double)) As Double

Dim values = (From element In stDevAggregate Select selector(element)).ToArray()

Return StatisticalFunctions.StDev(values)

End Function

' Calculate the stdevp value for a collection of type Double.

<Extension()> _

Function StDevP(ByVal stDevAggregate As IEnumerable(Of Double)) As Double

Return StatisticalFunctions.StDevP(stDevAggregate.ToArray())

End Function

' Project the collection of generic items as type Double and calculate the stdevp value.

<Extension()> _

Function StDevP(Of T)(ByVal stDevAggregate As IEnumerable(Of T), _

ByVal selector As Func(Of T, Double)) As Double

Dim values = (From element In stDevAggregate Select selector(element)).ToArray()

Return StatisticalFunctions.StDevP(values)

End Function

End Module

· In Sub Main of the default Module1 module, add the following code to calculate and display some sample standard deviation values:

Sub Main()

Dim numbers1 = New Double() {5.4, 2.3, 8.9, 9.456}

Dim numbers2 = New Integer() {12, 0, 3, 6, 8, 9}

Dim q1 = Aggregate num In numbers1 Into StDev()

Dim q2 = Aggregate num In numbers2 Into StDev(num)

Dim q3 = Aggregate num In numbers1 Into StDevP()

Dim q4 = Aggregate num In numbers2 Into StDevP(num)

Console.WriteLine(q1)

Console.WriteLine(q2)

Console.WriteLine(q3)

Console.WriteLine(q4)

End Sub

Press F5 to see the code run.

LINQ Cookbook, Recipe 11: Desktop Search Statistics (Doug Rothaus)

VBTeam — Fri, 14 Dec 2007 02:53:00 GMT

Ingredients:

· Visual Studio 2008 (Beta2 or Higher)

Categories: LINQ to DataSet

Introduction:

You can use aggregate functions in LINQ queries to perform calculations on sets of data. Visual Basic includes a set of standard aggregate functions for LINQ queries: All, Any, Average, Count, LongCount, Max, Min, Sum. These functions are documented in the reference topics for the Aggregate Clause. You can use aggregate functions as part of the Aggregate clause for an entire set of data, or as part of the Into portion of a Group By or Group Join clause, where the aggregate function will be applied to each group of data as shown in the following example.

Dim customersByCountry = From cust In customers _

Order By cust.City _

Group By CountryName = cust.Country _

Into RegionalCustomers = Group, Count() _

Order By CountryName

In this recipe, you will create a Windows Forms application that queries for items indexed using Windows Desktop Search. The application returns the total count and total kilobytes for items that are documents, e-mails, or images. The application uses the OLEDB provider for Windows Desktop Search to retrieve item information and LINQ to DataSet to group the item information and apply the Count and Sum aggregate functions.

Instructions:

· Create a Windows Forms Application.

· From the Toolbox, drag a ListBox control, and a DataGridView control onto the form. Resize the form and controls as needed.

· Select the ListBox control. In the Properties page, locate the Items property and click the ellipsis (...) button to add items to the ListBox. Add the following three items and click OK:

o Document

o E-mail

o Image

· Double-click the ListBox control to edit the SelectedIndexChanged event and add the following code:

' Connect to the Desktop Search OLEDB provider. Return a list of items and the size

' of each item where the item type contains the search string selected from the ListBox.

Dim conn As New OleDbConnection("Provider=Search.CollatorDSO.1;" & _

"Persist Security Info=False;" & _

"Extended Properties='Application=Windows'")

Dim cmd As New OleDbCommand("SELECT System.ItemTypeText, System.Size " & _

"FROM SystemIndex WHERE " & _

"CONTAINS(System.ItemTypeText, '""" & ListBox1.SelectedItem & """')", conn)

Dim adapter As New OleDbDataAdapter(cmd)

Dim ds As New DataSet

adapter.Fill(ds, "SearchResults")

' Group the results from the Desktop Search. Count the number of items in each

' group and sum the size of the items in each group.

Dim query = From row In ds.Tables("SearchResults") _

Let ItemTypeText = row("System.ItemTypeText"), _

Size = CInt(row("System.Size")) _

Group By ItemTypeText Into TotalItems = Count(), Bytes = Sum(Size) _

Select Type = ItemTypeText, Count = TotalItems, _

Size = (Bytes / 1000).ToString("#,###") _

Order By Type

' Display the grouped results.

DataGridView1.DataSource = query.ToList()

Press F5 to see the code run. Click on the different search terms in the ListBox to see the grouped results including the count of each item and the size (in kilobytes) of each item group.

LINQ Cookbook, Recipe 10: Pre-compiling Queries for Performance (Doug Rothaus)

VBTeam — Wed, 07 Nov 2007 02:55:00 GMT

Ingredients:

· Visual Studio 2008 (Beta2 or Higher)

Categories: LINQ to SQL

Introduction:

As we add cookbook entries, we will include performance improvement tips where appropriate. Here’s a tip that you can use with LINQ to SQL to speed up queries that you will call numerous times: Pre-compiled queries. By pre-compiling a query, you perform the processing to compile the query once, and then skip the compile step every consecutive time that you run the query.

Pre-compiled queries are created using the Compile method of the CompiledQuery class in the System.Data.Linq namespace. You pass a Lambda expression that contains the variables used by your query (the DataContext object, filter variables, and so on) to the Compile method to create a compiled query as shown in the following example.

Dim query As Func(Of NorthwindDataContext, Customer, IQueryable(Of Order)) = _

System.Data.Linq.CompiledQuery.Compile( _

Function(database As NorthwindDataContext, cust As Customer) _

From order In database.Orders _

Where order.Customer Is cust)

The first time the query executes, the query will be compiled and stored in the specified variable. After that, the compiled query is used when the query executes.

In this recipe, you will create a classic master-detail application using the Northwind sample database. The “master” list will display the customers from the Northwind database using a LINQ query, and the “detail” list will display the orders for the selected customer using a pre-compiled query.

Instructions:

· Create a Windows Forms Application with a connection to the Northwind database. Add a LINQ to SQL Classes item named Northwind.dbml and drag the Customers and Orders tables to the data classes design surface in the Object Relational Designer. For steps on creating an application that uses the Northwind database, see LINQ Cookbook Recipe 6: Your first LINQ application using Northwind.

· From the Toolbox, drag a ListBox control (to display customer information), a DataGridView control (to display order information), and a Label control (to display timer information) onto the form. Resize the form and controls as needed.

· Double-click the Form to edit the application code.

· Replace the default Form1 class with the following code that defines class-level variables and the Form1.Load event handler:

Imports System.Data.Linq

Public Class Form1

' Variable to hold the pre-compiled query.

Private orderQuery As Func(Of NorthwindDataContext, Customer, IQueryable(Of Order))

' LINQ to SQL DataContext object for Northwind.

Private db As New NorthwindDataContext

' Timer to show performance difference.

Dim queryTimer As New Stopwatch

Dim slowestTime As Long?

Dim currentTime As Long

Private Sub Form1_Load() Handles MyBase.Load

' Get the list of Customers and bind it to ListBox1.

ListBox1.DataSource = From cust In db.Customers _

Select cust _

Order By cust.CompanyName

ListBox1.DisplayMember = "CompanyName"

End Sub

End Class

· After the Form.Load event, add the following GetOrders method to retrieve orders for a customer.

Private Function GetOrders(ByVal selectedCustomer As Customer) As List(Of Order)

' If the query for orders has not been compiled yet, compile it. Otherwise,

' use the compiled query.

If orderQuery Is Nothing Then

orderQuery = CompiledQuery.Compile( _

Function(database As NorthwindDataContext, cust As Customer) _

From order In database.Orders _

Where order.Customer Is cust)

End If

' Execute the compiled query by calling the ToList method and

' return the results.

Return orderQuery(db, selectedCustomer).ToList()

End Function

· After the GetOrders method, add the following event handler for the ListBox.SelectedIndexChanged event. The event handler will pass the current selected customer to the GetOrders method to call the pre-compiled query and retrieve the orders for that customer. Some simple timer code is added to show the difference between the first time the query executes, and the current execution time.

Private Sub ListBox1_SelectedIndexChanged() Handles ListBox1.SelectedIndexChanged

queryTimer.Reset()

queryTimer.Start()

' If a customer has been selected, get the list of orders for the customer

' and bind it to DataGridView1.

If ListBox1.SelectedValue IsNot Nothing Then

DataGridView1.DataSource = GetOrders(ListBox1.SelectedValue)

End If

queryTimer.Stop()

currentTime = queryTimer.ElapsedMilliseconds

If slowestTime Is Nothing OrElse currentTime > slowestTime Then

slowestTime = currentTime

End If

Label1.Text = "Elapsed Time: " & currentTime & "/" & slowestTime

End Sub

Press F5 to see the code run. Click on different customers in the ListBox to see the performance difference using a pre-compiled query.

LINQ Cookbook, Recipe 9: Dynamic Sort Order (Doug Rothaus)

VBTeam — Wed, 17 Oct 2007 20:20:00 GMT

Ingredients:

· Visual Studio 2008 (Beta2 or Higher)

Categories: LINQ-To-XML

Introduction:

You can use the Order By clause to easily sort the results of a LINQ query in Visual Basic. A common requirement for sorted data, however, is that the user be able to choose the fields that the results are sorted by. The Order By clause requires that you specify a static list of sort fields and sort directions, so how do you specify a sort order when you don’t know which fields the user has chosen until run time? The solution is to use the OrderBy or OrderByDescending query methods of the Queryable or Enumerable class.

Here’s how it works: The OrderBy or OrderByDescending methods can be applied to any LINQ query. The input to the OrderBy or OrderByDescending methods is either a Lambda expression, or the address of a custom function. The Lambda expression or custom function evaluate an instance of the range variable for the current query scope and return a value to be used when sorting. For example, if the range variable is a Customer object that has FirstName and LastName properties, you can create a function called GetSortValue that takes, as input, a Customer object and returns the value for either the FirstName or LastName property value, based on which field the user selected to sort by.

This recipe shows how to create a custom function to provide values to be used when sorting a LINQ query.

Instructions:

· Create a new Windows Forms Application in Visual Basic. Set the Size of the default Form, Form1, to 800, 600.

· From the Toolbox, drag a WebBrowser control onto the form. The name of the WebBrowser control will default to WebBrowser1. In the WebBrowser Tasks panel, select Undock in parent container and resize the WebBrowser control to make room for two Label controls on the form.

· From the Toolbox, drag a Label control onto the form. Set the Text property of the Label control to Date. The name of the Label control will default to Label1.

· From the Toolbox, drag another Label control onto the form. Set the Text property of the Label control to Title. The name of the Label control will default to Label2.

· Right-click the Form and select View Code.

At this point, you will add a method that your application will use to retrieve an RSS feed to use as data to be sorted, and another method that will format the query results as an HTML document to be displayed using the WebBrowser control.

· In the Form1 class, add the following code.

Private rss As XElement

' GetRssDocument: Retrieves an RSS XML document from a supplied URL.

Private Function GetRssDocument(ByVal url As String) As XElement

Dim request = Net.WebRequest.Create(url)

Dim response = request.GetResponse()

Dim reader = Xml.XmlReader.Create(response.GetResponseStream())

reader.MoveToContent()

Dim rssDoc = XDocument.ReadFrom(reader)

reader.Close()

response.Close()

Return rssDoc

End Function

' GetHtmlDocument: Returns HTML transformed from a list of XML elements from

' an RSS feed.

Private Function GetHtmlDocument(ByVal items As IEnumerable(Of XElement))

Dim htmlDoc = <html>

<head>

<style>

td {font-family:verdana;font-size:12px}

</style>

</head>

<body>

<%= _

From item In items _

Select <tr>

<td style="width:480"><b><%= item.<title>.Value %></b></td>

<td><%= item.<pubDate>.Value %></td>

</tr> _

</table>

</body>

</html>

Return htmlDoc.ToString()

End Function

Next, you will add a method called GetList that will create the LINQ query. The GetList method takes, as input, an RSS document (typed as XElement), a field name to sort by, and a sort order (either “ASC” or “DESC”). The GetList method starts by creating a query that returns all elements, and then modifies that query using either the OrderBy or OrderByDescending methods, based on the sort direction specified.

· In the Form1 class, add the following code.

' GetList: Returns a list of XML elements from the RSS feed sorted based

' on user input.

Private Function GetList(ByVal rss As XElement, _

ByVal orderBy As String, _

ByVal direction As String) As IEnumerable(Of XElement)

Dim items = From item In rss.<channel>.<item>

If Not String.IsNullOrEmpty(orderBy) Then

sortField = orderBy

If Not String.IsNullOrEmpty(direction) AndAlso direction = "DESC" Then

' Store the sort order for Label click events

sortDirection = "DESC"

' Sort the query

items = items.OrderByDescending(AddressOf GetSortValue)

Else

' Store the sort order for Label click events

sortDirection = "ASC"

' Sort the query

items = items.OrderBy(AddressOf GetSortValue)

End If

Return items

End Function

Notice that the GetList method sets two variables that haven’t been declared yet: sortField and sortDirection. These are class-level variables that are used for different reasons. The sortDirection variable is used to toggle the sort order when a user clicks on either the Date label, or the Title label. In the click events for those labels, the code checks to see what the current sort order is, and passes the opposite sort order to the requested query. The sortField variable stores the name of the requested sort field. This is because the OrderBy and OrderByDescending methods only pass the current range variable to the method that returns the sort value. The name of the sort field is not included. As a result, the code stores the requested field in the sortField class-level variable before updating the query with either the OrderBy or OrderByDescending method. When the method that returns the sort value runs, it retrieves the sort field name from the sortField variable.

· In the Form1 class, add the following declarations after declaring the rss variable.

Private sortField As String

Private sortDirection As String

The GetList method also passes the address of the GetSortValue method to the OrderBy and OrderByDescending methods, which will be added next. The GetSortValue method returns a value from the current range variable to use when sorting, based on the specified sort field.

· In the Form1 class, add the following method.

' GetSortValue: Based on the current sort field, returns the value for

' that field from the supplied XElement. This function is

' called by a LINQ query to order a result based on

' a user-selected sort field.

Private Function GetSortValue(ByVal item As XElement) As String

Select Case sortField

Case "Title"

Return item.<title>.Value

Case "Date"

' Return a date value as a sortable string

Dim pubDate = DateTime.Parse(item.<pubDate>.Value)

Return pubDate.ToString("yyyy/mm/dd hh:mm")

End Select

Return String.Empty

End Function

Now that you have the supporting variables and methods, you can add the logic to the Form Load event and Label Click events to display and sort the values from the RSS feed.

· In the Form1 class, add the following code.

Private Sub Form1_Load() Handles MyBase.Load

rss = GetRssDocument("http://msdn.microsoft.com/vbasic/rss.xml")

WebBrowser1.DocumentText = GetHtmlDocument(GetList(rss, "Date", "DESC"))

End Sub

Private Sub Label1_Click() Handles Label1.Click

' Sort by publish date

' Toggle the sort direction, default to ascending

If sortDirection = "DESC" Or sortField = "Title" Then

WebBrowser1.DocumentText = GetHtmlDocument(GetList(rss, "Date", "ASC"))

Else

WebBrowser1.DocumentText = GetHtmlDocument(GetList(rss, "Date", "DESC"))

End If

End Sub

Private Sub Label2_Click() Handles Label2.Click

' Sort by title

' Toggle the sort direction, default to ascending

If sortDirection = "DESC" Or sortField = "Date" Then

WebBrowser1.DocumentText = GetHtmlDocument(GetList(rss, "Title", "ASC"))

Else

WebBrowser1.DocumentText = GetHtmlDocument(GetList(rss, "Title", "DESC"))

End If

End Sub

Press F5 to see the code run. Click on the Date and Title labels to toggle the sort order of the results.

LINQ Cookbook, Recipe 8: Querying XML Using LINQ (Doug Rothaus)

VBTeam — Mon, 01 Oct 2007 21:02:00 GMT

Ingredients:

· Visual Studio 2008 (Beta2 or Higher)

Categories: LINQ-To-XML

Instructions:

· Create a new Console Application in Visual Basic.

· Create an RSS document. Add the following code to Sub Main.

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

<title>LINQ to XML in Visual Basic</title>

<description>Sample RSS Feed</description>

<item>

<title>Basic Instincts: Lambda Expressions</title>

<description>A new feature added to Visual Basic 9 to

support Language Integrated Queries (LINQ),

which adds data programmability to

Visual Basic.</description>

</item>

<item>

<title>Visual Basic Pack for Visual Studio 2005 SDK</title>

<description>The Visual Basic Pack for the Visual Studio

2005 SDK includes SDK samples converted into

the Visual Basic language and a new wizard for

generating Visual Basic-based integration

packages for Visual Studio.</description>

</item>

<item>

<title>XML to Schema Tool</title>

<description>The XML to Schema tool is a free project item

template to automate creation of XML schema

sets from any number of XML documents. If you

are working with Language Integrated Queries

(LINQ) to XML in Visual Basic 9, this utility

can significantly improve your editing

experience by adding XML schemas (.xsd files)

to your project that add IntelliSense for XML

properties.</description>

</item>

<item>

<title>Line and Shape Controls in the Power Packs</title>

<description>Download the latest version of the Visual

Basic 2005 Power Packs which now includes Line

and Shape controls that enable you to draw

lines, ovals, and rectangles on forms and

containers at design time making it much easier

to enhance the look of your user

interface.</description>

</item>

</channel>

</rss>

You use the same LINQ syntax to query XML in Visual Basic as you would to query a collection, data from SQL Server, and so on. The difference is in how you reference the XML elements and attributes. The XML features in Visual Basic enable you to reference XML elements and attributes as first class data objects. That is, you can use XML syntax in your object-oriented Visual Basic code.

For example, to reference the <channel> element from the XDocument object created earlier in this topic, you would simply code: rss.<rss>.<channel>. While this may seem to reference only one <channel> element, XML in Visual Basic actually returns a collection of all of the <channel> elements that are sub-elements of the <rss> object. You can then refer to particular items in the collection by index, or, as we’ll see in this topic, you can perform a LINQ query over that collection of elements. To refer to any descendant of an XML element, use the descendant syntax, “...” as in rss.<rss>...<title>. To refer to an attribute, use the attribute syntax, “@”, as in rss.<rss>.@version. These options for referring to elements and attributes in an XDocument or XElement object are called XML Axis Properties.

Note: The XML features in Visual Basic include XML IntelliSense, which provides selection lists for possible XML attributes and child elements when you are coding using LINQ to XML objects such as XDocument or XElement object. To enable XML IntelliSense in Visual Basic, you simply need to include an XML Schema Definition (XSD) file in your project. The XML tools in Visual Basic will even create an XSD file for you, based on the contents of an XML file, if you don’t have an XSD file. For more information, see XML IntelliSense in Visual Basic.

Using the XML Axis Properties available in Visual Basic, we can query the XML content using LINQ. For example, the following query performs a free text search of the content from the <title> and <description> elements of an <item> in an RSS feed. Add the code to Sub Main after the code that creates the XDocument object.

Dim itemList1 = From item In rss.<rss>.<channel>.<item> _

Where item.<description>.Value.Contains("LINQ") Or _

item.<title>.Value.Contains("LINQ")

Console.WriteLine("Items containing 'LINQ'" & vbCrLf)

For Each item In itemList1

Console.WriteLine(vbTab & "Title: " & item.<title>.Value)

Console.WriteLine(vbTab & "Description: " & item.<description>.Value)

Console.WriteLine()

Note that the code example searches the Value property of an XML element to find a match. The Value property returns the contents of the XML element as a string. Without it, the XML Axis Property would return a collection of elements based on the element name. When searching XML attributes, you don’t need to specify the Value property. The XML Axis property will return the value of the first matching attribute, by default.

Because the Value property always returns a string, you may need to cast values as a particular type to perform your query. For example, the following code example searches for the items published in the last 20 days. Add the code to the end of Sub Main.

Dim itemList2 = From item In rss.<rss>.<channel>.<item> _

Let pubDate = DateTime.Parse(item.<pubDate>.Value) _

Where pubDate >= _

DateTime.Now.Subtract(New TimeSpan(20, 0, 0, 0)) _

Select item

Console.WriteLine("Items published in the last 20 days" & vbCrLf)

For Each item In itemList2

Console.WriteLine(vbTab & "Title: " & item.<title>.Value)

Console.WriteLine(vbTab & "Publish Date: " & item.<pubDate>.Value)

Console.WriteLine()

Press F5 to see the code run.