You Can Take it With You

24 Hours of Windows Mobile Webcast Series Continues – Creating Adaptive Applications

jim-wilson — Tue, 23 Sep 2008 20:58:37 GMT

It has been quite a while since I posted as the summer has just been crazy busy. With the start of a new season (today's the first full day of autumn), I'm now getting back to my more regular blogging schedule.

What better time is there to get back into blogging than when one has the opportunity for shameless self-promotion? J Tomorrow (Wednesday 24-September-2008), I'm presenting a webcast on Creating Adaptive Windows Mobile Applications.

As some of you may know, I've done webcasts and written papers on the topic of application adaptability in the past. The thing I find so interesting about the issue of application adaptability is how much solutions and techniques evolve. It's been nearly 3 years since I last did a Webcast on application adaptability and during that time a lot of new devices have been released making it a good time to revisit the topic.

Let me start by saying that this is not a talk about "Write Once Run Everywhere" … It is a talk about writing a single adaptable application that runs successfully across the entire family of Windows Mobile devices. "Write Once Run Anywhere" is really just marketing hype that many people in the mobile device space get excited about (I was once guilty of promoting the term myself).

Device adaptability is designing an application so that the application's core functionality is decoupled from the application's interaction with the device features. Adapting to differences in each device's user interface is part of the story but it's not the whole story. There's also the issue of adapting to differences in network capabilities, phone features, GPS access, and any other features that may vary between devices.

As mobile devices become increasingly rich, the differences between device features will become increasingly significant. Please join me on Wednesday (24-September-2008) as I talk about techniques for assuring that your application takes advantage of individual device capabilities while assuring that all users, even those with less capable devices, have the best possible application experience.

Debugging device cellular connection code without ActiveSync interference

jim-wilson — Wed, 16 Jul 2008 13:43:00 GMT

I had a situation today where I needed to debug some code that used Connection Manager to establish a cellular connection. The challenge was that the connectivity problem was only observed on certain devices therefore I couldn't use the Device Emulator & Cellular Emulator to debug … I needed to debug on a real device.

This all sounds simple enough until you start to try and do it… In order to debug application code using Visual Studio, I have to connect the device to my desktop using ActiveSync or WMDC.

Now here's the problem…

I want my application to establish a cellular connection but ActiveSync/WMDC provide the device with network connectivity … as a result any call to ConnMgrEstablishConnection or ConnMgrEstablishConnectionSync to establish the network connection returns with a successful connection but not a cellular connection because Connection Manager is recognizing that the current ActiveSync/WMDC connection meets the application's network connectivity requirements.

I could modify my code to explicitly establish a cellular connection but I want to debug the application code as it will run in real life. In real life, I want Connection Manager to choose the appropriate connection … I just need to debug the cellular scenario right now.

I have to say that I did stare at my screen for a minute or so wondering what kind of kludge I could come up with to get the device to not use ActiveSync/WMDC and then I realized … the answer is quite simple.

Windows Mobile manages connections as connecting to Work Network or connecting to The Internet. Since I'm trying to create a cellular connection, I want an Internet connection. All I need to do is tell the device that ActiveSync/WMDC doesn't provide Internet connections.

On the ActiveSync Connection Settings dialog there's a selection that reads "This computer is connected to:" with a default value of Automatic. Simply changing that setting from Automatic to Work Network solves all my problems.

Now when I call connection manager requesting a connection that reaches a location on the Internet, Connection Manager looks at the ActiveSync/WMDC setting and determines that ActiveSync/WMDC connection cannot meet that requirement; therefore, Connection Manager looks for other choices which then initiates a new Cellular Connection just as it would in the field when not connected to ActiveSync.

Viola … I can debug my cellular connectivity code J

Like many of us, I've often found the whole Windows Mobile Work Network vs. The Internet connectivity handling to be a bit of a pain but in this case it did make my life easier. Of course what would be even better is to have a way to explicitly do what I really wanted to do… setup an application debugging scenario that let's one choose whether ActiveSync should be considered a viable connection route during application debugging.

Windows Mobile Webcast Series – Getting Ready for Tech Ed (and other life changing events)

jim-wilson — Tue, 20 May 2008 17:55:00 GMT

If you've been thinking about getting started with Windows Mobile programming, then you'll want to check out this webcast series co-presented by Maarten Struys, Constanze Roman, and me.

We originally put this series together so that people who are new to Windows Mobile could get a foundation in Windows Mobile before attending TechEd Windows Mobile-related sessions. Honestly though, this series is useful for anyone who is looking to start developing Windows Mobile applications whether or not you're attending TechEd.

Part 1: Developing Applications for Windows Mobile Devices (available on-demand)
Part 2: Developing Your First Real Windows Mobile 6 Application (available on-demand)
Part 3: Using Device Capabilities and Device Functionality (available on-demand)
Part 4: Mobile Data Strategies and Synchronization Using SQL Server Compact, XML, and LINQ (available on-demand)
Part 5: Windows Mobile Development - Live from TechEd Orlando (available on-demand)

Sooner or later, almost every developer will be involved in developing mobile applications; this series is a great way to quickly build up a foundation in Windows Mobile development and learn how you can apply your existing .NET skills to create rich mobile applications.

If you miss one of the live broadcasts, remember that all webcasts become available for on-demand viewing starting approximately 24 hours after the live broadcast. Whether you're viewing the webcast live or on-demand, the above links will take you there.

WCF Strategies for Windows Mobile Webcast

jim-wilson — Sun, 11 May 2008 13:27:00 GMT

Due to a last minute scheduling problem, my planned appearance on geekSpeak last week to talk about Windows Communications Foundation (WCF) Strategies for Windows Mobile had to be rescheduled.

I realize it's a bit of short notice but I wanted to let everyone know that it is now scheduled for Monday 12-May at 12-noon PDT (3PM EDT, 19:00 UTC). The URL to register for the webcast is still the same.

I really encourage you to come by and checkout this webcast. Although, our initial point of reference is WCF on Windows Mobile, most of what we talk about applies equally to all mobile-oriented applications whether running on a Windows Mobile device, or laptop/notebook computer.

One of the key areas we'll address is the Store and Forward transport and its usefulness in applications that may be intermittently online or that may switch between wired, wireless, or cellular networks.

Remember that geekSpeak webcasts are more interactive than most, allowing an opportunity for you to ask questions and for us to share a very interactive dialog. As always though, I'll be showing some demos so that you can see some real code at work.

I hope to see you there. If you're not yet doing mobile application development, you almost definitely will be doing so very soon and this is a great way to learn about some of the common considerations and solutions for communicating in this loosely-connected environment.

A Whirlwind of Webcasts

jim-wilson — Mon, 28 Apr 2008 22:23:00 GMT

It looks like Webcast season is upon us J …

Between now and Tech Ed, Maarten Struys and I will be presenting a combined total of 7 webcasts.

This Wednesday, 30-April and next Wednesday, 7-May I'll be the guest on MSDN's geekSpeak.

Then starting next week (week of 5-May), Maarten Struys and I will be co-presenting a multi-part webcast series on a variety of Windows Mobile topics as a lead-in to Tech Ed Developer 2008.

geekSpeak

This Wednesday (30-April) I'll be talking about SQL Server Compact Tips and Tricks (both devices and desktop).

I'm really looking forward to this talk. Those of you who have followed my blog or who have seen my whitepapers or webcasts know that I'm a big fan of SQL Server Compact. Although it provides excellent code & SQL compatibility with SQL Server, the details of the underlying architecture sometimes require a different approach. That's what we'll be talking about … how to get the most out of SQL Server Compact.

Next Wednesday (7-May), I'll be talking about Windows Communication Foundation (WCF) Strategies for Windows Mobile.

Although not the focus of the entire webcast, we'll definitely be talking a bunch about using Store-and-Forward messaging. Whether you're targeting Windows Mobile devices or focus more on desktop applications, you'll want to be there.

Most of the same strategies we use for Windows Mobile applications apply equally to applications running on a laptop/notebook computer with Store-and-Forward messaging being a great example. Any application (Windows Mobile or Laptop-based) that needs to be away from connectivity periodically faces communications challenges that Store-and-Forward messaging addresses as it allows your app to simply send messages and the Store-and-Forward mechanism caches the messages automatically sending them whenever connectivity becomes available.

Bring your questions: If you haven't been to a geekSpeak webcast before, you don't know what you're missing.

These are much more two-way than traditional webcasts. Don't get me wrong, I love traditional webcasts where I get to show you a bunch of code but geekSpeak provides a great adjunct. On geekSpeak we engage much more in a conversation; the discussions are very listener driven with much of the time focused on addressing those things that you ask about.

Countdown to Tech Ed Developer 2008

We don't have all of the details posted yet but staring next week (week of 5-May), Maarten and I will be doing webcasts each week covering a different aspect of Windows Mobile development.

The webcasts are aimed at people who are new to Windows Mobile or who may be looking to gain a deeper understanding of the tools and capabilities of Windows Mobile application development. Keep a watch here on my blog and I'll provide further details on these webcasts as we get them published.

Using LINQ to Access SQL Server Compact Directly – A follow up

jim-wilson — Fri, 18 Apr 2008 18:37:00 GMT

You may recall my webcast from about 6/7 weeks ago where I talked about how to use custom extension methods to allow your mobile device applications to efficiently query a SQL Server Compact (SSC) databases directly.

I received a question today regarding the webcast. The question relates to the verbosity of returning anonymous types when using the technique discussed in the webcast. For example…

var records = from order in resultSet
where (string)order["Ship Country"] == "UK"
select new
{
ShipName = (string)order["Ship Name"],
ShipAddress = (string)order["Ship Address"],
ShipCity = (string)order["Ship City"],
ShipPostalCode = (string)order["Ship Postal Code"],
ShipCountry = (string)order["Ship Country"],
ShipVia = (int)order["Ship Via"]
};

The verbosity is necessary because "order" in the above LINQ statement is of type SqlCeUpdatableRecord. Although Visual Studio supports generating typed-wrappers for SqlCeResultSet, it doesn't generate wrappers for the SqlCeUpdatableRecord corresponding to the SqlCeResultSet. With that being the case, specifying the individual column values within the anonymous type declaration requires you to use either the indexer (or Getxxx functions).

Ultimately there's nothing we can do about the way the column values are accessed (unless you write your own typed-wrapper generator for SqlCeUpdatableRecord). What we can do is move the code that creates the anonymous type into a separate function.

private object ShippingColumns(SqlCeUpdatableRecord order)
{
return new
{
ShipName = (string)order["Ship Name"],
ShipAddress = (string)order["Ship Address"],
ShipCity = (string)order["Ship City"],
ShipPostalCode = (string)order["Ship Postal Code"],
ShipCountry = (string)order["Ship Country"],
ShipVia = (int)order["Ship Via"]
};
}

With that, the LINQ statement becomes very simple.

var records = from order in resultSet
where (string)order["Ship Country"] == "UK"
select ShippingColumns(order);

Once we move the anonymous type declaration to a separate function we can take things one step further and optimize the column access by caching the column ordinals and then retrieving the column values using the Getxxx functions.

private object ShippingColumns(SqlCeUpdatableRecord order)
{
if (_nameIndex == -1)
InitializeIndexes(order);

return new
{
ShipName = order.GetString(_nameIndex),
ShipAddress = order.GetString(_addressIndex),
ShipCity = order.GetString(_cityIndex),
ShipPostalCode = order.GetString(_postalCodeIndex),
ShipCountry = order.GetString(_countryIndex),
ShipVia = order.GetInt32(_viaIndex)
};
}

private void InitializeIndexes(SqlCeUpdatableRecord record)
{
_nameIndex = record.GetOrdinal("Ship Name");
_addressIndex = record.GetOrdinal("Ship Address");
_cityIndex = record.GetOrdinal("Ship City");
_postalCodeIndex = record.GetOrdinal("Ship Postal Code");
_countryIndex = record.GetOrdinal("Ship Country");
_viaIndex = record.GetOrdinal("Ship Via");
}

private int _nameIndex = -1;
private int _addressIndex = -1;
private int _cityIndex = -1;
private int _postalCodeIndex = -1;
private int _countryIndex = -1;
private int _viaIndex = -1;

Although not a huge performance increase, storing the column indices does eliminate the overhead of the indexer looking up the column name each time. More importantly, using the strongly-typed Getxxx functions eliminates the overhead of boxing any column values that are value-types. As you know, excessive boxing creates a lot of scrap objects which leads to increased memory and garbage collection overhead.

Using regular class methods like those above work just fine; however, if you find that you use a common anonymous type throughout different parts of your application, you may want to use an extension method – extension methods are also nice just because of their class-member-like syntax.

public static class ResultSetExtension
{
public static IEnumerable<SqlCeUpdatableRecord> Where(
this SqlCeResultSet resultSet, Func<SqlCeUpdatableRecord, bool> theFunc)
{
return new PrepAwareEnumerableWrapper(resultSet, theFunc);
}

public static object ShippingColumns(this SqlCeUpdatableRecord order)
{
if (_nameIndex == -1)
InitializeIndexes(order);

return new
{
ShipName = order.GetString(_nameIndex),
ShipAddress = order.GetString(_addressIndex),
ShipCity = order.GetString(_cityIndex),
ShipPostalCode = order.GetString(_postalCodeIndex),
ShipCountry = order.GetString(_countryIndex),
ShipVia = order.GetInt32(_viaIndex)
};
}

private void InitializeIndexes(SqlCeUpdatableRecord record) { ... }

With the extension method, the LINQ statement becomes…

var records = from order in resultSet
where (string)order["Ship Country"] == "UK"
select order.ShippingColumns();

A couple of notes before I finish up…

One thing to keep in mind is that all of these functions that create the anonymous type have a return type of object. This means that the IEnumerable<T> collection that is created by the LINQ statement will be of type IEnumerable<object> rather than IEnumerable<compiler_generated_type>. In most cases this difference does not matter but it is something to be aware of.

And for a final note, if you do find yourself returning the same anonymous type construct from a number of LINQ statements, you might want to consider defining an explicit type and then constructing instances of that type within the LINQ statement. In my experience, anytime I find myself using an anonymous type/function/etc. more than once or twice that I ultimately end up needing access to it in my code in a non-anonymous fashion.

To return a specific type from a LINQ statement, simply define a type that has a constructor that accepts a SqlCeUpdatableRecord and assigns the desired columns to the corresponding type members – basically the constructor will look like the ShippingColumns methods shown above. Assuming that you've defined a class named ShipInfo with the appropriate constructor, your LINQ statement would look like the following…

var records = from order in resultSet
where (string)order["Ship Country"] == "UK"
select new ShipInfo(order);

I've updated one of the samples from the original webcast to include examples of what we've talked about in this post. If you'd like the updated sample, you can download it from here. The methods you'll want to look at in the download are menuRedefineType_Click, menuDynamicType_Click, menuDynamicTypeExtMethod_Click all of which are in the Form1.cs source file.

Stop the Lies! … Pentagon issuing Windows Mobile-based lie detectors

jim-wilson — Wed, 09 Apr 2008 14:34:00 GMT

I came across this article: New anti-terror weapon: Hand-held lie detector on MSNBC today.

The article talks about a new hand-held lie detector that the Pentagon is issuing to soldiers in Afghanistan to help in screening local-police, interpreters, etc.

I couldn't find Microsoft or Windows Mobile mentioned anywhere in the article but take a look at this picture of the application screen …

The tell-tale Start icon appears in the top-left corner, and the familiar network activity and sound icons followed by the time appear in the top-right corner.

Something that I found funny … For an overview of the tool, the Pentagon has made a PowerPoint presentation available. J

All joking aside, it's really cool to see Windows Mobile being used in such a critical application

Problem creating data-bound DataGrid in Device Project

jim-wilson — Tue, 08 Apr 2008 14:32:00 GMT

The other day while working in Visual Studio 2008, I encountered an unexpected error while attempting to create a DataGrid by dragging a table from the Data Sources pane onto a form (something we've all done many times).

At first Visual Studio appeared to be creating the DataGrid and associated components (BindingSource, TableAdapter, etc.) correctly but then Visual Studio threw an error:

An error occurred while performing the drop:

Length cannot be less than zero.
Parameter name: length

The error message might have been useful if I had access to the Visual Studio source code – but I was just using Visual Studio, not building it. Needless to say, the error message was of little help. J So I did what we all do in such situations, used trial-and-error.

The project calls a WCF service through a proxy generated by NetCfSvcUtil.exe; as an experiment, I decided to remove the WCF proxy from the project (and any calls to the proxy) to see what happened.

… VOILA …

Visual Studio was then able to create the DataGrid with no problem.

To verify what I had observed, I added the WCF proxy (and any associated calls) back into the project and deleted the DataGrid. Just as before, when I tried to create the DataGrid, Visual Studio threw the same error – so now I know where to start looking for the problem.

When I checked out the source file for the WCF proxy I realized that there was no namespace declaration. As you may know, if you run the NetCFSvcUtil without specifying the "/namespace" option then the types are not placed within a namespace….

So as an attempt at a solution, I created the WCF proxy so that the contained types were in a namespace (and added the appropriate using statement to the form class) – I then deleted the DataGrid from the form. Now when I dragged the table from the DataSource pane to the form, the DataGrid was created without any trouble - putting the types in a namespace completely resolved the problem. The program also compiles and runs as expected.

Now things are working – My assumption at this point was that there must have been a type name conflict (or something similar) between the WCF proxy types and the DataGrid-related types; seemed a reasonable assumption.

… BUT… here's the thing …

To confirm my assumption about the name conflict, I created the WCF proxy so that the contained types were not in a namespace (and of course removed the associated using statements) but left the generated DataGrid place. If there were a type name conflict between the DataGrid-related types and the WCF proxy the compiler should report the error

… BUT … get this …

The code compiles and runs perfectly --- the namespace was required for Visual Studio to create the DataGrid (and/or associated components) but the namespace is not required for the code to compile and run -- what?!?!

So what does this all mean? … At this point my guess is that Visual Studio and the DataGrid creation process have a type name sensitivity that may not be consistent with the .NET CF language requirements. If that is the case it would appear to indicate a possible bug but can't be 100% certain until the problem is narrowed down specifically.

I haven't had a chance to narrow down things further quite yet but I hopefully will shortly. As soon as I have the answer I'll post it here.

One thing to keep in mind, if you do run into the error I describe above, look for any possible name conflicts or classes outside of a namespace. It seems that there's a good chance that that's the source of the problem.

I hope to have more to report soon.

OT: Fun Cat Videos

jim-wilson — Thu, 27 Mar 2008 17:43:00 GMT

A short divergence from my regular technical posts...

If you have a cat, you can't help but laugh due to the insane accuracy of these videos

Simon's Cat in Cat Man Do

Simon's Cat in Let Me In

Videos are originally from “And then there were four”

For other fun cat content checkout Buzzerbee's blog and the many other sites it links to.

Looks like Flash-Lite still has a strong mobile story

jim-wilson — Fri, 21 Mar 2008 11:38:00 GMT

A couple of weeks ago there were indications that Adobe's hope for continued adoption of Flash-Lite on mobile devices was possibly in jeopardy.

First there was the Microsoft MIX08 announcement of Silverlight for Mobile which, of course, competes with Flash-Lite; then Steve Jobs said that Flash-Lite didn't offer the power that iPhone requires.

Oh but how quickly things change…

On Monday Adobe announced: Microsoft Licenses Flash Lite for Windows Mobile Users
Then on Wednesday, thanks to the release of the iPhone SDK: Adobe says Flash is coming to the iPhone

It certainly is an exciting time to be a mobile device developer. J

Automating the process of associating the Device Emulator with the Cellular Emulator

jim-wilson — Tue, 18 Mar 2008 17:19:00 GMT

If you do much work with Windows Mobile applications, there's a good chance that you frequently use the Cellular Emulator to test out things like call handling, SMS message handling, as well as cellular network behavior. I'm a pretty big fan of the Cellular Emulator … I remember what it was not that long ago when we didn't have it … that said …

There is one thing that I do sometimes find bothersome (yes I know this is a very small thing) – it's the process of associating the Cellular Emulator with a Device Emulator. You have to:

Open the Device Emulator Configuration dialog
Select the Peripherals tab
Enter the Cellular Emulator COMx port number into the Serial Port 0 field
Dismiss the Configuration Dialog
Reset the Device Emulator by selecting File | Reset | Soft
Click OK to confirm the soft reset

I realize that there are bigger problems in the world but when you test your apps across several different Device Emulators multiple times each day, that little 6-step process gets old. Fortunately, thanks to the Device Emulator Manager API one can create a little program to automate the whole process.

In an attempt to be a better person and to help my fellow man J … I thought I should share this little, but very helpful block of code.

public static void AssociateDeviceAndCellularEmulator(string emulatorName, string commPort)
{
IDeviceEmulatorManager emulatorManager = new DeviceEmulatorManagerClass();
IDeviceEmulatorManagerVMID theEmulator = FindEmulator(emulatorManager, emulatorName);

// Start the device emulator if not already running
if (theEmulator.get_State() == EMULATOR_STATE.EMU_NOT_RUNNING)
theEmulator.Connect();

SetEmulatorCommPort(theEmulator, commPort);

// Soft-Reset the Device Emulator
theEmulator.Reset(1);
}

private static void SetEmulatorCommPort(IDeviceEmulatorManagerVMID theEmulator, string commPort)
{
string originalConfigString = theEmulator.GetConfiguration();
XmlDocument configXml = new XmlDocument();
configXml.LoadXml(originalConfigString);
XmlNamespaceManager nsManager = new XmlNamespaceManager(configXml.NameTable);
nsManager.AddNamespace("decfg", "http://schemas.microsoft.com/DeviceEmulator/2006/01/DeCfg");

XmlElement serialPort0 = (XmlElement) configXml.SelectSingleNode(
"/decfg:DeviceEmulator/decfg:Peripherals/decfg:SerialPort[@UARTNumber='0']",
nsManager);
serialPort0.InnerText = commPort;

string updatedConfigString = configXml.OuterXml;
theEmulator.SetConfiguration(updatedConfigString);

}

The first function takes care of starting the Device Emulator if it isn't running and doing the soft-reset of the Device Emulator. Before doing the reset, it first calls the 2^nd function, SetEmulatorCommPort, which retrieves the specified Device Emulator's current configuration XML, locates the serial port 0 element, assigns the correct COMx port number, then passes the updated configuration XML back to the Device Emulator. After which, the Device Emulator is correctly associated with the Cellular Emulator and is ready to use.

With these functions in place, to associate the Windows Mobile 6 Professional Emulator with the Cellular Emulator (we'll assume it requires COM4) – we just make the following function call.

AssociateDeviceAndCellularEmulator("Windows Mobile 6 Professional Emulator", "COM4");

Just a little bit of code but I find it makes my day-to-day application testing a little easier.

Silverlight support for iPhone Confirmed?

jim-wilson — Tue, 11 Mar 2008 17:34:00 GMT

According to a report in techradar.com today …

"Microsoft has confirmed to TechRadar that it will look to build a version of Silverlight that will work on the iPhone"

I haven't seen such a commitment corroborated by any other source yet but techradar.com makes it sound pretty good.

I am a little concerned by the phrase "will look to build" – as that doesn't quite sound like a commitment on Microsoft's part – but, fingers-crossed; I hope that it's true.

Sometimes a few words are worth a 1,000 pictures

jim-wilson — Tue, 11 Mar 2008 16:00:00 GMT

Like many, I really like the ongoing trend of providing developer-related information in the form of videos.

I suppose I'd better … although I don't know the exact count, the number of "How Do I Videos for Devices" and On-Demand Webcasts I've made total in excess of 100 – BUT, I'm a bit bothered by what appears to be a trend of delivering developer-related content in only video form.

I recently needed to ramp up quickly on a particular technology and I did what I always do in such a circumstance; I tried to locate a few pieces of good content that would give me a solid foundation in the technology so I could then start writing programs to experiment with the technology's ins-and-outs.

My search for content didn't quite go as I hoped. My problem was not that I couldn't find any content on the subject; I found quite a lot of content. The problem was that virtually all of that content was videos. There were a few papers available but they tended to focus on high-level topics and generalities; not really much I could use to start actually working with the technology.

In my personal experience, I find videos useful for getting information on how to perform a particular task but I find them to be of limited value when trying to build up an overall picture of the technology. I also find that in some cases videos slow down the learning process. In the case of using papers, one can read just particular sections of interest, quickly skip past topics not of interest, and easily refer back and forth between multiple papers; all things not easily done with videos.

So all of you content producers, content managers, and decision makers out there … please keep written-content coming.

Written content and videos are fantastic compliments to one another … they're not replacements.

LINQ on Mobile Devices – Some Big Surprises from Visual Basic … Part 2 (continuing the story of improved SqlCeResultSet LINQ query efficiency)

jim-wilson — Mon, 03 Mar 2008 16:45:00 GMT

As you'll recall from my last post, we were talking about some of Visual Basic's unexpected behavior when compiling and resolving method signatures in LINQ queries. Hopefully, most of you will also recall, where this all started … the webcast discussion of using extension methods to efficiently query data held in a SQL Server Compact (SSC) database with LINQ rather than incur the overhead of loading that data into a DataSet. This post shows the difference in resource usage between using DataSets for LINQ queries and direct database LINQ queries through "smart" SqlCeResultSet handing.

So building on our observations in my previous post as to how VB is handling LINQ queries and the difficulties we observed that this creates when using custom extension methods, the following describes how I worked around the issues so we can employ SqlCeResultSet LINQ query optimizations in VB similar to those we observed in C#.

(see this post for C# code examples and this post for VB code examples)

A Quick Review of the Problem

SqlCeResultSet implements the older object-based IEnumerable interface rather than the more modern generic IEnumerable(of T) interface. We observed that when a class implements the older IEnumerable interface that the VB compiler appears to force the creation of a IEnumerable(of Object) wrapper over the class reference by way of a call to the Cast(of Object) extension method. As a result, the reference resolves to the built-in Where extension method that accepts IEnumerable(of T) rather than to our custom Where extension method that accepts a SqlCeResultSet reference.

Working Out a Solution

When working out the optimized SqlCeResultSet LINQ query solution, I wanted to insure that the solution had minimal impact on how you write your code. I wanted to be able to use the SqlCeResultSet class just as it is (no new derived class, etc.) and I wanted to be able to use the same LINQ query syntax that we use for other LINQ queries.

With that in mind, the following is the solution I was able to work out for VB. It is certainly not the only solution to the problem and may not be the best solution. I do feel, however, that it is a reasonable solution.

Getting past the IEnumerable Problem

Because the VB compiler appears to intercede and immediately wrap the SqlCeResultSet instance in a IEnumberable(of Object) collection before resolving the Where extension method, I had to identify an easy way to short-circuit this behavior. I figured the easiest way to do this was to create a simple wrapper class that would basically allow me to hide the SqlCeResultSet from the VB compiler long enough for the compiler to select my custom Where extension method rather than the built-in IEnumberable(ofT) version.

To do this, I defined the VBLinqHandlingWorkAround class…

Public Class VBLinqHandlingWorkAround
Implements IEnumerable(Of SqlCeUpdatableRecord)

Public Sub New(ByVal resultSet As SqlCeResultSet)
_resultSet = resultSet
End Sub

Private _resultSet As SqlCeResultSet

Public ReadOnly Property ResultSet() As SqlCeResultSet
Get
Return _resultSet
End Get
End Property

Public Function GetEnumerator() As System.Collections.Generic.IEnumerator(Of System.Data.SqlServerCe.SqlCeUpdatableRecord) Implements System.Collections.Generic.IEnumerable(Of System.Data.SqlServerCe.SqlCeUpdatableRecord).GetEnumerator
Return Nothing
End Function

Public Function GetEnumerator1() As System.Collections.IEnumerator Implements System.Collections.IEnumerable.GetEnumerator
Return Nothing
End Function
End Class

I then defined an extension method, GetVBLinqHandlingWorkAround…

<Extension()> _
Public Function GetVBLinqHandlingWorkAround(ByVal resultSet As SqlCeResultSet) As VBLinqHandlingWorkAround
Debug.WriteLine("GetVBLinqHandlingWorkAround(this SqlCeResultSet resultSet")
Return New VBLinqHandlingWorkAround(resultSet) ' Wraps the SqlCeResult
End Function

With the VBLinqHandlingWorkAround class and the GetVBLinqHandlingWorkAround extension method in place, I modified the actual LINQ query just slightly…

Dim records = From order In resultSet.GetVBLinqHandlingWorkAround() _
Where order("Ship Country") = "UK"

By calling the GetVBLinqHandlingWorkAround method, the type being queried is the VBLinqHandlingWorkAround class which implements IEnumerable(of SqlCeUpdatableRecord). By implementing the strongly-typed IEnumerable(of T), the VB compiler does not wrap the class reference in a new collection as it did with the SqlCeResultSet. So the type being queried is VBLinqHandlingWorkAround which internally contains a reference to the SqlCeResultSet.

Notice that the VBLinqHandlingWorkAround class doesn't actually implement an enumerator; we have to provide the empty IEnumerable(of T) implementation so that the VB compiler will accept that the VBLinqHandlingWorkAround class can be queried. As you recall from Example 1 in my previous post, without the interface implementation VB considers the type illegal to query even though there's a Where extension method available for the type (C# does not enforce such a requirement).

Accessing the SqlCeResultSet Custom Where Extension Method

Because the type being queried remains the VBLinqHandlingWorkAround class, we can provide a custom Where extension method that accepts the VBLinqHandlingWorkAround reference…

<Extension()>
_Public Function Where(ByVal workAroundReference As VBLinqHandlingWorkAround, _
ByVal theFunc As Func(Of SqlCeUpdatableRecord, Boolean)) _
As IEnumerable(Of SqlCeUpdatableRecord)
Dim resultSet As SqlCeResultSet = workAroundReference.ResultSet
Return resultSet.Where(theFunc)
End Function

Notice what this custom Where extension method does. It simply accesses the SqlCeResultSet reference contained within the VBLinqHandlingWorkAround instance and then uses the method syntax to call the SqlCeResultSet Where extension method. And viola, we're now using our "smart" SqlCeResultSet LINQ query implementation.

When I first designed the SqlCeResultSet optimized query solution I was working in C#. One of the things I had found so elegant about the optimized SqlCeResultSet query solution was the fact that it didn't require any changes to the actual LINQ query. As I so far understand the behavior of the VB compiler when working with LINQ queries, we're not able to achieve that same degree of invisible integration. That said, given the huge payoff in query performance and resource efficiency when using the "smart" SqlCeResultSet query solution, having to include the GetVbLinqHandlingWorkAround method call in the query is a pretty small price to pay. J

LINQ on Mobile Devices – Some Big Surprises from Visual Basic

jim-wilson — Fri, 29 Feb 2008 01:57:00 GMT

As you probably know… yesterday I posted the samples and some screen shots from my LINQ on Mobile Devices webcast. A short time later I received feedback asking that I post VB versions of the samples.

The feedback author made a very good point that these examples (especially the last one) are very difficult to translate from C# to VB if you're not already familiar with C#. Certainly a reasonable request so I figured a take an hour or two today and convert them to VB…

Well so much for an "hour or two" … I started working on them at 10:30 AM and didn't finish until after 5:00 PM … Let's just say that converting the last demo to VB was a little more than just difficult. J

BTW: This isn't going to be a VB bash-fest where I keep touting the amazing power of the C# compiler. I will draw parallels between the two compilers just to provide a reference to an alternate implementation. In the interest of full disclosure, I will say that I do find the C# compiler's handling a of LINQ queries easier to follow than that of the VB compiler.

Sample Downloads

Before I go into the explanation, let me give you the links to the VB Samples first (remember the first demo was already VB)

Second demo – Shows the time and resource cost of using a DataSet as compared to a SqlCeResultSet
Third demo – Shows the benefit of using a custom extension methods and enumerators to query the SSC database tables directly (Be sure to read the below explanation)

For C# versions of the demos, see yesterday's post.

Some Unexpected Behavior in VB's Processing of LINQ Queries

Some of you will remember earlier this month when I ran into what appeared to be a bug when performing LINQ queries against DataTables in VB – as we later learned, it was due to subtle differences between the C# and VB compilers combined with a subtle difference between Extension Method support in .NET CF and the full framework. With that in mind, I'm going to be a little more cautious with the issue I encountered today. J

I'm not prepared to call what I've run into a bug but I can honestly say that I encountered what I found to be very unexpected behavior when attempting to use custom Extension Methods in VB LINQ queries. Let me explain…

As you'll recall from the webcast, we defined a custom Where extension method for SqlCeResultSet. This method allows us to provide a "smart" enumerator which we can use to expedite our queries. In VB, that extension method is declared as follows.

<Extension()> _
Public Function Where(ByVal resultSet As SqlCeResultSet, ByVal theFunc As Func(Of SqlCeUpdatableRecord, Boolean)) As IEnumerable(Of SqlCeUpdatableRecord)
Debug.WriteLine("Where(resultSet As SqlCeResultSet")
Return New PrepAwareEnumerableWrapper(resultSet, theFunc)
End Function

When we did this in C#, our custom Where extension method immediately worked – there were really no significant caveats. I didn't have the same experience in VB J. Here's what I initially found interesting when doing this in VB … using the method syntax to query the SqlCeResultSet works as expected but the query syntax won't even compile!

resultSet.Where(Function(order) order("Ship Country") = "UK") ' Works

Dim records = From order In resultSet _
Where order("Ship Country") = "UK" ' Won't compile?!?!

The problem as reported by the compiler is that the query syntax is trying to use late binding – the compiler believes that "order" is of type Object rather than inferring that it's a SqlCeUpdatableRecord as expected.

In order to get the method to compile, I tried declaring the data type of "order" explicitly [ From order as SqlCeUpdatableRecord in resultSet ] – I also tried letting the compiler infer the type and then using a cast in the Where clause [Where DirectCast(order, SqlCeUpdatableRecord)("Ship Country") = "UK" ]. But when I run the code, the program uses one of the built-in Where extension methods rather than our custom Where extension method.

Ugh! – not what I was hoping for.

Getting a Handle on the VB Compiler's Type Inference within LINQ Query Syntax

Obviously these difficulties with the query syntax were a surprise. As I understand LINQ handling, the query syntax should be transformed into the method syntax – in fact, I know that's how it works in C#. After several hours of research, I now understand that the direct query-syntax-to-method-syntax translation is sort of what happens in VB … but not exactly. I think the best way to explain how things work is with some examples.

Let's assume that I have a class named BizObjectManager that represents a business object that manages lists of other subordinate business objects. The subordinate business object class is called ChildBizObject whose definition looks like the following.

Public Class ChildBizObject
Public ReadOnly Property SalesDivision() As String
'...
End Property
'...
'...
End Class

We'll query the BizObjectManager object for a list of ChildBizObject objects using both the method and query syntax.

Dim manager As New BizObjectManager

Dim records1 = manager.Where(Function(child) child.SalesDivision = "SouthEast") ' method syntax

Dim records2 = From child In manager _
Where child.SalesDivision = "SouthEast" ' query syntax

And we have the following Where extension method that we hope will be used when doing the LINQ queries.

<Extension()>_
Public Function Where(ByVal manager As BizObjectManager, ByVal theFunc As Func(Of ChildBizObject, Boolean)) As IEnumerable(Of ChildBizObject)
'...
End Function

Now let's look at 3 possible ways that we might declare the BizObjectManager class. The method syntax works with all 3 of the declarations but I think you'll be surprised (I certainly was) at the way the VB compiler's handling of the query syntax changes based on that declaration.

Example 1 – Class implements no interfaces

Public Class BizObjectManager
'...
End Class

In this case the VB compiler reports that the class BizObjectManager cannot be queried. This isn't quite true. As I mentioned a few lines back, the method syntax compiles and works fine. Also, this same situation compiles and works fine in C#. The bottom-line is that there is a Where extension method returning an IEnumerable(of T) available so the class is query compatible.

It appears that the VB compiler will only allow classes that implement specific interfaces to appear in the query syntax. Those interfaces include IEnumerable, IEnumerable(of T), and possibly others.

Example 2 – Class implements the strongly-typed IEnumerable(of T) interface

Public Class BizObjectManager
Implements IEnumerable(Of ChildBizObject)
'...
End Class

So to satisfy the compiler, we have our class implement IEnumerable (of ChildBizObject). This code now compiles fine. But what will happen when we run the code?

Since the VB compiler is requiring us to implement this interface, which Where extension method will it choose: the built-in Where extension method that accepts an IEnumerable(of T) or our Where extension method that accepts the BizObjectManager?

The standard rules for method overloading dictate that the method that most closely matches a type be used; in this case the closest match is our custom Where extension method. The good news is, the compiler does choose the correct Where extension method … ours (closest type match). What that means though, is that to get past the VB compiler I had to implement IEnumerable(of T) even though the compiler won't actually use it. The IEnumerable(of T) method implementations can literally return the value "Nothing".

Example 3 – Class implements the loosely-typed IEnumerable interface

Public Class BizObjectManager
Implements IEnumerable
'...
End Class

This is exactly the case with SqlCeResultSet – it implements only IEnumerable not IEnumerable(of T). So just like SqlCeResultSet, the BizObjectManager query won't compile unless we explicitly declare the type of "child" in our query or cast "child" in the Where clause – but once it compiles, when it runs it uses a built-in Where extension method instead of our custom Where extension method.

What's happening in this case is that the VB compiler appears to want to bias the type towards being some version of IEnumerable(of T). Let's assume that in order to get the code to compile that I've modified the query so that there's a cast in the Where clause – like the following…

Dim records = From child In manager _
Where DirectCast(child, ChildBizObject).SalesDivision = "SouthEast"

The compiler then generates code similar to the following (I've simplified the code for clarity).

Dim records = Manager.Cast(Of Object)().Where(DirectCast(child, ChildBizObject).SalesDivision = "SouthEast")

Basically it appears that once the VB compiler sees that the class implements the loosely-typed IEnumerable [members are returned as object references] the compiler then calls the Cast method which generates a new collection containing the members of the original collection but this time the collection is typed as IEnumerable(of Object) [members are returned as … object references J]. I'm not sure why the compiler does this [I'd guess it's related to the same issue that causes the compiler to require that objects being queried implement IEnumerable/IEnumerable(of T)] but the net-effect is that the type being queried is now IEnumerable(of T) and therefore the built-in Where extension method gets used.

OK … So How'd You Get the SqlCeResultSet-based Extension Method to Work in VB

I don't mean to leave you hanging but this post is already so much longer than I wanted it to be – I'm going to call it a night here and post the details of how I worked around the issue tomorrow.

If you just can't wait, you can download the VB version of Demo three and checkout the code directly.

Oh … I wanted to mention that the webcast that goes with all of this is now available On-Demand.

See ya tomorrow.