Using LINQ to Objects in Visual Basic

Scott Lysle
Nov 09, 2012

9.5k
0
0
- facebook
- twitter
- linkedIn
- Reddit
- WhatsApp
- Email
- Print
- Other Artcile

Introduction

This article provides an introduction to employing LINQ to Objects queries to support a simple win forms application; the article addresses the construction of LINQ to Objects statements and then goes on to describe how one might use LINQ to Objects within the context of an actual application.

The demonstration project included with the article is a simple contact manager which may be used to capture and store information about a person's contacts in address book format. This demonstration application uses LINQ to Objects to manage, query, and order the list of contacts maintained by the application. The demonstration application also includes a dummy contact file with a collection of test contacts.

Figure 1: Application Main Form

The application provides the following functionality:

Create a contact data file.
Add contacts to the contact data file.
Remove contacts from the contact data file.
Search for specific contacts by last name.
Create and edit details about the contact.
- First Name
- Middle Name
- Last Name
- Street
- City
- State
- Zip Code
- Home Phone
- Work Phone
- Cell Phone
- Email Address

Save a contact data file.

Reopen a contact data file.

Navigate through all of the contacts in the contact data file.

View a list of all contacts in the contact data file.
Provide a Rolodex function (search by starting letter of last name)

Naturally, the approaches used within the application are representative of only one way of doing things; as with most things in the .NET world, there are several alternatives and you can modify the code to work with the data using one of the other alternatives if you prefer to do so.

Figure 2: Searching for a Contact by Last Name

Figure 3: Listing All Contacts (Edits to the grid are posted immediately to the List)

Figure 4: Rolodex Function

LINQ to Objects Statements

This section will discuss some of the common techniques used in LINQ to Objects statement construction. In a nutshell, LINQ to Objects provides the developer with the means to conduct queries against an in-memory collection of objects. The techniques used to query against such collections of objects are similar to but simpler than the approaches used to conduct queries against a relational database using SQL statements.

Anatomy of LINQ to Objects Statements

Example 1 ï¿½ A Simple Select

This is an example of a very simple LINQ to Objects statement:

Public Sub Example1()

Dim tools() As String = {"Tablesaw", "Bandsaw", "Planer", "Jointer", "Drill",

"Sander"}

Dim List = From t In tools _

Select t

Dim sb As New StringBuilder()

Dim s As String

For Each s In List

sb.Append(s + Environment.NewLine)

MessageBox.Show(sb.ToString(), "Tools")

End Sub

In the example, an array of strings (tools) is used as the collections objects to be queries using LINQ to Objects; the LINQ to Objects query is:

Dim List = From t In tools _

Select t

In this example, an untyped variable "List" is created and all of the items contained in the string array are added to this object; the types are inferred (implicitly typed), for example, "t" is a member of tools, since it is known that tools is a string array, the framework will infer that "t" is also a string. Of course this is not all that terrific since you can just iterate through the array to do essentially the same thing; however, you can create more complex queries with LINQ to Objects and then the value of the LINQ library becomes more apparent.

If you were to create a project, add this bit of code to a method and run it, the results would look like this:

Figure 5: Query Results

Example 2 ï¿½ Select with a Where Clause

The next example shows a LINQ to Objects query that incorporates a where clause. In this example, we start out with a collection of birds in the form of a string array; LINQ to Objects is used to query this string array to find and return a subset of the array in the form of all birds with names beginning with the letter "R".

Public Sub Example2()

Dim Birds() As String = {"Indigo Bunting", "Rose Breasted Grosbeak", _

"Robin", "House Finch", "Gold Finch", _

"Ruby Throated Hummingbird", _

"Rufous Hummingbird", "Downy Woodpecker"}

Dim list = From b In Birds _

Where b.StartsWith("R") _

Select b

Dim sb As New StringBuilder()

Dim s As String

For Each s In list

sb.Append(s + Environment.NewLine)

MessageBox.Show(sb.ToString(), "R Birds")

End Sub

If you were to run this query, the results would appear as follows (all birds with names beginning with the letter "R" are shown):

Figure 6: R Birds Query Results

Example 3 ï¿½ Select with a Where Clause

In a slight variation to the previous query, this example looks for an exact match in its where clause:

Public Sub Example3()

Dim Birds() As String = {"Indigo Bunting", "Rose Breasted Grosbeak", _

"Robin", "House Finch", "Gold Finch", _

"Ruby Throated Hummingbird", _

"Rufous Hummingbird", "Downy Woodpecker"}

Dim list = From b In Birds _

Where b = "Indigo Bunting" _

Select b

Dim sb As New StringBuilder()

Dim s As String

For Each s In list

sb.Append(s + Environment.NewLine)

MessageBox.Show(sb.ToString(), "Bunting Birds")

End Sub

Running this code will result in the display of this message box:

Figure 7: Bird Query Results

Example 4 ï¿½ Generating an Ordered List

In this query, the list of birds is alphabetized (using "Order By b Ascending"):

Public Sub Example4()

Dim Birds() As String = {"Indigo Bunting", "Rose Breasted Grosbeak", _

"Robin", "House Finch", "Gold Finch", _

"Ruby Throated Hummingbird", _

"Rufous Hummingbird", "Downy Woodpecker"}

Dim list = From b In Birds _

Order By b Ascending _

Select b

Dim sb As New StringBuilder()

Dim s As String

For Each s In list

sb.Append(s + Environment.NewLine)

MessageBox.Show(sb.ToString(), "Ordered Birds")

End Sub

Figure 8: Ordered Bird List Query Results

Example 5 ï¿½ Working with a Custom Type

In this example, a typed list is created, populated, and then queried using LINQ to Objects.

Public Sub Example5()

Dim parts = New List(Of Parts)

Dim p1 As New Parts()

p1.PartNumber = 1

p1.PartDescription = "Cog"

parts.Add(p1)

Dim p2 As New Parts()

p2.PartNumber = 2

p2.PartDescription = "Widget"

parts.Add(p2)

Dim p3 As New Parts()

p3.PartNumber = 3

p3.PartDescription = "Gear"

parts.Add(p3)

Dim p4 As New Parts()

p4.PartNumber = 4

p4.PartDescription = "Tank"

parts.Add(p4)

Dim p5 = New Parts()

p5.PartNumber = 5

p5.PartDescription = "Piston"

parts.Add(p5)

Dim p6 As New Parts()

p6.PartNumber = 6

p6.PartDescription = "Shaft"

parts.Add(p6)

Dim p7 As New Parts()

p7.PartNumber = 7

p7.PartDescription = "Pulley"

parts.Add(p7)

Dim p8 As New Parts()

p8.PartNumber = 8

p8.PartDescription = "Sprocket"

parts.Add(p8)

Dim list = From p In parts _

Order By p.PartNumber Ascending _

Select p

Dim sb As New StringBuilder()

Dim pt As Parts

For Each pt In parts

sb.Append(pt.PartNumber.ToString() + ": " + _ pt.PartDescription.ToString() + _

Environment.NewLine)

MessageBox.Show(sb.ToString(), "Parts List")

End Sub

The purpose the query is merely to sort the parts list in order of the part numbers. The results returned from this method are as follows:

Figure 9: Ordered Parts List Query

The parts class used in as the type behind the parts list is as follows:

Public Class Parts

Private mPartNumber As Integer

Private mPartDescription As String

Public Sub New()

' nothing

End Sub

Public Sub New(ByVal partNum As Integer, ByVal partDesc As String)

mPartNumber = partNum

mPartDescription = partDesc

End Sub

Public Property PartNumber() As Integer

Get

Return mPartNumber

End Get

Set(ByVal value As Integer)

mPartNumber = value

End Set

End Property

Public Property PartDescription() As String

Get

Return mPartDescription

End Get

Set(ByVal value As String)

mPartDescription = value

End Set

End Property

End Class

Example 6 ï¿½ Searching a Typed List Using LINQ to Objects

In this example, a typed list is created (as in the previous example), populated, and then queried using LINQ to Objects. In this case, the query includes a where clause that only returns matches were the part description begins with the letter "S":

Dim list = From p In parts _

Where p.PartDescription.StartsWith("S") _

Order By p.PartNumber Ascending _

Select p

Dim sb As New StringBuilder()

Dim pt As Parts

For Each pt In list

sb.Append(pt.PartNumber.ToString() + ": " _

+ pt.PartDescription.ToString() + _

Environment.NewLine)

Next
MessageBox.Show(sb.ToString(), "Parts List")

Figure 10: Matching Parts Query Results

Example 7 ï¿½ Searching a Typed List Using LINQ to Objects and Returning a Single Result

In this example, a typed list is created (as in the previous example), populated, and then queried using LINQ to Objects. In this case, returns a single result of type "Parts":

Dim matchingPart = (From m In list _

Where m.PartNumber.Equals(5) _

Select m).Single()

MessageBox.Show(matchingPart.PartDescription, "Matching Part")

The results of this query are shown in the next figure.

Figure 11: Returning a Single Result

The preceding examples were intended to provide a simple overview as to how to conduct some basic queries against collections using LINQ to Objects; there are certainly a great number of more complex operations that can be executed using similar procedures (grouping, joins and selects into a new custom type, etc.).

Getting Started

There is a single solution included with this download, the solution contains a Win Forms project called "LinqToObjectsVB"; this project contains two forms (the main form (frmContactBook) and a form used to display the total list of contacts (frmFullList), a serializable class called 'Contact' (used to contain contact related data), and a class entitled, 'Serializer' which contains two static methods used to serialize and deserialize the contact data (writing it to and reading it from a file) .

If you open the attached project into Visual Studio 2008; you should see the following in the solution explorer:

Figure 12: Solution Explorer

Code: Contact.vb

The Contact class is the container class used to store all of the contact related data used in the application. Whilst this demonstration uses contact data, this could easily be replaced with something more useful to you.

The class begins with the normal and default imports:

Imports System

Imports System.Collections.Generic

Imports System.Linq

Imports System.Text

The next section contains class declaration. Note that the class is declared as serializable; the serializable attribute indicates that the class can be serialized.

<Serializable()> _

Public Class Contact

The region defined in the class declares the member variables used internally by the class; any member variables exposed externally are made accessible through public properties.

#Region "Member Variables"

Private mId As System.Guid

Private mFirstName As String

Private mMiddleName As String

Private mLastName As String

Private mStreet As String

Private mCity As String

Private mState As String

Private mZip As String

Private mEmail As String

Private mHousePhone As String

Private mWorkPhone As String

Private mCellPhone As String

Private mFax As String

#End Region

The next region of code in the class contains the constructors. Two constructors are defined; a default constructor that creates a new instance of the class and assigns it an internal ID (as a Guid). The second constructor accepts an ID as an argument and sets the contact's internal ID to that value.

#Region "Constructor"

Public Sub New()

mId = Guid.NewGuid()

End Sub

Public Sub New(ByVal ID As System.Guid)

mId = ID

End Sub

#End Region

The last bit of the code in this class is contained within the properties region; this region contains all of the properties defined to access the member variables. Note that since the ID value is always set by the constructor, the property does not provide a public interface to set the Guid to a new value.

#Region "Properties"

Public Property FirstName() As String

Get

Return mFirstName

End Get

Set(ByVal value As String)

mFirstName = value

End Set

End Property

Public Property MiddleName() As String

Get

Return mMiddleName

End Get

Set(ByVal value As String)

mMiddleName = value

End Set

End Property

Public Property LastName() As String

Get

Return mLastName

End Get

Set(ByVal value As String)

mLastName = value

End Set

End Property

Public Property Street() As String

Get

Return mStreet

End Get

Set(ByVal value As String)

mStreet = value

End Set

End Property

Public Property City() As String

Get

Return mCity

End Get

Set(ByVal value As String)

mCity = value

End Set

End Property

Public Property State() As String

Get

Return mState

End Get

Set(ByVal value As String)

mState = value

End Set

End Property

Public Property ZipCode() As String

Get

Return mZip

End Get

Set(ByVal value As String)

mZip = value

End Set

End Property

Public Property Email() As String

Get

Return mEmail

End Get

Set(ByVal value As String)

mEmail = value

End Set

End Property

Public Property HousePhone() As String

Get

Return mHousePhone

End Get

Set(ByVal value As String)

mHousePhone = value

End Set

End Property

Public Property WorkPhone() As String

Get

Return mWorkPhone

End Get

Set(ByVal value As String)

mWorkPhone = value

End Set

End Property

Public Property CellPhone() As String

Get

Return mCellPhone

End Get

Set(ByVal value As String)

mCellPhone = value

End Set

End Property

Public Property Fax() As String

Get

Return mFax

End Get

Set(ByVal value As String)

mFax = value

End Set

End Property

#End Region

End Class

That concludes the description of the 'Contact' class.

Code: Main Application Form (frmContactBook.vb)

The is the main form of the application; much of the code provides the framework for the application and does not really pertain to LINQ to Objects, however, all of the code will be described herein to provide a proper context.

The contact application's main form contains the following controls:

File
- New
- Open
- Save
- Save As
- Exit
Contacts
- Add Contact
- Remove Contact
- List All Contacts

Toolbar

Add
Remove
Find by Last Name
Save Data
Navigate to Previous Contact
Navigate to Next Bird Contact
Exit Application

Split Container Left Hand Side

Alphabet List
Alphabetized Names List

Split Container Right Hand Side

First name text box control

Middle name text box control

Last name text box control

Street text box control

City text box control

State text box control

Zip code text box control

Home phone number text box control

Work phone number text box control

Cell number text box control

Fax number text box control

Email address text box control

Figure 13: frmContactBook.vb

The class begins with the normal and default imports:

Imports System

Imports System.Collections.Generic

Imports System.ComponentModel

Imports System.Data

Imports System.Drawing

Imports System.Linq

Imports System.Text

Imports System.Windows.Forms

The next section contains the class declaration.

Public Class frmContactBook

The next region defined in the class declares the member variables used internally by the class; any member variables exposed externally are made accessible through public properties. The comment adjacent to each declaration describes its purpose.

#Region "Member Variables"

Private contacts As New List(Of Contact) ' create a typed list of contacts

Private currentContact As Contact ' create a single contact instance

Private currentPosition As Integer ' used to hold current position

Private currentFilePath As String ' file path to current contact file

Private dirtyForm As Boolean ' keep track of dirty forms

#End Region

The next region of code in the class contains the constructor. Upon initialization, the application creates a new contact data list, creates a new contact data object, sets the current position indicator to zero, and sets the dirty form Boolean to false.

#Region "Constructor"

''' <summary>

''' Constructor - create a new instance of

''' the contact list and setup the local

''' member variables

''' </summary>

''' <remarks></remarks>

Public Sub New()

' This call is required by the Windows Form Designer.

InitializeComponent()

' Add any initialization after the InitializeComponent() call.

contacts = New List(Of Contact)

currentContact = New Contact()

contacts.Add(currentContact)

currentPosition = 0

dirtyForm = False

End Sub

#End Region

The next code region is called 'Toolstrip Event Handlers'; the first event handler in this region is the click event handler for the Add button; this method merely calls the menu control's click event handler and the code contained in that event handler adds a new contact to the current contact data.

#Region "Toolstrip Event Handlers"

''' <summary>

''' Add a new contact to the current contact list

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles tsbAddRecord.Click

Me.addToolStripMenuItem_Click(Me, New EventArgs())

End Sub

The next click event handler is used remove the current contact from the contact list when the user clicks the toolstrip's remove record button; again, this method merely calls the matching menu item function.

''' <summary>

''' Remove the current contact from the contact list

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles tsbRemoveRecord.Click

Me.removeToolStripMenuItem_Click(Me, New EventArgs())

End Sub

The next handler is used to search for a specific contact using the contact's last name. The code uses a LINQ to Objects query in order to find the first instance of a matching contact with that last name. The handler uses the search term text box control on the toolstrip to capture the last name and it uses the search button to execute the search. The code is annotated to describe what is going on in this method.

''' <summary>

''' Find a contact by searching the list

''' for a matching last name

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles tsbFindContact.Click

' return if the search term was not provided

If (String.IsNullOrEmpty(tspSearchTerm.Text)) Then

MessageBox.Show("Enter a last name in the space proved.", _

"Missing Search Term")

Return

End If

Try

' using linq to objects query to get first matching name

Dim foundGuy = _

(From contact In contacts _

Where contact.LastName = tspSearchTerm.Text _

Select contact).FirstOrDefault()

' set the current contact to the found contact

currentContact = foundGuy

currentPosition = contacts.IndexOf(currentContact)

' update the display by loading the

' found contact

LoadCurrentContact()

' clear the search term textbox and return

tspSearchTerm.Text = String.Empty

Return

Catch

MessageBox.Show("No matches were found", "Search Complete")

End Try

End Sub

The next handler saves the current contact list, this handler just calls the matching menu click event handler.

''' <summary>

''' Save the current contact list

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles tsbSave.Click

Me.saveStripMenuItem_Click(Me, New EventArgs())

End Sub

The next handler is used to navigate back one contact from the current position of the displayed contact. If the contact as at the lower limit; the button click is ignored.

''' <summary>

''' Navigate back to the previous record

''' if not at the lower limit

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles tsbNavBack.Click

' capture form changes and plug them

' into the current contact before

' navigating off the contact

SaveCurrentContact()

' don't exceed the left limit

If (currentPosition <> 0) Then

currentPosition -= 1

currentContact = contacts(currentPosition)

LoadCurrentContact()

End If

End Sub

The next handler is used to navigate forward one contact from the current position of the displayed contact. If the contact as at the upper limit; the button click is ignored.

''' <summary>

''' Navigate to the next record if

''' not at the upper limit

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles tsbNavForward.Click

' capture form changes and plug them

' into the current contact before

' navigating off the contact

SaveCurrentContact()

' don't exceed the right limit

If (currentPosition < contacts.Count - 1) Then

currentPosition += 1

currentContact = contacts(currentPosition)

LoadCurrentContact()

End If

End Sub

The next handler is used to exit the application. This handler merely calls the matching menu item click event handler.

''' <summary>

''' Exit the application

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles tsbExit.Click

Me.exitToolStripMenuItem_Click(Me, New EventArgs())

End Sub

#End Region

The next region contains the menu item click event handlers. The next menu item click event handler creates a new contact list; before following through with the creation of the new contact list, this handler checks to see if the current form is dirty to allow the user the opportunity to save before closing the current list. Following that, the contact list is replaced with a new contact list and the form's controls are cleared.

#Region "Menu Item Click Event Handler"

''' <summary>

''' Create a new contact list and clear

''' the contact form

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles newToolStripMenuItem.Click

' check to see if the form has been editted

If dirtyForm = True Then

If (MessageBox.Show(Me, "You have not saved the current contact data; " + _

"would you like to save before starting a new " + _

"contact database?", "Save Current Data",

MessageBoxButtons.YesNo) = _

System.Windows.Forms.DialogResult.Yes) Then

' display the save dialog if the contact list is dirty

saveAsMenuItem_Click(Me, New EventArgs())

End If

Else

' discard the contact list and

' start new document

contacts = New List(Of Contact)

ClearScreen()

End If

End Sub

The next event handler is used to open a contacts file. Again, the handler checks to a dirty form and provides the user with an opportunity to save if the form is dirty. A separate open method is called to handle the actually file opening operation.

''' <summary>

''' Open an existing contact file

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles openToolStripMenuItem.Click

' give the user an opportunity to save the current

' contact list if the data has been edited

If dirtyForm = True Then

If (MessageBox.Show(Me, "You have not saved the current contact data; " + _

"would you like to save before opening a different " + _

"contact database?", "Save Current Data",

MessageBoxButtons.YesNo) = _

System.Windows.Forms.DialogResult.Yes) Then

saveAsMenuItem_Click(Me, New EventArgs())

End If

Else

' call the open function to open the file

Open()

End If

End Sub

The save menu item is used to save the current contacts file to disk; the function first calls a "SaveCurrentContact" which is used to save the current contact to the current contact data list. Next, the function uses the save file dialog to capture a file name if none is currently set to the "currentFilePath" variable, or, if the variable is set, it saves the file using that file path. The file is actually saved to disk when the call to serialize the file is made.

''' <summary>

''' Save the current contact list

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles saveStripMenuItem.Click

' save the current form data to the list

SaveCurrentContact()

' if the file path is not set, open the

' save file dialog

If String.IsNullOrEmpty(currentFilePath) Then

Dim SaveFileDialog1 As New SaveFileDialog()

Try

SaveFileDialog1.Title = "Save CON Document"

SaveFileDialog1.Filter = "CON Documents (*.con)|*.con"

If (SaveFileDialog1.ShowDialog() = _

System.Windows.Forms.DialogResult.Cancel) Then

Return

End If

Catch

Return

End Try

currentFilePath = SaveFileDialog1.FileName

End If

' make sure the file path is not empty

If String.IsNullOrEmpty(currentFilePath) Then

Return

End If

' persist the contacts file to disk

Serializer.Serialize(currentFilePath, contacts)

' tell the user the file was saved

MessageBox.Show("File " + currentFilePath + " saved.", "File Saved.")

' everything is saved, set the dirtyform

' boolean to false

dirtyForm = False

End Sub

The next bit of code us used to support the "Save As" menu item; the call is similar to the previous save method but straight opens the Save File dialog box to permit the user to name or rename the file.

''' <summary>

''' Save the current contact data as a file

''' under a new name

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles saveAsMenuItem.Click

' save the current form data to the contact list

SaveCurrentContact()

' create and show the save file dialog

Dim SaveFileDialog1 As New SaveFileDialog()

Try

SaveFileDialog1.Title = "Save CON Document As"

SaveFileDialog1.Filter = "CON Documents (*.con)|*.con"

If (SaveFileDialog1.ShowDialog() = _

System.Windows.Forms.DialogResult.Cancel) Then

Return

End If

Catch

Return

End Try

currentFilePath = SaveFileDialog1.FileName

' make sure the file path is set

If String.IsNullOrEmpty(currentFilePath) Then

Return

End If

' persist the contacts file to disk

Serializer.Serialize(currentFilePath, contacts)

' tell the user the file was saved

MessageBox.Show("File " + currentFilePath + " saved.", "File Saved.")

' everything is saved, set the dirtyform

' boolean to false

dirtyForm = False

End Sub

The next method exits the application but checks the dirty form Boolean prior to exiting to give the user a chance to save their edits.

''' <summary>

''' Exit the application

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles exitToolStripMenuItem.Click

If dirtyForm = True Then

If (MessageBox.Show(Me, "You have not saved the current contact data; " + _

"would you like to save before exiting?", "Save Current

Data", _

MessageBoxButtons.YesNo) =

System.Windows.Forms.DialogResult.Yes) Then

tsbSave_Click(Me, New EventArgs())

End If

Else

Application.Exit()

End If

End Sub

The next method is used to add a new contact to the current list of contacts; this method saves the current contact to the open list of contacts, creates a new contact and adds it to the list of contacts, clears the form, and marks the form as dirty:

''' <summary>

''' Add a new contact to the current

''' contact list

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

Private Sub addToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles addToolStripMenuItem.Click

SaveCurrentContact()

currentContact = New Contact()

contacts.Add(currentContact)

ClearScreen()

dirtyForm = True

End Sub

The next method removes the current contact from the list and updates the display.

''' <summary>

''' Remove the current contact from the

''' contact list and update the display

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles removeToolStripMenuItem.Click

' make sure there are records

If contacts.Count = 0 Then

' remove the current record

contacts.Remove(currentContact)

' check to see if the current

' position is at the limit

' and move up or down

' as required

If (currentPosition = 0) Then

currentPosition += 1

End If

Else

currentPosition -= 1

' reload the current contact

' from the new position

currentContact = contacts(currentPosition)

LoadCurrentContact()

' dirty the form since a

' record was removed

dirtyForm = True

End If

End Sub

The next method is used to open a separate form displaying all of the contacts in a data grid view control. This method constructs and ordered list and passes it to a new instant of the "frmFullList" class which binds the grid control to the list in its constructor.

''' <summary>

''' Display a list of all the contacts in a data grid

''' view control

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

Private Sub listAllContactsToolStripMenuItem_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) _

Handles

listAllContactsToolStripMenuItem.Click

' use linq to objects to create a list of contacts

' ordered by the contact's last name, first name,

' and middle name

Dim orderedCons = _

(From contact In contacts _

Order By contact.LastName Ascending, _

contact.FirstName Ascending, _

contact.MiddleName Ascending _

Select contact)

' create an instance of the full list form and pass it's

' constructor the list converted to a List

Dim f As New frmFullList(orderedCons.ToList())

f.Show()

End Sub

#End Region

The next region contains a garbage can collection of other methods maintained in a region entitled "Housekeeping":

#Region "Housekeeping"

The first method contained in this section is used to clear all of the text boxes used to display contact information. This is called anytime the current contact is changed to prevent remnants of one contact appearing the display of a replacement contact.

''' <summary>

''' Clear all of the fields in the form

''' </summary>

''' <remarks></remarks>

Private Sub ClearScreen()

txtFirstName.Text = String.Empty

txtMiddleName.Text = String.Empty

txtLastName.Text = String.Empty

txtStreet.Text = String.Empty

txtCity.Text = String.Empty

txtState.Text = String.Empty

txtZipCode.Text = String.Empty

txtHousePhone.Text = String.Empty

txtWorkPhone.Text = String.Empty

txtCellPhone.Text = String.Empty

txtFax.Text = String.Empty

txtEmailAddress.Text = String.Empty

tslViewWho.Text = String.Empty

End Sub

The next method is used to load the information contained in the current contact into the controls used to display contact information.

''' <summary>

''' Load the current contact into the form fields

''' </summary>

''' <remarks></remarks>

Private Sub LoadCurrentContact()

' update the form fields

txtFirstName.Text = currentContact.FirstName

txtMiddleName.Text = currentContact.MiddleName

txtLastName.Text = currentContact.LastName

txtStreet.Text = currentContact.Street

txtCity.Text = currentContact.City

txtState.Text = currentContact.State

txtZipCode.Text = currentContact.ZipCode

txtHousePhone.Text = currentContact.HousePhone

txtWorkPhone.Text = currentContact.WorkPhone

txtCellPhone.Text = currentContact.CellPhone

txtFax.Text = currentContact.Fax

txtEmailAddress.Text = currentContact.Email

' display the current user in the status bar

tslViewWho.Text = "Now Viewing " + txtFirstName.Text + " " + txtLastName.Text

End Sub

The next method captures all of the information currently on the form for the current contact and writes it into the current contact's properties. This is called whenever a contact is changed so that all edits to an existing contact are held within the local list until it can be written to disk. The method further updates the order of the contacts and updates the contact list and displayed contact.

''' <summary>

''' Save the form data to the current

''' contact, reorder the contact list,

''' and update the display

''' </summary>

''' <remarks></remarks>

Private Sub SaveCurrentContact()

If (Not String.IsNullOrEmpty(txtFirstName.Text) And _

(Not String.IsNullOrEmpty(txtLastName.Text))) Then

Try

' get all of the textbox values and

' plug them into the current contact object

currentContact.FirstName = txtFirstName.Text

currentContact.MiddleName = txtMiddleName.Text

currentContact.LastName = txtLastName.Text

currentContact.Street = txtStreet.Text

currentContact.City = txtCity.Text

currentContact.State = txtState.Text

currentContact.ZipCode = txtZipCode.Text

currentContact.HousePhone = txtHousePhone.Text

currentContact.WorkPhone = txtWorkPhone.Text

currentContact.CellPhone = txtCellPhone.Text

currentContact.Fax = txtFax.Text

currentContact.Email = txtEmailAddress.Text

' reorder the contacts by last, first, and

' middle name to keep everything in correct

' alphabetical order

Dim orderedContacts = _

(From contact In contacts _

Order By contact.LastName Ascending, _

contact.FirstName Ascending, _

contact.MiddleName Ascending _

Select contact).ToList()

' set the contacts list to the newly

' ordered list

contacts = orderedContacts

' update the current position index value

currentPosition = contacts.IndexOf(currentContact)

' reload the current contact

LoadCurrentContact()

Catch ex As Exception

MessageBox.Show(ex.Message, "Error")

End Try

End If

End Sub

The next method is used to open and deserialize an existing contact file, making it available for edit and viewing within the application.

''' <summary>

''' Open an existing contacts file

''' </summary>

''' <remarks></remarks>

Public Sub Open()

Dim OpenFileDialog1 As New OpenFileDialog()

OpenFileDialog1.Title = "Open con Document"

OpenFileDialog1.Filter = "CON Documents (*.con)|*.con"

If OpenFileDialog1.ShowDialog() = System.Windows.Forms.DialogResult.Cancel

Then

Return

End If

currentFilePath = OpenFileDialog1.FileName

If String.IsNullOrEmpty(currentFilePath) Then

Return

End If

If System.IO.File.Exists(currentFilePath) = False Then

Return

End If

' deserialize file content into contacts

' list to make it available to the application

contacts = Serializer.Deserialize(currentFilePath)

' alphabetize the contact list

' by last, first, and middle name and

' push the results into a List

Dim orderedContacts = _

(From contact In contacts _

Order By contact.LastName Ascending, _

contact.FirstName Ascending, _

contact.MiddleName Ascending _

Select contact).ToList()

' set the contacts list to the newly

' ordered list

contacts = orderedContacts

' Load contacts at position zero

' if contacts list is not empty

If contacts.Count > 0 Then

currentContact = contacts.ElementAt(0)

LoadCurrentContact()

dirtyForm = False

End If

End Sub

#End Region

The final region in this form class is used to handle the listbox control events. These controls are used to provide a Rolodex sort of functionality to the application. The listbox controls are loaded into the left hand split panel's panel. The top listbox control displays all of the letters in the alphabet whilst the lower listbox control is used to display all matching last names beginning with the letter selected in the upper listbox.

#Region "Listbox Event Handlers"

The first function handles the selected index changed event for the upper listbox containing all of the letters of the alphabet. When a new letter is selected, this method uses a simple LINQ to Objects query to find all contacts with last names beginning with the selected letter. The lower listbox is then cleared and then the matches are then formatted into a string showing the contact's last name, first name, and middle name and each formatted string is then added to the lower listbox control.

''' <summary>

''' Find all last names starting with the selected letter

''' and display that list of matching names in the names

''' list box

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles lstAlphas.SelectedIndexChanged

' store the selected letter as a local variable

Dim alpha As String = lstAlphas.SelectedItem.ToString()

' make sure the contact list is not empty

If contacts.Count > 0 Then

Try

' use linq to objects query to find

' last names matching the selected

' letter of the alphabet

Dim alphaGroup = _

From contact In contacts _

Where contact.LastName.ToUpper().StartsWith(alpha) _

Select contact

' clear out any names from the

' existing list

lstNames.Items.Clear()

' add the short list of matching

' names to the list box

Dim con As Contact

For Each con In alphaGroup

lstNames.Items.Add(con.LastName + ", " + _

con.FirstName + " " + con.MiddleName)

' if no matches were found, tell the user

' with a note in the box

If (alphaGroup.Count < 1) Then

lstNames.Items.Clear()

lstNames.Items.Add("No matches were found")

End If

Catch

lstNames.Items.Clear()

lstNames.Items.Add("No matches were found")

End Try

End If

End Sub

Then the names listbox selected index changed event is handled in the next block of code. In it, the name string (Last name, first name, middle name) is parsed and used in a LINQ to Objects query used to return a list of all matching names; the first found name is displayed in the contact form and the index position is updated to support the list navigation.

''' <summary>

''' Display the selected contact's information in the

''' contact form's fields

''' </summary>

''' <param name="sender"></param>

''' <param name="e"></param>

''' <remarks></remarks>

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

ByVal e As System.EventArgs) _

Handles lstNames.SelectedIndexChanged

' if there were no matches found, return from this function

If (lstNames.SelectedItem.ToString().Trim() = "No matches were found") Then

Return

End If

' variables to hold parts of the name as search terms

Dim first As String = String.Empty

Dim middle As String = String.Empty

Dim last As String = String.Empty

' get the last name

Dim arr() As String = lstNames.SelectedItem.ToString().Trim().Split(",")

last = arr(0).Trim()

' get the first name

Dim arr2() As String = arr(1).ToString().Trim().Split(" ")

first = arr2(0).Trim()

' get the middle name

Try

middle = arr2(1).Trim()

Catch

' no middle name

End Try

Try

' using linq to objects query to get a collection of matching names

' when all three names match

Dim foundGuy = _

(From contact In contacts _

Where contact.FirstName.Equals(first) And _

contact.LastName.Equals(last) And _

contact.MiddleName.Equals(middle) _

Select contact).FirstOrDefault()

' set the current contact to the first found

' contact

currentContact = foundGuy

' update the index position used to maintain

' the current position within the list

currentPosition = contacts.IndexOf(currentContact)

' reload the current contact and return

LoadCurrentContact()

Return

Catch ex As Exception

MessageBox.Show(ex.Message, "Error Encountered")

End Try

End Sub

#End Region

End Class

Code: frmFullList.vb

This form class contains a data grid view control and a constructor which accepts a contact list (List(Of Contact)) as an argument. Upon initialization the list is bound to the data grid view control.
Changes made by edits in the grid are maintained in the contact list.

There is not much code; it is presented here in its entirety:

Imports System

Imports System.Collections.Generic

Imports System.ComponentModel

Imports System.Data

Imports System.Drawing

Imports System.Linq

Imports System.Text

Imports System.Windows.Forms

Public Class frmFullList

Public Sub New(ByVal cons As List(Of Contact))

' This call is required by the Windows Form Designer.

InitializeComponent()

' display the contact list in the

' data grid view control

dgvFullList.DataSource = cons

End Sub

End Class

Summary

The article shows some simple examples of LINQ to Objects queries used in support of a sample application. LINQ to Objects may be used to generate more complex queries than are shown in the example, however, those demonstrated herein are representative of some of the more common tasks that one might choose to do within a similar application. Much of the code in the demonstration project was provided as a framework for the application and was necessary to create an environment useful for testing some simple LINQ to Objects based queries.

Recommended Free Ebook

Printing in C# Made Easy

Download Now!