The Visual Basic Team : LINQ Cookbook

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.

Visual Basic 2008 Ships!!! (Amanda Silver)

VBTeam — Mon, 19 Nov 2007 20:27:00 GMT

Hooray! Today we’ve finally shipped Visual Studio 2008, previously known as “Orcas”, previously known as some symbol which doesn’t have an ascii representation. We’ve come a long way, but it’s been a great ride. In his blog, Soma mentions many of the flagship features at a high-level that will undoubtedly make the every developer and head of IT salivate, but this blog is about Visual Basic. :)

This is a tremendous release for Visual Basic users everywhere as it’s the first to introduce query expressions and XML as a first class data-type. Not only does this make Visual Basic the most productive choice for programming data-centric applications, it also makes us VB developers the envy of many an alpha-geek. If you'd like to just try it out -- be sure to check out Visual Basic Express which comes with all the features I talk about below.

With query the entire .NET frameworks become a queryable data source. You can now query against anything available in the .NET Frameworks – the registry, file system, live processes, etc. For example, the code below queries against the running processes and returns those with a thread count greater than 10, orders them by the thread count:

        Dim query = From proc In Process.GetProcesses _
            Let ThreadCount = proc.Threads.Count _
            Where ThreadCount > 10 _
            Order By ThreadCount _
            Select proc.ProcessName, proc.Id, ThreadCount

Using the LINQ to SQL Object-Relational Mapping framework, you can query against a SQL database as though it was just another collection of objects exposed by the frameworks. The following query finds all the products that have been discontinued, groups them into categories, and finds the total number of units in stock for each category:

        Dim db As New NorthwindDataContext(My.Settings.NORTHWNDConnectionString)
        Dim query = From prod In db.Products _
                    Where prod.Discontinued = True _
                    Group By prod.CategoryID _
                    Into Count(), NumInStock = Sum(prod.UnitsInStock) _
                    Join cat In db.Categories On cat.CategoryID Equals CategoryID _
                    Select cat.CategoryName, Count, NumInStock

Unlike writing huge SQL query strings, I get immediate feedback on the query I write.

Intellisense:

Syntax checking:

Schema checking:

I can use the same query language (VB!) to query against relational databases, XML, and collections of objects – I don’t need to learn any domain specific language, VB gives me access to all! It’s really easy for me to join across domains (I’ll take that up in a later blog post.)

With XML as a first class data-type, Visual Basic becomes a full XML transform language. But it’s also really easy for me to project to XML from my SQL database:

        Dim query = From prod In db.Products _
            Where prod.Discontinued = True _
            Group By prod.CategoryID _
            Into prodGroup = Group, NumInStock = Sum(prod.UnitsInStock) _
            Join cat In db.Categories On cat.CategoryID Equals CategoryID _
            Select <Products>
                       <Category CategoryID=<%= CategoryID %> CategoryName=<%= cat.CategoryName %>>
                           <%= From prod In prodGroup _
                               Select <Product Price=<%= prod.UnitPrice %>><%= prod.ProductName %></Product> %>
                       </Category>
                   </Products>

Last but not least, for those of you who aren’t so excited about the LINQ (Language INtegrated Query) project, Visual Basic 2008 comes with a tremendous improvement in the Intellisense experience overall. One of our MVPs said that he literally types two characters and hits tab, two characters, tab – it’s as though the code writes itself!

Obviously, we’re very excited about this release and hope it meets you with open arms eager to embrace the productivity! If you're ready to go to the next level and dig in, be sure to check out our learning pages and How-Do-I videos which walk you through these features and so much more.

Tomorrow I’ll blog about the least often mentioned goodies hidden in Visual Basic 2008 so that you can become the guru master of VB9. ‘Til then…

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.

LINQ Cookbook, Recipe 7: Selecting Pages of Data from Northwind (Jonathan Aneja)

VBTeam — Thu, 12 Jul 2007 20:58:00 GMT

Ingredients:

- Visual Studio 2008 (Beta2 or Higher)

- Connection to Northwind database

Categories: LINQ-To-Objects, LINQ-To-SQL

Instructions:

· Create a new Windows Forms project with a Northwind DataContext (for step-by-step instructions on how to do this please see Recipe #6)

· Drop a DataGridView control from the Toolbox onto the Form

· Add the following line of code in your Form1_Load event:

Dim db As New NorthwindDataContext

One of the key considerations when designing an application is how much data to show the user at a time. For instance, if the user enters a query for products and there’s 10 million matches in the database, it’s probably not a good idea to display all those records on the screen at once.

The typical solution for this is to show one “page” worth of data at a time, and then give the user the ability to move to the next page. This results in a faster application which is easier for your customers to use.

In order to implement paging with LINQ, we’re going to use two new operators called Skip and Take. For instance, consider the following query:

Dim q = From p In db.Products _

Select p.ProductID, p.ProductName, p.UnitPrice _

Skip 20 _

Take 20

This will select 3 fields from my Products table and ignore the first 20 rows, and give me the next 20, or to put it another way: page 2 of my results. Now let’s look at a function we can use to generalize this to any number of rows:

Public Function GetProductsPage(ByVal db As NorthwindDataContext, _

ByVal pageNum As Integer, _

ByVal pageSize As Integer) As IEnumerable

Return From p In db.Products _

Select p.ProductID, p.ProductName, p.UnitPrice _

Skip (pageNum - 1) * pageSize _

Take pageSize

End Function

Note: When using Skip/Take you must ensure that you select any identity columns (ProductID in this case) when working with SQL Server 2000. For SQL Server 2005 you don’t need to worry about this.

We can now use this function by passing in the page number and the size (i.e. number of rows in the page):

Private Sub Form1_Load() Handles MyBase.Load

Dim db As New NorthwindDataContext

DataGridView1.DataSource = GetProductsPage(db, 3, 20)

End Sub

Linq Cookbook, Recipe 6: Your first Linq Application using Northwind (Kit George)

VBTeam — Thu, 12 Jul 2007 05:48:00 GMT

This example is intended as a ‘primer’ for following recipes (so we don’t repeat the same instructions multiple times). This recipe takes you through everything you need, and assumes only that you've installed Visual Studio (and in so doing, you've installed SQLExpress). Subsequent Northwind based Linq-To-Sql recipes will point to this entry.

Ingredients:

- Visual Studio 2008 (Beta2 or Higher)

We assume that SQL Express (or better) has been installed

Categories: LINQ-To-SQL, LINQ and WinForms

Instructions:

We need the northwind database, so Download the northwind database here. Run the file from the download button on the page
Once downloaded, you’ll find the new samples in “C:\SQL Server 2000 Sample Databases”. We’ll be using the northwind.mdf file
Open Visual Studio, and create a new Windows Forms Application
Go to the View menu and click the Server Explorer menu item
On the treeview on the left, right-click the Data Connections and select ‘Add Connection’
In the next dialog select ‘Microsoft SQL Server Database File’ and click Continue
In the next dialog, click the Browse button, and navigate to “C:\SQL Server 2000 Sample Databases”. Select the ‘NORTHWND.MDF’ file, and click Open
Click OK to finish Adding the Connection
In your Treeview node, under ‘Data Connections’ NORTHWIND.MDF will be available. Expand this node (click on the plus beside it) and expand the Tables node

Note: The steps up to this point need only be completed once. If you create a new project, then the database will still be available through server explorer. You may need to reopoen the Server Explorer window from session to session (see below)

Now add a Linq To Sql file to your application. Go to the Project menu, and select ‘Add New Item’
In the Add New Item dialog, select the ‘LINQ To SQL Classes’ item
Change the name to ‘Northwind.dbml’ and click Add
From the Server Explorer window (which will still be open) select all of the Tables from the node we expanded (DataConnections\NORTHWND.MDF\Tables) and drag them to the O/R designer window to the right (this window will have opened after we added the Northwind.dbml file)
You will get a dialog asking if you wish to copy the database locally. Click Yes
Close the designer file, and the Server Explorer window. You’re ready to start writing your LinQ To Sql code!
To reopen the Server Explorer window, go to the View menu, and select Server Explorer
To reopen the O/R designer, go to the Solution Explorer window, and double-click Northwind.dbml

Test our project

To ensure our project is ready to add linq statements to, let’s try it out!
Add a button to form1
Add a DataGridView to form1
Double-Click the button to open its click event
Add this code inside the click event:

Dim db As New NorthwindDataContext

DataGridView1.DataSource = _

From cust In db.Customers _

Where cust.City = "London" _

Order By cust.CompanyName _

Select cust.CompanyName, _

cust.ContactName, cust.Fax

Run the App (F5) and click the button to test it

LINQ Cookbook, Recipe 5: Concatenating the selected strings from a CheckedListBox (Kit George)

VBTeam — Wed, 04 Jul 2007 02:28:00 GMT

Ingredients:

- Visual Studio 2008 (Beta2 or Higher)

Categories: LINQ-To-Objects, LINQ and WinForms

Instructions:

Open Visual Studio 2008, and Click ‘File/New Project’. Create a new Windows Forms Application project
From the toolbox, drag a CheckedListBox to the main form, and a button. Ensure the listbox is large enough to view multiple items
DoubleClick the form to creat the load event. Add this code to the load event (this simply populates the CheckedListBox with entries)

CheckedListBox1.Items.AddRange( _

New String() {"Apple", "Orange", "Banana", _

"Avocado", "Tomato", "Tamarillo", _

"Kiwifruit", "Cherry"})

Create the click event for the button (in the code editors dropdowns, in the left drop down, select Button1) and add this code

MsgBox( _

Aggregate Box In CheckedListBox1.CheckedItems _

Into Concat())

At the very bottom of the code (after End Class) add this code. This code creates the aggregate 'Concat' function which enables this code to be used on the 'Into' above

Public Module AggregateModule

<Extension()> Public Function Concat(Of Type)( _

ByVal ie As IEnumerable(Of Type)) As String

Dim str As String = ""

For Each item In ie

If str <> "" Then str &= ","

str &= item.ToString()

Return str

End Function

End Module

Alternatively, change the code in the button to be the following and remove the function we created (this is less code, but if you're going to use this code a lot, then writing the Concat function is preferred)

MsgBox((From c In _

CheckedListBox1.CheckedItems).Aggregate( _

Function(ByVal x, ByVal y) x + "," + y))

LINQ Cookbook, Recipe 3: Find all the prime numbers in a given range (Jonathan Aneja)

VBTeam — Thu, 28 Jun 2007 23:21:00 GMT

Ingredients:

- Visual Studio 2008 (Beta2 or Higher)

Categories: LINQ-To-Objects

Instructions:

- Open Visual Studio 2008, and Click ‘File/New Project’. Find and double-click the ‘Console Application’ Icon

- Add the following code:

Module Module1

Sub Main()

Dim primes = GetPrimesInRange(30, 50)

For Each n In primes

Console.WriteLine(n)

Console.ReadLine()

End Sub

Function GetPrimesInRange(ByVal low, ByVal high) As IEnumerable(Of Integer)

Dim range = Enumerable.Range(1, high)

Return From num In range _

From num2 In range _

Where num Mod num2 = 0 _

Group By num Into Count() _

Where Count = 2 And num > low _

Select num

End Function

End Module

- The grouping is used to select only those numbers that have exactly two factors (i.e. they're prime)

LINQ Cookbook, Recipe 4: Find all complex types in a given assembly (Kit George)

VBTeam — Thu, 28 Jun 2007 04:30:00 GMT

Ingredients:

- Visual Studio 2008 (Beta2 or Higher)

- An assembly which you want to analyze (in this example, we use mscorlib.dll, the assembly which houses String)

- A definition for 'Complex Type'. In this instance, a complex type is defined as having more than 10 public methods, of which at least one has more than 3 arguments

Categories: LINQ-To-Objects, LINQ and types, LINQ and WinForms

Instructions:

- Open Visual Studio 2008, and Click ‘File/New Project’. Find and double-click the ‘Windows Forms Application’ Icon

- Drag and drop a Listbox to the form. Size the listbox to be fairly tall. Drag and drop a button to the form

- Double-click the button, and add the following code to the button:

Dim q = From type In System.Reflection.Assembly.GetAssembly( _

GetType(String)).GetTypes(), _

m In type.GetMethods() _

Where type.IsPublic _

AndAlso type.GetMethods.Length > 10 _

AndAlso m.GetParameters.Length > 3 _

Select type Distinct

ListBox1.Items.AddRange(q.ToArray)

LINQ Cookbook, Recipe 2: Find all capitalized words in a phrase and sort by length (then alphabetically) (Kit George)

VBTeam — Sat, 23 Jun 2007 02:59:00 GMT

Ingredients:

- Visual Studio 2008 (Beta2 or Higher)

- Some text you want to search

Categories: LINQ-To-Objects, LINQ and strings, LINQ and WinForms

Instructions:

- Open Visual Studio 2008, and Click ‘File/New Project’. Find and double-click the ‘Windows Forms Application’ Icon

- Drag and drop a Listbox to the form. Size the listbox to be fairly tall. Drag and drop a button to the form

- Double-click the button, and add the following code to the button:

Dim text = "Good morning everyone. I'd like to welcome " & _

"you to today's presentation on LINQ. My " & _

"name is Kit George and I'm a Program Manager " & _

"for Microsoft, on the Visual Basic team. You " & _

"might be wondering where my accent is from? " & _

"Well, I hail from a small country called New " & _

"Zealand but it sure is great to be here in " & _

"Atlanta today!"

Dim capitalWords = _

From word In text.Split( _

New Char() {",", ".", "!", " "}, _

StringSplitOptions.RemoveEmptyEntries) _

Where word(0) = Char.ToUpper(word(0)) _

Order By word.Length, word

ListBox1.Items.AddRange(capitalWords.ToArray())

- Change the text being searched to the text of your choice. If your text is coming from a file, use My.Computer.FileSystem.ReadAllText to get the data into the text variable

LINQ Cookbook, Recipe 1: Change the font for all labels on a windows form (Kit George)

VBTeam — Sat, 23 Jun 2007 02:24:00 GMT

Folks, we’re gonna start a ‘cookbook’ of LINQ entries, which we’ll be building over time. This is just meant to be a series of solutions to specific scenarios, that the team comes across when writing code and using queries. I can't think of a better way to communicate everything you might use LINQ for!

The point of the series is to show you the wide array of things LINQ can do. Like any good cookbook, we’ll have categories for the cookbook, so you can easily find items later. Don’t expect any particular ‘recipe’ to have a large description, although they will contain repro steps. Feel free to ask for any recipes you want to see, and we’ll get as many created as we can!

Ingredients:

- Visual Studio 2008 (Beta2 or Higher)

Categories:

- LINQ-To-Objects, LINQ with Windows Forms, LINQ with controls, Label

Instructions:

- Open Visual Studio 2008, and click ‘File/New Project’. Find and double-click the ‘Windows Forms Application’ Icon

- Increase the size of the window to be large enough to fit a number of controls

- Drag and drop multiple controls from your toolbox onto the form. Ensure at least 3-4 labels are added

o My own personal favorites are two group boxes, with two labels in front on textboxes (and labels above the group boxes), and a couple of radio buttons in each. This ensures the recursive code is tested

- Add a button to the form and change the text of the button to ‘Go’. Double-click the button, and modify the EventHandler code and add the method below:

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

For Each label In GetLabels(Me)

label.Font = New Font("Comic Sans MS", 12, _

FontStyle.Bold Or FontStyle.Underline)

End Sub

Private Function GetLabels(ByVal sourceControl As Control) _

As IEnumerable(Of Control)

If sourceControl.Controls.Count > 0 Then

Dim labels = From cont As Control In sourceControl.Controls _

Where TypeOf cont Is Label _

Select cont

For Each c As Control In sourceControl.Controls

labels = labels.Union(GetLabels(c))

Return labels

End If

Return New List(Of Control)

End Function

- Change the ‘New Font’ line to be the style of your choice