LINQ

My book "Visual Basic 2010 Unleashed" is available

alessandro.delsole@nospamvisual-basic.it — Wed, 12 May 2010 09:49:00 GMT

I'm pleased to announce that my book "Visual Basic 2010 Unleashed" is finally live! It's my first English book and it offers more than 1200 pages where the syntax of Visual Basic 2010 is analyzed in details but it is also a book that describes how Visual Basic today can be used against the most recent Microsoft technologies for both Windows and the Web.

(Click for larger image)

It has been a really hard work but I feel proud of it :-) With regard to contents, actually this book is not intended for absolute beginners; instead it is intended for an audience having some experience with the .NET technology and the Visual Basic language. It is composed of 59 chapters and the last 4 of them is available on the Web only (yes, I wrote too much :-)). The book starts with the Visual Basic language fundamentals and then goes through the Object Oriented Programming aspects, analyzing advanced features of the language and of the Common Language Runtime as well. Among the topics, I covered data access with LINQ, the new Parallel Programming libraries, code contracts, building WPF & Silverlight applications, Web applications also targeting Windows Azure. I discuss about Windows Communication Foundation and WCF Data Services, setup & deployment, Office deployment and Visual Studio 2010 extensibility. The last part of the book, which is Web only, is about the Team System instrumentation, therefore analysis tools, IntelliTrace, unit tests and so on. Except for the last part of the book, most of the contents can be also applied to Visual Basic 2010 Express Edition.

The full list of the chapters and of the topics is available in this page from the InformIT web site, in the Sample Contents tab. We'll soon have 2 free sample chapters (I'll give you the download link as soon as I get it). The companion source code is also available from the same page.

I hope you will enjoy it!

Alessandro

Querying the Windows' events with LINQ and Visual Basic

alessandro.delsole@nospamvisual-basic.it — Sun, 07 Mar 2010 23:05:00 GMT

Some time ago, in the Italian MSDN forum about Visual Basic, a user asked how it is possible querying the Windows' log events registry based on the given ID. This is really easy with LINQ.

First, you get a reference to the Windows' events registry via an instance of the System.Diagnostics.EventLog class. The constructor requires as an argument the log name you want to query (e.g. Application, Security, Setup etc.). Once you get the instance, you can write a LINQ query for filtering only entries marked with the given ID. Each entry is represented by EventLogEntry objects. The following code demonstrates how to accomplish this:

Dim eLog As New EventLog("Application")

Dim specificEntries = From logEntry In eLog.Entries.Cast(Of EventLogEntry)()

Where logEntry.InstanceId = 9010

Select logEntry

Notice how the code requires the Cast(Of T) operator which is often necessary in LINQ to Objects scenarios, especially in case the compiler cannot infer the appropriate type. The EventLogEntry.InstanceId property allows comparing the desired ID event (on my machine the ID 9010 is about events generated by Team Foundation Server 2010 Basic). Then it is possible to perform further operations against the events set (e.g. via a For..Each loop) in order to obtain information about each event, such as the application that raised the event (property EventLogEntry.Source) or the event message (property EventLogEntry.Message).

Alessandro

Listing files from a directory with LINQ and .NET 4.0

alessandro.delsole@nospamvisual-basic.it — Sun, 20 Sep 2009 13:34:00 GMT

Every time a new version of the .NET Framework is available we probably think of new great technologies (or at least this is for me) but often there are also some small improvements to the Base Class Library.

I just discovered that the System.IO.Directory class implementation in .NET Framework 4.0 Beta 1 now exposes a method named EnumerateFiles, which works like the well known GetFiles, but differs in that it returns an IEnumerable(Of String) making the result directly queryable with LINQ.

This is an example:

Dim filesEnumerable As IEnumerable(Of String) = Directory.EnumerateFiles("C:\", "*.exe")

You use it exactly as GetFiles, but the result type is different. The really cool thing is that you can query the result with LINQ, as in the following example where all file names containing the "document" literal are extracted from the given directory:

Dim fileList = From everyFile In Directory.EnumerateFiles("C:\")

Where everyFile.ToLowerInvariant.Contains("document")

Select everyFile

For Each item In fileList

Console.WriteLine("File name: {0}", item)

Of course the query is executed at the moment when its result is effectively used, as a typical LINQ mechanism. Similarly you can use general LINQ to Objects concepts in this scenario too.

Alessandro

ADO.NET Entity Framework - 3rd party providers

alessandro.delsole@nospamvisual-basic.it — Tue, 14 Apr 2009 11:31:00 GMT

One of the most interesting features in ADO.NET Entity Framework is that it can be extended with external providers for databases different from Microsoft SQL Server, whose provider is shipped by default with .NET Framework 3.5 Service Pack 1.

There is a list of available 3rd party providers for ADO.NET ENtity Framework on the MSDN data development portal, both RTM and beta providers. Click here to be redirected to the MSDN page and you'll see important names such as Oracle, MySQL, PostgreSQL. If you work with ADO.NET Entity Framework, maybe you are interested into such topic.

Alessandro

Strongly typed eager loading in Entity Framework with Visual Basic

alessandro.delsole@nospamvisual-basic.it — Mon, 19 Jan 2009 22:59:00 GMT

In a previous post we discussed about creating data forms for showing master-details data representations with Visual Basic 2008 and the ADO.NET Entity Framework and we said that using strings within the eager loading technique could cause the loss of the benefits provided by the LINQ strongly typed approach.

I then found a blog post by Matthieu Mezil (Microsoft Visual C# MVP), who solved the problem implementing a custom Include method using lambda expressions instead of strings, taking the advantage of the strongly typed approach. Matthieu's code is in Visual C# with his help we converted the code into Visual Basic 2008.

The code is quite short, but it requires a good knowledge of LINQ, so you'll find links to the MSDN library for each object we will utilize.

Let's retake the demo application we saw in the previous post then let's add a new module. In this module we must first add the following Imports directives:

Imports System.Runtime.CompilerServices

Imports System.Data.Objects

Imports System.Linq.Expressions

Imports System.Reflection

Once we've done this, let's type the following code which implements an extension version of the Include method. This is the code about the new module and that we'll comment below:

<Extension()> Module ObjectQueryExtension

<Extension()> _

Function Include(Of T)(ByVal MainQuery As ObjectQuery(Of T), _

ByVal SubSelector As Expression(Of Func(Of T, Object))) _

As ObjectQuery(Of T)

Return MainQuery.Include(CType(CType(CType(SubSelector.Body, _

UnaryExpression).Operand, _

MemberExpression).Member, _

PropertyInfo).Name)

End Function

End Module

Extension methods must be adorned with the Extension attribute and must be exposed by modules adorned with the same attribute. The Include method requires a generic type Of T. The first argument the method receives is of type ObjectQuery(Of T), that represents, in a strongly typed way, a query executed versus the Entity Data Model. In our case the ObjectQuery is constituted by the NorthwindContext.Categories object. The secund argument is of type Expression (Of TDelegate), and is a strongly typed representation of a lambda expression that is structured as an expression tree.

The method body invokes the Include method versus the ObjectQuery instance that it received (in our sample it's always the NorthwindContext.Categories).

The lambda expression body is converted into an UnaryExpression. The result of this expression (Operand) is then converted into a MemberExpression, which is the infrastructure for accessing fields or properties which are then accessed via the reflection.

Invoking this method is quite easy. If we would apply the method to the demo application we saw in the previous post, we can replace the line of code for the eager loading as follows:

'Dim dataSource = NorthwindContext.Categories.Include("Products")

Dim dataSource = NorthwindContext.Categories.Include(Function(c) c.Products)

You can surely notice the difference. We are no more passing a string, because we are now passing a lambda expression that allows us working in a strongly typed way (with many advantages from this). The local type inference correctly assigns the Categories type to the c object and the ObjectQuery(Of Categories) type to the dataSource one.

If you try to run the application you'll obtain the same result of the previous time, but this time we retrieved data with a more efficient and "managed" approach.

Alessandro

Master-details forms with the ADO.NET Entity Framework

alessandro.delsole@nospamvisual-basic.it — Mon, 19 Jan 2009 22:27:00 GMT

If you are a little bit familiar with LINQ to SQL, you probably already know how simple is creating a basic Windows Forms application for exposing one-to-many relationships between entities via master-detail representations through the UI.

In LINQ to SQL this can be accomplished using the Microsoft Visual Studio 2008 automation engine that allow dragging and dropping objects (entities) from the Data Sources window onto the target form. The IDE then adds the needed UI controls, manages the data-binding leaving to us the only job to specify in code the data source regarding the “one” part in the relationship.

Unfortunatley this is not available when working with the ADO.NET Entity Framework (introduced by .NET Framework 3.5 Service Pack 1); this means that dragging just the "master" data source onto the form will not automatically bind the "details" as in LINQ-to-SQL, so we need to set this behavior manually.

So, how can we accomplish this when working with EF? Another Visual Basic MVP (Ken Tucker) helped me to find the right way to solve the problem (thanks Ken).

Suppose you want to create a Windows Forms application to show tabular data, inside two DataGridView controls, the content of the Categories and Products tables from the Northwind database and that when selecting each category, in the second grid will be automatically bound and shown the related products.

When working with the Entity Framework, we need to recur to the so called eager loading technique that we can realize invoking a method called Include. The following are the first steps required:

1. creating a Windows Forms project with Visual Basic 2008;

2. establishing a database connection and adding a new Entity Data Model;

3. adding tables to the EDM (remember to select tables with relationships). In our example we'll add the Categories and Products tables in Northwind;

4. adding a new data source (Data|Add New Data Source command) pointing to the Categories object that was generated by the mapping.

The Data Sources window should look like this:

A this point we can drag the two objects (Categories and Products) onto the form so that Visual Studio can add the appropriate controls to the user interface which should look like this:

Now we can switch to the Visual Basic code. As we said before, we can't just simply assign the Categories collection (or a LINQ query result for that collection) to the DataSource property of the BindingSource control (CategoriesBindingSource), automatically implemented by Visual Studio, to get the ProductsBindingSource automatically updated for showing details according to the item selected in the first one.

According to what we just said, first of all we have to instantiate the EF ObjectContext:

Private NorthwindContext As New NorthwindEntities

Once we've done this, we can specify the data source for the “master” part (please refer to the comments below):

'The include method retrieves also related objects

Dim dataSource = NorthwindContext.Categories.Include("Products")

'The primary data source is always Categories

CategoriesBindingSource.DataSource = dataSource

Then, invoking Include, we can load also the details (eager loading), as shown in the subsequent code:

'The Products' data source is still the CategoriesBindingSource control

'which contains both Products and Categories...

ProductsBindingSource.DataSource = CategoriesBindingSource

'...and of this control I can show just the collection I really need

'assigning to the DataMember property the name of the collection itself

ProductsBindingSource.DataMember = "Products"

Probably this situation puts some limitations: using a string is not a typical LINQ approach, where everything should be strongly typed. Now let's try to run the application. We can just select the rows in the Categories DataGridView to see how the Products one is automatically updated with details:

Obviously this is enough just to show data but some more code should be written if we want to allow the user adding new objects. At this point we must explicitly assign the AllowNew property exposed by the ProductsBindingSource control because, differently from LINQ-to-SQL, in Entity Framework this property is not set as True by default. According to this consideration, we can just specify the following line of code:

ProductsBindingSource.AllowNew = True

But this is not necessary regarding the Categories. Just to make the demo application complete, we can provide the most basic implementation of a method for persisting data to the underlying database. Once enabled the Save button on the BindingNavigator, we can handle its Click event:

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

ByVal e As System.EventArgs) Handles CategoriesBindingNavigatorSaveItem.Click

Try

NorthwindContext.SaveChanges()

Catch ex As Exception

MessageBox.Show("An error has occurred while saving changes to the database")

End Try

End Sub

And that’s all. You can download the source code for this post from this address (MSDN Code Gallery). Inside the zip archive you will find also .vsi installer (created with my Vsi Builder 2008 tool) that will install a reusable code snippet for the Visual Studio 2008 IntelliSense which includes the code related to the master-details data binding task as shown above.

Alessandro