LINQ to Joe

Pro LINQ C# 2010 Now Shipping!

joe@rattz.com — Thu, 01 Jul 2010 22:42:35 GMT

My copies arrived a couple days ago and it is now in stock at Amazon.

Using LINQ To Filter By Object Type and Then Quantify

joe@rattz.com — Mon, 12 Apr 2010 21:48:28 GMT

Using LINQ To Filter By Object Type and Then Quantify

Every so often I run across a case where LINQ comes in so handy that I just want to post a quick article sharing some particular usage of it. For this example I was working on a web page that shows user roles and their permissions within my applictation. Below is a photo showing how the display looked before my added LINQ code.

My web application has other roles not listed in that image. This is why there are some permissions that none of the listed roles are approved for such as "Allow Access To Site/User/Role Maintenance". For this page, I wanted to omit any rows from the display where at least one of the roles wasn't approved for it. After all, these permissions were irrelevant for these roles. Displaying them would only confuse my users and invite support questions.

The data is being displayed in an ASP.NET GridView that has been bound to a DataSet. To omit the rows, I decided I would filter the DataSet prior to assinging the GridView's DataSource property and calling its DataBind method. Please notice that the first column of the GridView will contain a string for the description of the permission and each subsequent column will contain a bool specifying if that role is approved for the permission. One thing not obvious from the image is that the number of roles is driven by the database and is not static. If I add another role to my application there will be another column added here and I wouldn't want to have to modify this code to accommodate the additional role.

Below is my code to call the method to filter the DataSet. GetMyRoleData is just a dummy method to acquire the needed data and I do not show it in this example. I then call the FilterRows method that will delete all the rows from the DataSet for which no role has approval for that row's permission. I then set the GridView's DataSource property and call the DataBind method. Nothing of note so far.

DataSet ds = GetMyRoleData();
FilterRows(ds);
RoleComparisonView.DataSource = ds;
RoleComparisonView.DataBind();

Next comes my method to actually filter the unwanted rows. It would have been very easy to enumerate through each row, which I did, and then enumerate through each column of the row. If every column is set to false, delete the row. Or, if any column is true, don't delete the row. The latter would be more efficient because I could stop checking once the first column had a true value.

But instead of enumerating through each column and checking its value, LINQ can make the code so much simpler. Why not just use the Any operator? If any of the elements in the row's array of items is true, then I don't want to delete the row. Alternatively, I could use the All operator and make sure they are all set to false, but again, this would be less efficient and require every item to be checked. Using the Any operator instead of the All operator allows the code to stop once an item is true.

There is one last complication and that is the fact that the first column of each DataRow is a string for the permission description and not a bool for a role. This can easily be overcome though with the OfType operator. Just call the OfType operator on the array of items, ItemArray, and specify to only return elements of type bool. It's just that simple. Here is the code.

private void FilterRows(DataSet ds)
{
    bool someRoleHasPermission;
    foreach (DataRow dr in ds.Tables[0].Rows)
    {
        someRoleHasPermission = dr.ItemArray.OfType().Any(b => b == true);
        if (!someRoleHasPermission)
        {
            dr.Delete();
        }
    }
}

So, I enumerate through each DataRow in the DataTable's Rows collection. I then call the OfType operator on the row's ItemArray to return only those items that are a bool. Last I call the Any operator and provide a lambda expression returning true if any of the items is set to true. Very simple. I then call the DataRow's Delete method if I got a false back from the LINQ query. Just like that, my permissions have been filtered. Here is one last image showing the GridView after calling the FilterRows method:

As you can see, LINQ can make so many chores just that much more simple.

Using LINQ With System.Web.Caching.Cache (A Legacy Collection)

joe@rattz.com — Wed, 03 Mar 2010 22:49:05 GMT

Using LINQ With System.Web.Caching.Cache (A Legacy Collection)

In my previous blog post titled "Creating A Reusable AdRotator ASP.NET User Control Using LINQ" I took advantage of caching with the System.Web.Caching.Cache object to prevent constantly querying the database for the ad content. Since I intentionally didn't leverage the cache dependencies feature, my cached ad content would only refresh at a certain time interval. After putting that code into production I realized what I really wanted was a way to manually flush the cache of the ad content when I wanted to. This would allow me to keep the ad content cached for a long period of time but provided a way to flush the ad content when I wanted it to change.

So I created a page to allow me to delete just the cached objects that I wanted to. I did have one small complication though. I use a third party weather control and it uses the cache too for caching the weather data for each zip code for which it is displayed. In my production environment, it would not be unusual for there to possibly be several hundred cached weather data objects. Therefore, on my cache maintenance page, I wanted to filter those out, but provide a way to see them, and delete them, if I chose to.

I used the ASP.NET CheckBoxList server control on the page. This way I could check the ones I wanted to delete from the cache and press a delete button.

LINQ became very handy for controlling which cached objects I displayed, as well as programmatically checking them when the Select All checkbox was checked. Here is the basic user interface:

The Display Weather Objects? and Select All checkboxes are just regular checkboxes that autopost to the server when clicked. The checkboxes under the Select All checkbox are from the CheckBoxList and there is one checkbox for each Cache object, except those from the weather server control.

I took advantage of LINQ to filter out the weather cache objects like this:

if (DisplayWeather.Checked)
{
CacheObjectList.DataSource = Cache.Cast().OrderBy(i => i.Key);
}
else
{
CacheObjectList.DataSource = Cache.Cast().Where(i => !i.Key.ToString().StartsWith(WeatherId)).OrderBy(i => i.Key);
}

CacheObjectList.DataTextField = "Key";
CacheObjectList.DataBind();

If the DisplayWeather checkbox, the one labeled Display Weather Objects?, is checked, I simply use the OrderBy standard query operator to order the objects alphabetically by their key. Notice though that since the System.Web.Caching.Cache objct does not implement IEnumerable (and is therefore what I call a legacy collection), I can't call the OrderBy standard query operator on it directly. I must first call either the Cast or OfType operator first and specify the type of object in its collection, which in this case is DictionaryEntry. The Cast (or OfType) operator will return an IEnumerable (actually an IEnumerable in this case) that I can call the OrderBy operator on.

If the DisplayWeather checkbox is not checked, after calling the Cast operator, I then call the Where operator to return only those objects in the Cache whose key does not start with "WeatherDS:" which I have stored in the variable named weatherId. I use a variable for this string just to make sure I use it consistently throughout the code. Then, I order the objects again alphabetically. This allows me to filter out the weather control related Cache objects. Very nice.

Here is another screenshot showing the display if the Display Weather Objects? checkbox is checked:

Notice that in that image, I have a new checkbox labeled Select All Weather. This allows me to easily select just the weather checkboxes if I choose. I also use LINQ when the Select All Weather checkbox is changed:

protected void AllWeather_CheckedChanged(object sender, EventArgs e)
{
    foreach (ListItem li in CacheObjectList.Items.Cast().Where(i => i.Text.StartsWith(WeatherId)))
    {
        li.Selected = AllWeather.Checked;
    }
}

Above I use LINQ to only enumerate through those cache objects whose Text starts with my weather string.

But wait, there's more! What about when the Delete button is pressed? I also use LINQ to only enumerate through those checkboxes that have been selected:

foreach (ListItem li in CacheObjectList.Items.Cast().Where(i => i.Selected))
{
Cache.Remove(li.Text);
}

In the first paragraph of my book I ask, "Did you just feel your world shift?" I hope that by showing how useful LINQ can be, you can now understand why I ask.

For those interested in the third party ASP.NET weather server control, you can find out more about Milan Negovan's weather control here:

http://www.aspnetresources.com/articles/weather_server_control.aspx

and here:

http://www.aspnetresources.com/blog/weather_control_1_7.aspx

Creating A Reusable AdRotator ASP.NET User Control Using LINQ

joe@rattz.com — Fri, 12 Feb 2010 04:07:33 GMT

Creating A Reusable AdRotator ASP.NET User Control Using LINQ

I recently had the need for an AdRotator on one of my websites. ASP.NET already comes with an AdRotator server control but since I wanted to make it even easier to reuse, I decided to create an ASP.NET user control that leverages the ASP.NET AdRotator server control, but handles all the lower-level details.

Requirements

One of my requirements is that I wanted to be able to have multiple instances of this user control, perhaps even on the same page. I also wanted to be able to either have an instance have its own pool of ad content, or share the ad content with another instance. Since the built-in AdRotator control has a Keyword feature, that would be how I would control which pool of ad content an instance of the user control displayed content from.

Additionally, I wanted the ad content coming from the database, as opposed to a configuration (XML) file, which the built-in AdRotator server control allows as of ASP.NET 2.0. This way I could add new content right into the database.

Another requirement was that I didn't want the AdRotator hitting the database every time the page was refreshed. For this, I planned to use the Cache object that exists in ASP.NET.

Another requirement was that I wanted the ability to be able to temporarily disable an ad without having to remove it from the database, and I wanted to be able to provide effective and expiration dates for an ad so that they could come online and go offline automatically as scheduled.

My last requirement was that I wanted to use LINQ to SQL for the database access.

Creating an AdRotator user control using the built-in AdRotator server control and LINQ made this all fairly trivial to accomplish. Here is how I did it.

Creating the LINQ to SQL DBML File

First, lets start with my data model. Here is what my SQL Server database table looked like:

As you can see, I have all the fields needed for an ad including an image URL, navigation URL, keyword, enabled, effective date, and expiration date.

Next, in Visual Studio 2008, I created a LINQ to SQL DBML file for my AdRotatorContent table. To do this, right-click on your Project in the Solution Explorer window and select the Add | New Item menu. Select the LINQ to SQL Classes template and give the new item the name of your database. In this example, I will use Storefront for the name of my new item. This will create a file named Storefront.dbml in my project. This also means that I will have a derived DataContext class named StorefrontDataContext that I will use to access the database with LINQ to SQL.

Once the desginer canvas window is open, find your database in the tree of Data Connections in the Server Explorer window. You may need to add a connection to your database by right-clicking on the Data Connections node and selecting the Add Connection menu item. Once you have located (or created) your database in the Data Connections node, expand the Tables node. Drag the AdRotatorContent table node into the designer canvas as seen in the image above. Save your DBML file. This will allow you to access the AdRotatorContent table with your derived DataContext class, StorefrontDataContext in my case, using LINQ to SQL.

Creating the AdRotatorControl User Control

Next, I need to create the user control. I will name it AdRotatorControl. Here is the markup in the AdRotatorControl.ascx file:

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="AdRotatorControl.ascx.cs" Inherits="GPCStoreFront.UserControls.AdRotatorControl" %>

That's all there is to the markup. This is really trivial so far. I simply set the NavigateUrlField, AlternateTextField, and ImageUrlField properties to the names of the columns in the database where those values will come from.

Now let's take a look at the code-behind in the AdRotatorControl.ascx.cs file:

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace [YOUR NAMESPACE GOES HERE]
{
    public partial class AdRotatorControl : System.Web.UI.UserControl
    {
        public string Keyword { get; set; }
        public string Target { get; set; }
        public string CacheName { get { return String.Format("AdContent-{0}", Keyword); } }

Please notice that you will need to update the namespace with your namespace. Notice that I have added a using directive for the System.Data.SqlClient namespace since I will be using LINQ to SQL.

The only other significance of the code so far is that I have added three public properties: Keyword, Target, and CacheName.

I will use the Keyword property as a filter on the records from the AdRotatorContent table Keyword column. This is what will allow me to have multiple instances of the AdRotatorControl user control that either share the ad content or have independent content. I have made this a public property so that I can set the property in the markup for the AdRotatorControl user control. This will allow me to add the user control to a page without adding any code to the page to configure the user control.

I will use the Target property merely as a passthrough to set the AdRotator server control's Target property. This will dictate where the navigation URL will be loaded when the ad image is clicked. Use _blank to cause the URL to be opened in a new browser window. Use _self to open the URL in the current browser window. Of course you can use any valid target, but those are the standard ones that make the most sense. In my case, I will always use _blank because it is one of my self imposed web developement rules that no link should ever navigate away from your own site. This is also a public property so that it can be set in the markup thereby preventing the requirement of adding code.

I will use the CacheName property to retrieve the key name I will use to store and retrieve the ad content data from the Cache. Please notice that this property is a read-only property as there is no set statement. I wanted a property for the key name to make sure it was used consistently through the code. Also please notice that the key name is dependent on the Keyword property thereby establishing it's uniqueness in the Cache. You may want to make this property private, but I made it public just in case I want to access it from outside the class for debugging purposes.

Next, let's take a look at the Page_Load method:

        protected void Page_Load(object sender, EventArgs e)
        {
            this.AdRotator1.Target = Target;

            AdRotatorContent[] data = GetAdData();
            this.AdRotator1.DataSource = data;
            this.AdRotator1.DataBind();
            this.Visible = data.Length > 0;
        }

First, please notice that I am setting the AdRotator server control's Target property based on the user control's Target property. This is what I meant earlier when I said I was using it as a passthrough. Its sole purpose is to allow the AdRotator server control's Target property to be set from the user control's markup preventing the need to actually write any code to add an instance of the user control to a page.

Next I call the GetAdData mefhod. This is where all the real work will be done as well as caching. For now, we'll just assume it returns an array of ad content matching the Keyword specified in the user control's markup regardless of whether that data comes from the database or cache.

Then I simply bind the AdRotator server control to the array of ad content data and set the visibility of the user control depending on whether there is any ad content. This allows the user control to simply disappear if no ads exist for the specified Keyword that are enabled and valid for the current date and time.

Now let's take a look at the GetAdData method:

        private AdRotatorContent[] GetAdData()
        {
            // Attempt to retrieve the ad content data from the cache.
            AdRotatorContent[] data = Cache[CacheName] as AdRotatorContent[];
            if (data == null)
            {
                using (StorefrontDataContext dc = new StorefrontDataContext())
                {
                    DateTime now = DateTime.Now;
                    data = dc.AdRotatorContents
                        .Where(arc => arc.Keyword.Equals(Keyword) && arc.Enabled == true &&
                                     arc.EffectiveDate <= now && arc.ExpirationDate >= now)
                        .ToArray();
                    Cache.Insert(CacheName, data, null, DateTime.Now.AddMinutes(5), TimeSpan.Zero,
                        System.Web.Caching.CacheItemPriority.NotRemovable, null);
                }
            }
            return data;
        }
    }
}

I am hoping you are blown away by how trival this method turned out to be. First, I attempt to retrieve the ad content array from the Cache using the CacheName property I described earlier. Next, I check to see if it is null. If it is not null, I merely need to return the AdRotatorContent array. If it is null, meaning it is not in the Cache, I instantiate a StorefrontDataContext. This is my LINQ to SQL derived DataContext class. Notice that I am taking advantage of the using statement to automatically handle disposing the object when I am finished with it.

Next, I simply store the current time in a variable since I will reference it in more than one spot, just to ensure consistency of it.

Then I make my LINQ to SQL query. Notice that I am using the Where operator to retrieve only those ads for the specified Keyword that are enabled and whose effective and expiration dates make the ad valid now. Also please notice that I am calling the ToArray method to convert the returned IQueryable to an array. This is to prevent deferred query execution and the query executing later, after I have disposed of the StorefrontDataContext. Despite discussing deferred query execution at great length in my book, Pro LINQ: Language Integrated Query in C# 2008, even I forgot to be mindful of it, and this initially bit me. The most important part though is recognizing it when it happens and knowing how to resolve the problem. For this case, I decided to use the ToArray method to create an array from the IQueryable.

Next, I am inserting the array of ad content into the Cache using the CacheName property, again to ensure consistency between the insert here, and the retrieval at the beginning of the method. I am also specifying for the data to live in the Cache for 5 minutes. This means that the data will be cached for 5 minutes and then deleted from the Cache. When the next query arrives after the deletion, the code will cause the database to be queried and the data will be stored in the cache again where it will live for another 5 minutes. I used 5 minutes for this example because it is simple and makes testing the caching, disabling of ads, and effective and expiration dating of ads easier. You may want a longer time in production. In my real code, I will set this longer and store the time period in a configuration setting for the web application.

There are other, more sophistocated, ways to expire this data from the Cache, but for this purpose, a time limit is sufficient. You should be aware though that you can create Cache dependencies that will detect if a file or database table (among other things) is changed and delete the object from the Cache when that happens. So in fact, we could have created a database table dependency on the AdRotatorContent table itself so that when it is changed, the ad content is deleted from the Cache and then read again from the database. For a really important real-time system, that would be ideal. However, the way you do this is dependent on the database and its version so this is beyond the scope of this blog post. And, for most people's ad content, having such real-time access to the ads is not necessary. I expect Google would feel differently though. ;-) For more information about creating Cache dependencies or the Cache object in general, Matthew MacDonald's Pro ASP.NET 3.5 in C# 2008 (ISBN 1-59059-893-8) is a good read and I refer to it often.

Also notice that I am specifying a CacheItemPriority of NotRemovable. This is because I found that the caching on my production server didn't behave as I would expect. Despite having plenty of memory available, my Cache objects were getting flushed prior to their expiration time, and almost immediately. You can read more about this here:

http://www.west-wind.com/Weblog/ShowPost.aspx?id=11379

The last argument to the Insert method is a callback handler for when items get flushed from the cache. I have specified this to be null since I don't want a callback handler. This can however be a useful feature to determine why your Cache objects are getting flushed.

Adding the AdRotatorControl User Control To a Page

All that's left is to add the user control to a page. Here is the markup to do that:

Please notice that I am specifying the Keyword and Target properties. The Keyword will be used to filter just those ads in the database matching the Keyword specified in this property. This would allow me to put more than one instance of the user control on a single page but to have a different pool of ad content. For example, I might put one instance of the user control on the page and specify the Keyword as "Tech" to pull just those ads from the database having the Tech keyword. I might add another instance of the user control on the same page and specify the Keyword as "Political" to pull just the political ads. I could even add an instance of the user control to another page and specify the "Tech" or "Political" Keyword so that it would share the same pool of ad content.

Here are a couple screenshots of the AdRotatorControl user control in action:

Using ADO.NET Instead of LINQ to SQL

While it was one of my requirements to use LINQ to SQL, nothing says that you must. Should you prefer to use ADO.NET rather than LINQ to SQL, simply replace the LINQ to SQL code with ADO.NET code retrieving a DataSet from the database and store that DataSet in the Cache object instead of the array. This is a very trivial change to make.

All in all, I am very pleased with the way this AdRotatorControl turned out. I think you will find it fairly useful and simple to add to your web application.

A Practical Lambda Expression Example For The UPS Tracking Web Service Call

joe@rattz.com — Wed, 03 Feb 2010 20:17:28 GMT

A Practical Lambda Expression Example For The UPS Tracking Web Service Call

In "Pro LINQ: Language Integrated Query in C# 2008" I provided an example of the evolution of named methods to anonymous methods and finally to lambda expressions. I was illustrating the brevity that anonymous methods provide over named methods, and that lambda expressions provide over anonymous methods. Just this week, while consuming the UPS Tracking web service, I have yet again found lambda expressions to be useful for this purpose.

When compiling the UPS-provided test code, I received the following warning:

'System.Net.ServicePointManager.CertificatePolicy' is obsolete: 'CertificatePolicy is obsoleted for this type, please use ServerCertificateValidationCallback instead.

While it's just a warning and the code worked just fine, the code causing the warning has been obsolete for quite a while now so I thought I had better fix this now rather than potentially having to do it next time I upgrade to a new version of .NET.

Here is the code causing the warning:

System.Net.ServicePointManager.CertificatePolicy = new TrustAllCertificatePolicy();

Here we are instantiating an object from a class named TrustAllCertificatePolicy. That class implements the System.Net.ICertificatePolicy interface and here is the class code right from the UPS-provided test code:

public class TrustAllCertificatePolicy : System.Net.ICertificatePolicy
{
public TrustAllCertificatePolicy()
{ }

    public bool CheckValidationResult(ServicePoint sp,
      System.Security.Cryptography.X509Certificates.X509Certificate cert, WebRequest req, int problem)
    {
        return true;
    }
}

All that was really needed was just the CheckValidationResult callback function but it was implemented in .NET originally as an interface. This requires creating a named class implementing the interface, instantiating an object of that named class type, and setting a reference to the object. While this works, for a single callback, it is pretty verbose. So, they made that obsolete and added a callback delegate type (thanks Jon Skeet for the terminology - C# in Depth - ISBN: 1-93398-836-3) that looks like this:

public delegate bool RemoteCertificateValidationCallback (
    Object sender,
    X509Certificate certificate,
    X509Chain chain,
    SslPolicyErrors sslPolicyErrors
)

This would now allow you to call a named method. So instead of this:

...
System.Net.ServicePointManager.CertificatePolicy = new TrustAllCertificatePolicy();
...
public class TrustAllCertificatePolicy : System.Net.ICertificatePolicy
{
public TrustAllCertificatePolicy()
{ }

    public bool CheckValidationResult(ServicePoint sp,
      System.Security.Cryptography.X509Certificates.X509Certificate cert, WebRequest req, int problem)
    {
        return true;
    }
}

You would have this:

...
System.Net.ServicePointManager.ServerCertificateValidationCallback += CheckValidationResult;
...
public static bool CheckValidationResult(
    object sender,
    System.Security.Cryptography.X509Certificates.X509Certificate certificate,
    System.Security.Cryptography.X509Certificates.X509Chain chain,
    System.Net.Security.SslPolicyErrors sslPolicyErrors)
{
    return true;
}

Not bad. We eliminated a single use class and no longer have to instantiate an object from it. Anonymous methods make this even better so that you don't even have to write a named method. Changing the code to use an anonymous method looks like this:

System.Net.ServicePointManager.ServerCertificateValidationCallback +=
    delegate(
        object sender,
        System.Security.Cryptography.X509Certificates.X509Certificate certificate,
        System.Security.Cryptography.X509Certificates.X509Chain chain,
        System.Net.Security.SslPolicyErrors sslPolicyErrors)
    {
        return true;
    };

Even better. Not only do we no longer have a named class, we no longer have a named method. This is great for single-use methods. Now I'll take the last step and convert the code to use a lambda expression. Ready?

System.Net.ServicePointManager.ServerCertificateValidationCallback +=
(sender, certificate, chain, sslPolicyErrors) => true;

Wow, how about that! No named class. No named method. No verbose delegate syntax. Not even any parameter types. I could have specified parameter types had I wanted to, but for brevity I did not.

Changing the code from the initial, obsolete version, to the version using a lamda expression updated the code so that it is no longer obsolete and reduced the number of lines of code from twelve to two. Not to mention how much easier it is to read and understand...once you understand lambda expressions.

In all of these examples, the callback method simply returned true and you may need to update it for your needs.

I hope this demonstrates how lamda expressions can simplify your code as well as resolve the obsolete warning you may be seeing if you are consuming the UPS tracking web service.

Using LINQ to Generate Test Data with the Range Operator

joe@rattz.com — Wed, 21 Oct 2009 17:27:41 GMT

Using LINQ to Generate Test Data with the Range Operator

When working on Pro LINQ, one of the operators that caught my attention is the Range operator. The Range operator generates a sequence of integers. At the time, this seemed like it could be very useful for generating test data. I just used this again for a sample application I was working on and thought I should make a blog post about it.

int numItems = 200;

var list = Enumerable.Range(1, numItems)
                     .Select(i => new
                       {
                         Active = i & 1,
                         Id = i,
                         Description = "Site " + i.ToString(),
                         AccountNumber = "01015" + i.ToString("000"),
                         City = "City Ville",
                         State = "GA",
                         Local = i < 25,
                         COJ = i % 3
                       });

SearchCombo.DataSource = list;
SearchCombo.DataBind();

I have created a separate variable named numItems for the number of items I want to generate, but this obviously isn't necessary. Next I call the Range operator to generate a sequence of integers containing however many items I want in the test. I then call the Select operator on the sequence of integers and instantiate an anonymous object containing some sample data. Please notice that I used the integer from the sequence in each anonymous object. This of course isn't necessary either but makes for unique data. Some of the anonymous object's members (Local and COJ) are just initialized with a somewhat random expression based on the integer just to give the test data a more random look.

I then bind the generated sequence of test data to a combo box. In this case, it is an Infragistics' WebCombo control. Here is a screenshot.

Using the Range operator to generate test data can be very handy.

Pro LINQ: Language Integrated Query in VB 2008 Available and Shipping

joe@rattz.com — Wed, 12 Aug 2009 23:09:06 GMT

My latest book, Pro LINQ: Language Integrated Query in VB 2008, was published on August 10, 2009, and is now available and shipping from Amazon.

You may order it from Amazon or learn more about it at Apress.

Final Edits For Pro LINQ: Language Integrated Query in VB 2008 Have Been Submitted!

joe@rattz.com — Sun, 12 Jul 2009 06:17:23 GMT

I just turned in the final edits for my Pro LINQ: Language Integrated Query in VB 2008 book. That means it should actually be available in early August. Now I just have to update this site for it.

Using LINQ to Obtain a Control Reference in an ASP.NET Repeater Item's ControlCollection

joe@rattz.com — Fri, 23 Jan 2009 19:22:41 GMT

I haven't been blogging about LINQ much, but I am making it a new year's resolution to blog more frequently about LINQ. Now, don't expect daily or even weekly blog posts because I am just not as prolific as some bloggers. I don't know how some bloggers do it. But, I do plan on blogging more frequently.

One of my favorite, but under-utilized, ASP.NET controls is the Repeater. I think it exemplifies what it is that we like so much about the web; that is, the graphic representation of data. Sure, I use web grids more frequently, but when you have multiple instances of data that just doesn't fit in a single line well, the Repeater is the answer. Consider listings of homes for sale, or cars. You typically see an image of the house or car, and several fields of information. There are usually so many fields, that the data will just not fit in a single line in a grid. Plus, the image would make the line very tall. Using a Repeater, each repeating instance of data can have a format and occupy a rectangular screen space that is much taller than a row in a web grid, and you are not locked into an NxN grid. Here are a couple of examples of repeaters I have used:

In the image above, I have a page that is a mock-up of a newspaper, complete with columns. The idea with this page is here is all the news that is relevant to you, and it includes the user's Orders, Credits, and Invoices. Each item in one of the columns is a link to the item on another page where they can see all the data associated with that item. This page is neat because it lets the user see all their items from the week on a single page. Like a newspaper, you can see the price of the newspaper in the top right corner, and you can see a wink to the MasterCard "priceless" commericals there. That page has three Repeaters on it; one each for the Orders, Credits, and Invoices. Notice that each item in the Repeater has a specific format, and that the format for each Repeater (column) is slightly different. This is the beauty of the Repeater.

In the image below is a Repeater I use that contains a list of stores the user can import into their account. Again we are looking at repeating items with each item having a format. Please notice that there is a checkbox in each repeating item. Also notice that there is a Select All checkbox outside the Repeater. The purpose of the Select All checkbox is to select the checkbox in each repeating item.

On that page, I use a third-party set of web UI controls and during a recent upgrade of that control suite, something broke. When this happens, I need to create a sample application to demonstrate the problem, and the simpler it is, the better. As is always the case, my real application is too big, too complex, and dependent on too many environmental conditions to be able to provide the real page. Below is an image of the sample application I created to reproduce the problem that I could provide to the control's vendor.

In the image above, you can see a Select All checkbox followed by a list of checkboxes below it. Those checkboxes are items in a Repeater. When the user clicks the Select All checkbox, an AJAX postback is made to some code that enumerates through the Repeater's items, finds the checkbox in each item's template (ControlCollection), and checks (or unchecks depending on the state of the Select All checkbox) the Repeater item's checkbox.

Now here's probably the worst part of using a Repeater, dealing with the item's template. Since the Repeater uses a template, to obtain a reference to any control in the template, you must find the control in the Repeater item's ControlCollection. Prior to LINQ, that meant enumerating through the item's ControlCollection checking each control to see if it is the one you want. With LINQ, that is no longer necessary. Here is my code to obtain a reference to the CheckBox control in each item:

    protected void CheckBox1_CheckedChanged(object sender, EventArgs e)
    {
        foreach (RepeaterItem item in Repeater1.Items)
        {
            CheckBox cb = (CheckBox)item.Controls
                                        .Cast()
                                        .Where(c => c.ID == "CheckBox2")
                                        .SingleOrDefault();
            if (cb != null)
            {
                cb.Checked = CheckBox1.Checked;
            }
        }
    }

Notice that I enumerate through the Repeater's items. Next, I call the Cast operator on each item's ControlCollection (named Controls) because ControlCollection is a legacy collection that doesn't implement IEnumerable. I then call the Where operator on the sequence of Control objects returned by the Cast operator to find just the controls whose ID is equal to the ID I specified for the CheckBox in the template, which is "CheckBox2". Last, I call the SingleOrDefault operator to get a reference to that single control. I then check to make sure I got a reference, as opposed to null, and if I did get a reference, I set that control's Checked property equal to the Select All checkbox's Checked property. Voila, just that easy with a LINQ query, I now have a reference to a control in an ASP.NET Repeater control item's ControlCollection.

This is a fine demonstration of how to use LINQ to query legacy collections that do not implement the IEnumerable interface, as well has how to easily find a control by ID in a ControlCollection. Who said LINQ isn't fun?

LINQ to SQL Has a Future Despite the Rumors

joe@rattz.com — Mon, 22 Sep 2008 15:15:51 GMT

For the last several months, I have repeatedly heard a rumor that there was no future for LINQ to SQL. One reader even informed me that they heard LINQ to SQL was going to be snuffed and that because of this, their company changed architectural direction away from LINQ to SQL.

Concerned that the rumors may be either true and some developers are on a dead end path, or false and LINQ to SQL adoption may be suffering unnecessarily as a result of the rumors, I emailed Scott Guthrie at Microsoft to get his position on the future of LINQ to SQL.

Scott told me "Regarding LINQ to SQL, we definitely don't have plans to drop this. We plan to continue to fully support this going forward.".

Scott continued with "I actually blog most of my samples using LINQ to SQL these days (I just did one last week on ASP.NET MVC form scenarios and used LINQ to SQL for the data access). Expect to see me continue to blog more about it in the future.".

Here is a link to the blog post Scott refers to:

http://weblogs.asp.net/scottgu/archive/2008/09/02/asp-net-mvc-preview-5-and-form-posting-scenarios.aspx

If you read the blog post, you will see Scott using LINQ to SQL.

Further evidence of a commitment to LINQ to SQL is the work of Damien Guard, a Microsoft employee that works on LINQ to SQL. Here is a link to his personal blog: http://damieng.com/