Visual Studio 2008

Your First VS 2008 WPF Application .... or not?

Ged Mead — Tue, 27 Nov 2007 14:13:00 GMT

So Visual Studio 2008 is finally here! After what seems like a long time using Betas, VS 2005 extensions and various other weirdly named WIPs, it's great that the full, final version has arrived.

If you haven't tried it yet and aren't ready to commit from your wallet then you'll probably be pleased to hear that VS 2008 also has a free, downloadable Express Edition. Well, "Editions" - as there are VB, C#, C++ and Web versions. The download site for the VB Express Edition is here.

One of the very first things I did was to fire up a new WPF application :

However, I was a bit surprised to find that as soon as I tried to run this project I had an immediate compilation error:

As the message says, "Option Strict On disallows implicit conversions from 'System.Windows.Application' to 'WpfApplication1.Application'. (Obviously the name of the WPF Application will be different if you have already changed the project name to something more meaningful).

Having got into the good habit of always starting out with Option Strict On I didn't really want to "fix" this problem by turning Option Strict Off. Luckily the solution for this little setback is simple.

Double click the error message in the Errors list so that you are taken to the MyWpfExtension.vb file, which is where the problem resides. You will see the all-too-familiar wavy blue line under the code:

Return Global.System.Windows.Application.Current

Replace this with:

Return CType(Global.System.Windows.Application.Current, Application)

which explicitly makes the required cast and you will be good to go.

Of course, this only fixes the current project. For a longer term fix, you can create a new template. To do this, first of all make the code change as described above. Then select Export Template from the File Menu in Visual Studio:

Accept the default settings in the first window. Then in the next window, edit the Template Name (I recommend that you create one with a name that indicates that it is a revised version). Add a description if desired.

You can't actually change the output location from this window, so leave that as is (for now anyway).

Click the Finish button and you will see the created template zip file in that default folder. Copy that newly created zip file and navigate to :
My Documents\Visual Studio 2008\Templates\ProjectTemplates\Visual Basic

Create a new folder in there and name it "Windows". Paste the zip file into this new folder. Don't unzip the file.

Close down Visual Studio 2008 and re-open it. If all has gone according to plan, you will now see the additional template in the "My Templates" area.

You can click on this to create a new WPF application that will run fine with Option Strict On.

I'm sure this will be fixed in SP1, but it's one of those minor things that might throw you if you didn't know about it.

Visual Studio 2008 - Beta 2 now available for download

Ged Mead — Wed, 01 Aug 2007 13:23:00 GMT

The latest (and final) Beta for what we used to know as Visual Studio CodeName Orcas has now been made available. Visual Studio 2008 Beta 2 can be downloaded from here.

According to the team at Microsoft, this version is now feature complete. The next version - RTM version - will ship before the end of the year and the final product release is scheduled for February 2008.

Although still a hefty download, it's less bulky than the previous Beta and the Community Technology Preview (CTP) versions. As with all Betas, the best advice is to install it on a development machine that you don't mind reformatting if necessary.

Visual Studio Orcas (VS 2008): Project Saves and Intellisense

Ged Mead — Fri, 15 Jun 2007 11:18:00 GMT

I've spent most of my free Orcas experimentation time on Linq so far, and the occasional foray into the wild world of WPF. I really want to get to grips with WPF in the next few months. It's not going to be easy stuff, that's for sure, but hopefully the results - graphically at least - will be worth the effort.

Saving Project Files

I've noticed a few changes in the Orcas/2008 IDE. It seems that we've gone full circle again on project file saving. In Orcas, your new project is automatically saved to the hard drive - whereas in VB 2005 you have that kind of temporary system where you don't get asked to decide to save to a path of your choice until the first time you hit the save button or save menu item. Having got used to the 2005 way, I've actually come to prefer it . It can be a bit dispiriting to see just how many projects you can happily discard as worthless, but it doesn't half cut down on the search task when you want to go back later and find a worthwhile project in that huge mass of low grade Solution goo.

Intellisense

Intellisense has just come of age! Orcas Intellisense is just absolutely excellent. Not just in the Linq queries, where it is of course particularly useful in keeping your head straight on what you're trying to achieve either. For standard code bashing jobs, Intellisense has been refined.

First off, you only get a dropdown list of possible selections that begin with the letter(s) you have typed so far. The list gets further and further filtered as you type. In 2005 there is some filtering, but it's simply not as slick as this.

But the thing I like the best about it is that it remembers what your last choice was for any selection. So to take an example, the first time you start to type:
Console.W

you will get all Console methods beginning with W, as you would expect. Let's assume that you select Console.WriteLine.
You then go off and use Intellisense for other code insertion, using different initial letters. When you next select "Console.W" you are offered your last recorded choice - specifically in this case "Console.WriteLine" which happens to be way down the list of W choices. I don't have VS 2005 on the machine I'm writing this on, but as far as I remember, in 2005 you are offered the first match that begins with your current letter, not the one you last used. I've found this to be really useful.

Linq To SQL Hands On Lab

Ged Mead — Tue, 12 Jun 2007 09:34:00 GMT

As mentioned earlier, there is a Hands On Lab available from Microsoft which walks you through some basic (and not so basic!) steps in using Linq To SQL. The download page is here.

Here are a few observations on the Linq To SQL Hands on Labs that I jotted down while I was working through it :

So Much Reassurance is, umm, Reassuring!
One aspect of the Labs that I particularly liked was that the narrative was full of helpful notes to reassure me as I worked my way through it. The kind of thing included is "Note: .. the new row will not show in the results" and "Note:As in the last task, no changes have actually been sent to the database yet". I think notes at this level are extremely useful - and far too often technical authors forget that there is a wide range of understanding out there in their reading public. As they are side notes, readers who don't need the info can skim or ignore them; the rest of us can read them and be reassured that we haven't missed or misunderstood something.

So Many Customers Can Be Confusing!
I decided that I would create a brand new Orcas project and solution for each part of the Lab. That way, I thought, I could go back later when it all became fuzzy in my memory and just home in on one particular technique. It also meant that I got a bit of learning reinforcement as I went through the initial steps again each time

Just be aware though that in Exercises 2 and 3 (Internals) you hand-build your own Customer class (and very tricky stuff it is, too, although it is clearly explained). However, when you move on to Exercise 4 you need to revert to the Customer table from the dbml file, i.e. the one you created the easy way back in Exercise 1. If you don't, you'll have a problem or two when you try and use the demo code in Exercise 4. It's not rocket science level stuff, but may give you pause if you're not aware.

And at the risk of insulting your intelligence, you need to add the further two Tables from Northwind - Order Details and Products - to the existing dbml file, so you eventually have all five tables available.

Some Typos and Missing Link

It's rare day when you can work through a whole set of printed exercises and not get stung by a few typos in the code. The Linq To SQL HOL is generally pretty good on this score, but be aware that in Exercise 4, Task 2 there's a minor blip that's pretty obvious as soon as you look at it (and doesn't really undermine anything important in the learning curve). The formatted WriteLine string should of course be:

  '  Display the result
   For Each cust In CACustomers
     Console.WriteLine("{0}, {1}, {2}, {3}", _
     cust.CustomerID, cust.CompanyName, cust.ContactName, cust.Orders.Count)
   Next

i.e. the second "{2}" changed to "{3}".

It might also be worth mentioning that if you want to see the (not yet persisted) Update to the contactname, which is what the next Task -Task 5 - does, then you should copy and paste the above block again to bottom(ish) of Sub Main. That way you'll get both versions displayed one after the other.

I also had a problem with Tasks 1 - 4 of Exercise 5, in that I couldn't track down the SQL Server database they were using. I think this may be available via SQL Server Express or the VB Express Starter Kits, but it doesn't seem to be linked from the download page and I didn't pursue it. So, I did skip actually carrying out those tasks. (I think it's available as part of one of the Starter Kits in VB 2005, but not included with the Orcas Beta 1 - I'm sure it will probably all come together once the final version is shipped).

Overall though, I found the whole package to be well written, clear to follow and very useful. I'm sure I'll be dipping back into it for help in the future and, with the current lack of VB based Linq articles and books, this Hands On Lab is very welcome.

LINQ To SQL(1)

Ged Mead — Sun, 10 Jun 2007 10:30:00 GMT

I'm still very much just feeling my way tentatively forward with LINQ to SQL, but my first reaction is one of relief that it really is very similar to the LINQ to Objects approach and so the learning curve is minimal. Of course, there is the small matter of connecting to database that isn't a factor in LINQ to Objects, but so far the use of DataContext has been painless. (Hope I'm not celebrating too soon!)

A new Hands On Labs that is now available from the Visual Basic Team is very good and I recommend you download it and give it a try. You can get it via the VBFeeds web site here. As I don't think I can improve on that resource, I won't run through a whole list of examples as I did with LINQ To Objects. May be better if I just highlight some points that caught my attention. (This latest Hands on Lab, by the way, has been updated to run under Orcas Beta 1.)

Distinct
I don't know about you, but I find it hard to think of "Distinct" without the prefix of "Select" as in the standard SQL Query syntax of "SELECT DISTINCT". For whatever reason, in LINQ to SQL you do have to pull them apart though as the compiler won't recognise the phrase "Select Distinct" in a LINQ to SQL Query.

If I can claim to have done enough LINQ work to develop habits, I guess I'd say that I'm in the habit of using the query format of: (Pseudocode)

Dim x = From element in collection _
Where typedobject = SomeValue _
Order By somecolumn _ Select expression

i.e. writing the guts of the query before finishing it off with the Select line. It seems though that with a LINQ to SQL Query that uses the Distinct keyword, the format has to be:

Dim ids = From Customer In db.Customers _
                  From emp In db.Employees _
                  Where Customer.City = emp.City _
                   Select emp.EmployeeID Distinct

or:

Dim ids = From Customer In db.Customers _
                  From emp In db.Employees _
                  Where Customer.City = emp.City _
                   Select emp.EmployeeID _
Distinct

of course.

Just as a minor note of warning, if you do use this query format:

  Dim ids = From Customer In db.Customers _
                  From emp In db.Employees _
                  Where Customer.City = emp.City _
                  Distinct _
                   Select emp.EmployeeID

where the Distinct keyword is inserted prior to the Select keyword, you won't get a syntax error flagged up and the query will compile. However you won't get a distinct list as the result; you'll get all EmployeeIDs (repeated) that match the criteria.

Syntax Checking
Something else you have to get used to while writing out LINQ queries is the syntax editor barking at you halfway through some queries. This might just be because I'm still working with a Beta version and may not happen once we get to RTM. However it can be off-putting if you think you've written the code correctly (but haven't finished it) and you get various error messages that subsequently prove not to be errors.

One self-inflicted error (that actually is an error!) is to forget to insert the space and underscore at the end of a line in an incomplete LINQ Query. Sometimes when you're concentrating so hard on getting the syntax just right this is a really easy thing to forget. The error messages vary, but never refer to the missing underscore, but - understandably - refer to the next line of code which the compiler won't be able to understand because of the missing punctuation mark. So the first thing to check before trying to figure out what the supposed error might be is that you haven't forgotten that space and underscore. It'll soon become second nature - trust me!

Going back to the Hands On Labs, I quite like the way it begins by demonstrating how easy it is to use the built-in LINQ To SQL File Template to create a working query quickly and easily. It then digs deep down into the code to show how this is done under the hood and how you can hand build equivalents yourself if you want to. Personally, having worked through their examples, I was very happy to accept their advice which is:
"Generating the database table relationships and object model can be tedious and prone to error. We do NOT advise you take that approach but it's included in this lab for education.....
The easiest and best option is to use the new designer with its seamless Visual Studio integration."

Yay to that!

VB 9, Orcas, VB 2008, VB 10, VBx, Silverlight - Confused? Help is at hand!

Ged Mead — Fri, 08 Jun 2007 16:00:00 GMT

I'm not usually a fan of blogs that link to blogs, but I thought that this item by Scott Wisniewski of the Visual Basic Team is so useful in clarifying the situation that I would flag it up.

We're all used to mentally switching from Codenames like Orcas to the final version names (which now is VB 2008, apparently), but this year the ongoing stream of new products and additions to current ones is more mind-boggling than at any previous time that I can remember. So it's good to have an explanation like that one that walks through it in very clear terms.

I think it might be useful to have an equivalent clear explanation of the various .NET framework numbers - 1.0, 1.1, 2, 3 and now 3.5 - and where they all fit in to the big picture. There's probably at least one already out there somewhere. I just haven't come across it yet, but would welcome any links if you have any.

LINQ To Objects - Part 3

Ged Mead — Sun, 20 May 2007 09:03:00 GMT

Although some of the queries we saw at the end of Part 2 are quite impressive - and light years easier than doing it with Loops and If/Then tests - there are still more improvements to come. Let's take the situation where you want to run Join queries across two separate data sources. This is something you'll commonly do with Access or SQL Server, etc, data sources but not something you'd automatically think of doing with, for example, a couple of collections.

To demonstrate this, we can use a collection of objects from the Person class that we created earlier, together with a new Class that contains a field or fields that we can join them on. The scenario I'm going to use is that we run courses in the UK and in Belgium, so we will have a class named "Course". Here is the code for that class:

Code Copy

Public Class Course
    Private m_Title As String = "Not Known"
    Private m_Location As String = "Not Known"
    Private m_StartDate As DateTime = Today
    Private m_DurationDays As Integer = 1

    Property Title() As String
        Get
            Return m_Title
        End Get
        Set(ByVal value As String)
            m_Title = value
        End Set
    End Property

    Property Location() As String
        Get
            Return m_Location
        End Get
        Set(ByVal value As String)
            m_Location = value
        End Set
    End Property

    Property StartDate() As DateTime
        Get
            Return m_StartDate
        End Get
        Set(ByVal value As DateTime)
            m_StartDate = value
        End Set
    End Property

    Property DurationDays() As Integer
        Get
            Return m_DurationDays
        End Get
        Set(ByVal value As Integer)
            m_DurationDays = value
        End Set
    End Property

    Public Overrides Function ToString() As String
        Return m_Title & " : " & m_Location
    End Function

End Class

And, as I'm sure you'll realise, we will use the Location Property in the Course class as the field to join the HomeTown property of the Person class - the purpose of this imaginary scenario being that we can invite potential students to attend courses in their home town.

As we did in earlier examples for the Person class, we can create a simple array of Course objects:

Code Copy

Function CreateCourses() As Array
        Dim SomeCourses() As Course = {New Course With {.Title = "VB 2005", _
            .Location = "Leeds", .StartDate = New DateTime(2007, 8, 8), .DurationDays = 7}, _
        New Course With {.Title = "Java", .Location = "Ghent", .StartDate = New DateTime(2007, 12, 1), _
            .DurationDays = 14}, _
        New Course With {.Title = "Ajax", .Location = "Manchester", .StartDate = New DateTime(2008, 1, 13), _
            .DurationDays = 10}, _
        New Course With {.Title = "Classic VB", .Location = "Leeds", .StartDate = New DateTime(2006, 2, 2), _
            .DurationDays = 10}, _
        New Course With {.Title = "SQL Server 2005", .StartDate = New DateTime(2008, 5, 6), _
            .Location = "London", .DurationDays = 12}}

        Return SomeCourses

    End Function

Note that for demo purposes I've included a course location in London, a place which none of our current Persons have their HomeTown, and also a course start date which has already passed. We can use these for validation purposes in our queries.

First, we need to create the two arrays to query on:

Code Copy

Public Class Form1
    Dim People() As Person
    Dim Courses() As Course

    Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        '  Get some data to work with
        People = CreateDataVB9_3()
        Courses = CreateCourses()
    End Sub

And then we can run a query that matches all Persons whose HomeTowns are located in a place where we hold a course (reagrdless of course date):

Code Copy

  Dim Students = From P In People, C In Courses _
        Where P.HomeTown = C.Location _
        Order By C.Location _
        Select P.Forename, P.Surname, P.HomeTown, C.Title, C.Location

        Console.WriteLine("Potential Students:")
        For Each Potential In Students
            With Potential
                Console.WriteLine(String.Format("{0} {1} From {2} - {3} Course in {4}", .Forename, _
                      .Surname, .HomeTown, .Title, .Location))
            End With
        Next

A lot of this will be familiar from the earlier examples. We look into both the Persons and the Courses arrays and find those cases where the Person's HomeTown matches the Course's Location.
The resulting array is then ordered alphabetically by Location.
We select the details we are interested in - in this case the Person's name and home town, together with the Course's Title and Location.

(The selection of both HomeTown and Location is of course not really necessary. I've only done it this way so we can prove that the query has worked correctly by listing both the HomeTown and the Location properties separately in the output.)

The second block of code which outputs the results of the query to the console is very similar to output code we've used in previous examples. As I mentioned, I've included the place name twice simply to confirm that things are working as they should. The resulting output looks like this:

Potential Students:
Jan Urqhart From Ghent - Java Course in Ghent
Natalie Hebber From Ghent - Java Course in Ghent
Marc Goosens From Ghent - Java Course in Ghent
Ken Browning From Leeds - VB 2005 Course in Leeds
Ken Browning From Leeds - Classic VB Course in Leeds
William Birchley From Leeds - VB 2005 Course in Leeds
William Birchley From Leeds - Classic VB Course in Leeds
Pauline Pearson From Leeds - VB 2005 Course in Leeds
Pauline Pearson From Leeds - Classic VB Course in Leeds
Sandi Skeet From Manchester - Ajax Course in Manchester
Sylvie Swanson From Manchester - Ajax Course in Manchester
Sarah Wilkinson From Manchester - Ajax Course in Manchester
Frank Whittle From Manchester - Ajax Course in Manchester
Jim Burnley From Manchester - Ajax Course in Manchester

which seems to return the results you would expect, ordered by Location. As noted in a previous Part of this article, a GroupBy operator will also be available at a later stage in the evolution of LINQ in Orcas.

Finally, just to make use of that course I created where the start and finish dates have already passed, this query will only pull matches for future courses:

Code Copy

Private Sub FindCurrentCourseMatches()
        Dim Students = From P In People, C In Courses _
         Where P.HomeTown = C.Location _
         Where C.StartDate > DateTime.Today _
         Order By C.Location _
         Select P.Forename, P.Surname, P.HomeTown, C.Title, C.StartDate

        Console.WriteLine("Potential Students:")
        For Each Potential In Students
            With Potential
                Console.WriteLine(String.Format("{0} {1} From {2} - {3} Course, Starting on {4}", .Forename, _
                      .Surname, .HomeTown, .Title, .StartDate.ToLongDateString))
            End With
        Next
End Sub

You may have noticed that this time I didn't include the Course Location in the Select line.
The resulting output is:

Potential Students:
Jan Urqhart From Ghent - Java Course, Starting on 12 December 2007
Natalie Hebber From Ghent - Java Course, Starting on 12 December 2007
Marc Goosens From Ghent - Java Course, Starting on 12 December 2007
Ken Browning From Leeds - VB 2005 Course, Starting on 08 August 2008
William Birchley From Leeds - VB 2005 Course, Starting on 08 August 2008
Pauline Pearson From Leeds - VB 2005 Course, Starting on 08 August 2008
Sandi Skeet From Manchester - Ajax Course, Starting on 13 January 2008
Sylvie Swanson From Manchester - Ajax Course, Starting on 13 January 2008
Sarah Wilkinson From Manchester - Ajax Course, Starting on 13 January 2008
Frank Whittle From Manchester - Ajax Course, Starting on 13 January 2008
Jim Burnley From Manchester - Ajax Course, Starting on 13 January 2008

- always assuming that you are reading this before the end of 2007, that is!

So, we've scratched the surface of LINQ To Objects and I hope I've succeeded in giving you a flavour of the possibilities.

Orcas Beta 1 Downloaded and Installed

Ged Mead — Thu, 17 May 2007 14:47:00 GMT

Thanks to my VBCity colleague, Scott Waletzko a.k.a. Sp!ke, I'm now happily sat here with the Orcas Beta 1 fully installed and running smoothly. I'd suffered more than my fair share of pain when installing the March 2007 CTP so I was a bit concerned that the Beta would be a re-run of that. The VPC version had been a particular nightmare but I did get a more or less working version up and running eventually. After that, apart from a couple of minor glitches - all efforts to view the Property pages gave me an error and I didn't have access to the offline MSDN - it has worked well and I've been able to do quite a lot of research in general and testing out various elements of LINQ in particular.

I've also made a tentative start on XAML and WPF, but can see right away that it's going to be a tough uphill slog. I reckon the learning curve of WPF is going to be just as steep as the one from Classic VB to VB.NET. Ah well, no pain, no gain, as they say.

I really hope there are some VB authors out there who are already planning to write WPF books using VB as the code behind. Almost every book I can find at the moment only has C# as the code behind language. It's hard enough getting your head round the XAML without having to translate fron C# to VB on the fly too. Luckily there are some useful examples using VB in the MSDN pages, so I'm working through those while waiting for the first VB oriented book to appear on the bookstalls. (If anyone knows of any, whether available now or planned, please post up details as a comment.)

Having spent several days (I exaggerate not) sweating over the March CTP installation, I was in a bit of trepidation about what kind of experience the Beta 1 installation would give me. I needn't have worried. I carefully uninstalled all previous Orcas and related installations, keeping strictly to the uninstall order in the ReadMe. It took a while and a couple of reboots. Then, fingers crossed, I started the install of Beta 1. Smooth as silk! I went for the default installation option and all went well. MSDN installation next and this too was totally problem/warning message/blue screen free!

So, after maybe a total of 3 - 4 hours, it's all running well. I also got hold of the Beta 1 LINQ samples, which are of course very similar to the March CTP ones. Setting up LINQ to SQL having given me a problem in the CTP stage, so I was pleased to see that the comments and instructions in the latest LINQ Samples download made more sense (at least to me!) and I was able to get them running this time.

The download version I used came from here The Pro Edition Self-Extracting Install. I'm told that it runs almost without problem side by side with VS 2005, but I'm still playing safe and keeping it in quarantine on a spare machine. All the VB 2005 projects that I have tried running inside Orcas have run without problem (as they should of course, because Orcas boasts multi-targetting of Framework versions 2, 3 and 3.5).

The Beta 1 LINQ samples for VB can be downloaded from here. Speaking of LINQ, I'm hoping to get the third part of my LINQ To Objects article finished by the weekend, before moving on to exploring other areas of LINQ .

LINQ To Objects - Part 2

Ged Mead — Thu, 10 May 2007 14:44:00 GMT

Let's Run Some Queries!

By the end of Part 1 we set the stage and looked at a couple of new features coming up in Orcas, but hadn't done anything particularly exciting and new with LINQ To Objects. In this Part I'll hopefully whet your appetite for LINQ a little bit more as we run some queries that are (a) very easy with LINQ and (b) nowhere near as easy with VB 2005 and earlier edition tools. (And later in Part 3 you'll really be able to see the future according to LINQ!)

Let's begin with a query that finds all the Person objects in our Person List who are under 21 and who live in Belgium. The LINQ version of such a query is:

Code Copy

  Dim People() As Person

  Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
  Handles Button1.Click
    Dim YoungBelgians = From P In People _
       Where P.DateOfBirth > #12/12/1978# AndAlso P.Country = "Belgium" _
       Select p

    Console.WriteLine("Young Belgians:")
      For Each Youth In YoungBelgians
          Console.WriteLine(Youth.Forename & " " & Youth.Surname)
      Next
End Sub

In the above example (and those that follow) I used a small collection of pre-created Person objects. If you want the code for this in order to try the queries yourself, it looks like this:

Code Copy

  Function CreateDataVB9_3() As Array

      Dim SomePeople() As Person = {New Person With {.Forename = "Jan", .Surname = "Urqhart", _
                   .DateOfBirth = #9/8/1959#, .Gender = Gender.Female, _
                   .Country = "Belgium", .HomeTown = "Ghent"}, _
           New Person With {.Surname = "Fleischmann", .Forename = "Heinje", .Country = "Belgium", _
                   .Gender = Gender.Male, .DateOfBirth = #7/11/1982#, .HomeTown = "Mons"}, _
           New Person With {.HomeTown = "Leeds", .Forename = "Ken", .Surname = "Browning", _
                   .Gender = Gender.Male, .DateOfBirth = #3/9/1978#}, _
           New Person With {.Forename = "Sandi", .Surname = "Skeet", .DateOfBirth = #4/9/1981#, _
                   .Gender = Gender.Female, .Country = "UK", .HomeTown = "Manchester"}, _
           New Person With {.Forename = "Janet", .Surname = "Brent", _
                    .DateOfBirth = #9/12/1969#, .Gender = Gender.Female, _
                    .Country = "Belgium", .HomeTown = "Antwerp"}, _
           New Person With {.Forename = "Ged", .Surname = "Mead", .DateOfBirth = #11/24/1946#, _
                    .HomeTown = "Dumfries", .Country = "UK"}, _
           New Person With {.Forename = "Sylvie", .Surname = "Swanson", _
                    .DateOfBirth = #12/1/1977#, .Gender = Gender.Female, _
                    .Country = "UK", .HomeTown = "Manchester"}, _
           New Person With {.Forename = "Freddie", .Surname = "Foggin", .DateOfBirth = #4/14/1958#, _
                    .HomeTown = "York", .Country = "UK"}, _
           New Person With {.Forename = "Johannes", .Surname = "LeBon", _
                    .DateOfBirth = #10/8/1978#, .Gender = Gender.Male, _
                    .Country = "Belgium", .HomeTown = "Aachen"}, _
           New Person With {.Forename = "William", .Surname = "Birchley", _
                    .DateOfBirth = #7/8/1959#, .Gender = Gender.Male, _
                    .Country = "UK", .HomeTown = "Leeds"}, _
           New Person With {.Forename = "Sarah", .Surname = "Wilkinson", _
                    .DateOfBirth = #10/18/1990#, .Gender = Gender.Female, _
                    .Country = "UK", .HomeTown = "Manchester"}, _
           New Person With {.Forename = "Frank", .Surname = "Whittle", _
                    .DateOfBirth = #1/8/1993#, .Gender = Gender.Male, _
                    .Country = "UK", .HomeTown = "Manchester"}, _
           New Person With {.Forename = "Natalie", .Surname = "Hebber", _
                    .DateOfBirth = #2/28/1986#, .Gender = Gender.Female, _
                    .Country = "Belgium", .HomeTown = "Ghent"}, _
           New Person With {.Forename = "Franc", .Surname = "Mendler", _
                     .DateOfBirth = #10/8/1990#, .Gender = Gender.Male, _
                     .Country = "Belgium", .HomeTown = "Aachen"}, _ 
     New Person With {.Forename = "Marc", .Surname = "Goosens", _
                     .DateOfBirth = #9/9/1989#, .Gender = Gender.Male, _
                     .Country = "Belgium", .HomeTown = "Ghent"}, _ 
     New Person With {.Forename = "Pauline", .Surname = "Pearson", .DateOfBirth = #12/19/1989#, _
                     .Gender = Gender.Female, .Country = "UK", .HomeTown = "Leeds"}, _ 
     New Person With {.Forename = "Jim", .Surname = "Burnley", .DateOfBirth = #1/29/1981#, _
                     .Gender = Gender.Male, .Country = "UK", .HomeTown = "Manchester"}}

        Return SomePeople
    End Function

And to populate the People array with that data, you would just call it with:

People = CreateDataVB9_3()

If you have read the first part of this article, you will know that the above code uses some of the new features that will be available in VB 9, in particular the extended use of the With keyword and a new style of array initialization.

Taking this query a step further, it is very easy to sort the list of Young Belgians alphabetically by surname:

Code Copy

       Dim YoungBelgians = From P In People _
          Where P.DateOfBirth > #12/12/1978# AndAlso P.Country = "Belgium" _
          Order By P.Surname _
          Select p

        Console.WriteLine("Young Belgians:")
        For Each Youth In YoungBelgians
            Console.WriteLine(Youth.Surname & ", " & Youth.Forename)
        Next

The resulting display will be:

Young Belgians:
Fleischmann, Heinje
Goosens, Marc
Hebber, Natalie
Mendler, Franc

By the way, here's a little Gotcha that's worth watching out for: If you try the code out and you see the following error:-

'Select Case' must end with a matching 'End Select'

this will be because you forgot to add the underscore at the end of the previous line. Been there, done that!

With LINQ you can sort and sub-sort all on one line. This time we will return all Persons and sort them first by Gender and then by Surnames within each Gender. The LINQ code is trivial:

Code Copy

    Dim AllPersons = From P In People _
           Order By P.Gender, P.Surname _
           Select P

    Console.WriteLine("All Persons (Sorted):")
        For Each SortedPerson In AllPersons
            Console.WriteLine(SortedPerson.Forename & " " & SortedPerson.Surname)
        Next

The output from this looks like this:

All Persons (Sorted):
Janet Brent
Natalie Hebber
Pauline Pearson
Sandi Skeet
Sylvie Swanson
Jan Urqhart
Sarah Wilkinson
William Birchley
Ken Browning
Jim Burnley
Heinje Fleischmann
Marc Goosens
Johannes LeBon
Franc Mendler
Frank Whittle
Freddie Foggin
Ged Mead

The output is correct. First the Females(7), then the Males(8) and finally those that weren't assigned a value for Gender when the collection was created(2). But it's not particularly well formatted, is it? What would be good would be to group them, each with their Gender Heading. This will be possible using the "Group By" operator. Unfortunately at the time of writing this feature isn't implemented in VB, but I'll revisit this item and update it when it is - either via a later Beta or the final version when it is released.

For now, I'll settle for:

Code Copy

        Dim AllPersons = From P In People _
             Order By P.Gender, P.Surname _
             Select P

        Console.WriteLine("All Persons (Sorted):")
        For Each SortedPerson In AllPersons
            Console.WriteLine(SortedPerson.Forename & " " & _
                SortedPerson.Surname & " : " & SortedPerson.Gender.ToString)
        Next

which does make things clearer, even if it's not ideal.

It's also easy to have multiple Where operators in the same query. Take a case where you wanted to identify all those over 21 who live in either Leeds or Ghent. The query would be:

Code Copy

Dim AllPersons = From P In People _
      Where P.HomeTown = "Leeds" _
         Or P.HomeTown = "Ghent" _
      Where P.DateOfBirth < #1/1/1987# _
         Order By P.DateOfBirth Descending _
Select P

Notice also that this query sorts the names in date of birth descending order so the youngest person will be listed first, which is more intuitive. The following code snippet displays the result to the console. (The CalculateAge method isn't relevant to the LINQ query as such, but as it is available in the Person Class created earlier I've used it to improve the output for the user.)

Code Copy

  Console.WriteLine("All Persons (Over 21 From Leeds and Ghent):")
     For Each TwinTownPerson In AllPersons
        Console.WriteLine(TwinTownPerson.Forename & " " & _
            TwinTownPerson.Surname & " : " & CStr(Person.CalculateAge(TwinTownPerson.DateOfBirth, Now)) & "  -  " & TwinTownPerson.HomeTown)
     Next

The output is:-
All Persons (Over 21 From Leeds and Ghent):
Natalie Hebber : 21 - Ghent
Ken Browning : 29 - Leeds
Jan Urqhart : 47 - Ghent
William Birchley : 47 - Leeds

Several of the more interesting operators are still not implemented at the time of writing. Group By, as mentioned earlier and also Join, which obviously is going to be a very powerful tool in LINQ queries. I have also seen samples which appear to use Into, but I haven't been able to implement that either in my March CTP version.

I plan to include samples that will demonstrate all of these and more as they come onstream. In the meantime, the next and (for the time being) final part of LINQ To Objects we will look at how to join two data sources and run a query against them.

LINQ To Objects : Part 1

Ged Mead — Sun, 29 Apr 2007 17:06:00 GMT

There's no doubt that LINQ is one of the headline features of Visual Studio Orcas. I've been trying out some LINQ queries; it's a very interesting new area with massive potential. It seems though that most books and articles available at the moment are C# based, so I thought I'd blog my journey through the Land of LINQ in case any other VB DotNetters might find it useful now or in the future.

I'm currently using The March CTP of Orcas for the samples I will demonstrate in these blogs. If you want to dip into LINQ but don't want to install the CTP or the Betas as they come on stream, you can get limited access to LINQ features in VB 2005 via the .NET LINQ Tech Preview (May 2006) .

The 10 Second Version of "What is LINQ?"

I've seen answers to that question that run to several pages. Hopefully by the end of this series of articles, you will have formed your own opinion, but to get us started, here's the 10 second version.

LINQ is a tool that will enable you to use the same coding techniques to run queries against a wide range of types of data storage - e.g. simple arrays, collections of complex objects, XML and relational databases. It looks a lot like SQL, but isn't actually SQL. Many of the queries you can run against collections will be far less verbose than the hoops (and loops!) you would have to jump through to get the same results without LINQ.

For now, this is enough information. We will of course have to look into the whys and hows of LINQ as we dig deeper into the topic.

Some Data To Work With

The kind of data that is most appropriate for LINQ To Objects demos is something fairly basic but which still has enough content to be useful for the range of queries I plan to demonstrate. I wanted to stay away from the Products type of data because I want to use that in the LINQ to SQL article (probably utilising Northwind). So in the end I decided on an old favourite for demos - the Person class. This Class has a couple of constructors and six Properties - Forename, Surname, DateOfBirth, Gender, HomeTown and Country. If you want to see the code for this class, it is available here.

Before we look at the first LINQ queries, I want to briefly run through some of the ways we create instances of objects (in this case Person instances) and, more importantly, how to create collections of those instances.

Creating Instances Of Complex Objects

In VB 2005 there are various ways of creating new instances of the Person Class. The common ones are shown in the code sample below:

Code Copy HideScrollFull

Module CreateData
    Dim People As List(Of Person)
    Function CreateDataVB8_1() As List(Of Person)
        '  One of the VB8 ways
        People = New List(Of Person)

        Dim P As New Person
        P.Forename = "Peter"
        P.Surname = "Gray"
        P.Gender = Gender.Male
        P.Country = "UK"
        P.HomeTown = "Leeds"
        P.DateOfBirth = New DateTime(1966, 1, 12)
        People.Add(P)

        Return People
    End Function

    Function CreateDataVB8_2() As List(Of Person)
        '  One of the VB8 ways
        People = New List(Of Person)

        Dim P2 As New Person
        With P2
            .Forename = "Zoe"
            .Surname = "Gray"
            .Gender = Gender.Female
            .Country = "UK"
            .HomeTown = "Wakefield"
            .DateOfBirth = New DateTime(1969, 7, 3)
        End With
        People.Add(P2)
        Return People
    End Function

    Function CreateDataVB8_3() As List(Of Person)
        '  One of the VB8 ways - Overloaded Constructor
        People = New List(Of Person)

        Dim P3 As New Person("David", "Sedding", Gender.Male)
        People.Add(P3)
        P3 = New Person("Ricky", "Livid", Gender.Male)
        People.Add(P3)
        Return People
    End Function

End Module

VB9's language enhancements bring some more options in this area. Some of them may seem to be low on the Wow! factor, but they become more important and more useful as you get further into the whole LINQ scenario.

One way is to create a new instance and assign values to properties at the same time:-

Code Copy HideScrollFull

Dim P4 As New Person With {.Forename = "Sandi", .Surname = "Skeet", _
       .DateOfBirth = #12/2/1962#, .Gender = Gender.Female, _
       .HomeTown = "Dover", .Country = "UK"}

Note the use of the "With" keyword which is an extension of the current way of using With.

Not a million miles away from achieving the same result with an overloaded constructor, you may think. However, there are some subtle benefits. One is that you can assign values to the properties in any order. Another, possibly more useful, is that you can assign values to only those properties you are interested in at the time of initialization.

Code Copy HideScrollFull

P4 = New Person With {.HomeTown = "Leeds", .Forename = "Ken", _

           .Surname = "Browning", _
           .Gender = Gender.Male, .DateOfBirth = #3/9/1978#}

That said, these benefits are really a side product. This style of object initialization has been built into VB9 for technical reasons that will become clear later.

Creating Collections Of Complex Object Instances

As you know, you can create instances of the Person class and add them to a collection. A List (Of Person) for example:

VB 2005

Code Copy HideScrollFull

Dim People As New List(Of Person)

   Dim P As New Person
        P.Forename = "Peter"
        P.Surname = "Gray"
        P.Gender = Gender.Male
        P.Country = "UK"
        P.HomeTown = "Leeds"
        P.DateOfBirth = New DateTime(1966, 1, 12)
People.Add(P)

VB 9 (ORCAS)

Code Copy HideScrollFull

Dim PersonList As New List(Of Person)
    '  Object Initializer way:
    Dim P4 As New Person With {.Forename = "Sandi", .Surname = "Skeet", _
       .DateOfBirth = #12/2/1962#, .Gender = Gender.Female, _
       .HomeTown = "Dover", .Country = "UK"}

   PersonList.Add(P4)
    '  Note that the Properties can be set in totally random order,
    '  unlike parameters.
    P4 = New Person With {.HomeTown = "Leeds", .Forename = "Ken", _
         .Surname = "Browning", .Gender = Gender.Male, _
         .DateOfBirth = #3/9/1978#, .Country = "UK"}

PersonList.Add(P4)

The second example above is a kind of halfway house between VB8 and VB9. There are other ways available in VB9. You can initialize New Person instances, assign values to any or all properties and then add that instance to the collection:

Code Copy HideScrollFull

Dim SomePeople() As Person = _
       {New Person With {.Forename = "Jan", .Surname = "Urqhart", _
         .DateOfBirth = #9/8/1959#, .Gender = Gender.Female, _
         .Country = "Belgium", .HomeTown = "Ghent"}, _
       New Person With {.Surname = "Fleischmann", .Forename = "Heinje", .Country = "Belgium", _
         .Gender = Gender.Male, .DateOfBirth = #7/11/1982#, .HomeTown = "Mons"}} 
 

The With keyword is used again in the above example to assign values to properties. You will see that it creates an array of Person instances and that I included the identifier "As Person" in the first line. However, VB9 goes further and the compiler is able to infer what Type the array will contain by looking at the Type you populate it with. So the following version of the above snippet will compile without error and the SomePeople array will be correctly typed as Person type.

Code Copy HideScrollFull

Dim SomePeople() = _
       {New Person With {.Forename = "Jan", .Surname = "Urqhart", _
         .DateOfBirth = #9/8/1959#, .Gender = Gender.Female, _
         .Country = "Belgium", .HomeTown = "Ghent"}, _
       New Person With {.Surname = "Fleischmann", .Forename = "Heinje", .Country = "Belgium", _
         .Gender = Gender.Male, .DateOfBirth = #7/11/1982#, .HomeTown = "Mons"}}

In case you were wondering if this is Late Binding the array to the Person Type, this is definitely not the case. It's important to note that this array is Early Bound. This feature is known as Local Type Inference, one of the language enhancements in VB9. And, as with the new initialization techniques, the underlying reason for this feature being included is also for technical reasons to help make LINQ work and not just to add yet one more way of creating a new collection.

At Last! A LINQ Query Example

Although we still have several important language enhancements to cover, we can at this stage run a simple LINQ query. A LINQ query is a sequence of clauses, each clause containing a Query Operator. Query Operators include From, Where, Select, Join, Group By, etc, all of which are familiar sounding keywords if you have used SQL.

The following example creates and initializes an array of Person instances using the above technique. It then runs a simple LINQ query to find all Persons who have a birthday this month.

Code Copy HideScrollFull

        '  Create Data
        Dim PersonList() = _
          {New Person With {.Forename = "Jan", .Surname = "Urqhart", _
             .DateOfBirth = #6/6/1959#, .Gender = Gender.Female, _
             .Country = "Belgium", .HomeTown = "Ghent"}, _
           New Person With {.Surname = "Fleischmann", .Forename = "Heinje", _
             .Country = "Belgium", .Gender = Gender.Male, _
             .DateOfBirth = #5/15/1982#, .HomeTown = "Mons"}, _
           New Person With {.Forename = "Sandi", .Surname = "Skeet", _
             .DateOfBirth = #6/15/1962#, .Gender = Gender.Female, _
             .HomeTown = "Dover", .Country = "UK"}, _
           New Person With {.HomeTown = "Leeds", .Forename = "Ken", .Surname = "Browning", _
              .Gender = Gender.Male, .DateOfBirth = #5/9/1978#, .Country = "UK"}}

        '  Run LINQ Query
        Dim BirthdayPeople = From p In PersonList _
            Where p.DateOfBirth.Month = Now.Month _
            Select p

        '  Display results of query
        If BirthdayPeople.Count > 0 Then
            For Each p In BirthdayPeople
                Console.WriteLine("Happy Birthday,  " & p.Forename)   '& "  :  " & p.DateOfBirth.ToLongDateString)
            Next
        Else
            Console.WriteLine("No Birthdays this month")
        End If

Note that the query again uses Local Type Inference to decide that the Type of the collection is Person as it creates BirthdayPeople and also that p is a Person Type, because p is an element in a list of Persons.

The query itself is very simple; using the Where query operator it filters in any Person instance where the DateOfBirth's month property is the same as the current month.

The final line of this query uses the Select Operator to project or collect the matching entries into the BirthdayPeople collection. Note the order of "Where" and "Select" in this LINQ query; it is the reverse of the syntax you would usually use for SQL queries against a database. This is one of the possible Gotchas you will need to keep in mind as you begin using LINQ, but you will in fact find that the IDE syntax editor will bark at you if try using "Select" before "Where".

Once the query has been run, the final code block displays the results in a console window.

Next Steps

A very basic LINQ query there which, to be fair, would be just as easy to create using a simple For Next Loop.

Code Copy HideScrollFull

  Dim BirthdayPeople As New List(Of Person)
        For Each P As Person In People
            If P.DateOfBirth.Month = Now.Month Then
                BirthdayPeople.Add(P)
            End If
        Next

        If BirthdayPeople.Count > 0 Then
            For Each bp As Person In BirthdayPeople
                Console.WriteLine("Happy Birthday,  " & bp.Forename)
            Next
        End If

So, if at this point you are asking yourself what all the fuss and excitement is about, don't worry, there is more, so much more, to come. This relatively slow start is just meant to set the scene. What about a query that selects all Males who do not live in the UK, grouped by Country, sorted ascending by Surname then Forename? Try that with a For Next Loop or two

Or a query that selects all Persons over the age of 21, use a Join to a second collection which contains the names of towns where courses are currently available and produces a list of names of eligible people to invite to a course in their home town. Grouped by Towns. Sorted alphabetically. Now, once you start to move into that kind of territory you can see how powerful LINQ queries will be.

We will look at more complex LINQ To Objects queries in the next part of this article.