NOTE: This is a prototype, an idea, a random thought expressed aloud (well, in type). The code explains a concept and isn’t “tested” or production worthy (in my opinion).
Feedback is always appreciated. :) This is also what happens when I have a week off work and come back with ‘ideas.’
I find that a few of my projects, like the WebGallery2, all have a similar functionality. On pages with GridViews, ListViews (which, I’m slowly replacing all my GridViews with), or other DataBoundControls, I follow a common theme for data binding:
If the data set will be cached or in session, is that session/cache null OR has the data set been explicitly modified?
- true – regenerate the data set and repopulate session/cache.
- false – read the current data set from session/cache to the control.
In a single instance, the code to do this might look like:
private void BindList(bool hasBeenModified, string sessionVariable)
{
// If our session variable is null or the data has
// been explicitly modified, then rebuild the session variable.
if (Session[sessionVariable] == null || hasBeenModified)
Session[sessionVariable] =
db.GetWebFilesByGalleryName(this.Id);
resultsListView.DataSource =
Session[sessionVariable] as List<WebFile>;
resultsListView.DataBind();
}
This would then be called with:
BindList(true, “CurrentGallery”);
However, this code really bothers me.
The data source (the db.GetWebFilesByGalleryName method), data bound control (the resultsListView), and the type of the data source (List<WebFile> 
are all hard coded.
How could this helper method use generics to add a bit of resuability? What about when I want to use a GridView instead of a ListView, or have a List<Gallery>, List<String>, string[] of information?
First Attempt
The first attempt works. It takes the generics as anticipated and is rather easy to use.
protected void BindDataControl<TDataControlType, TEnumerableType>
(bool hasBeenModified, string sessionVariable,
TDataControlType dataControl, TEnumerableType dataSource)
where TDataControlType : DataBoundControl,
new() where TEnumerableType : IEnumerable
{
// Add the dataSource to session.
if (Session[sessionVariable] == null || hasBeenModified)
Session.Add(sessionVariable, dataSource);
// Read the data from session and bind the data control.
dataControl.DataSource =
(TEnumerableType)Session[sessionVariable];
dataControl.DataBind();
}
The constructor here has both generic parameters and standard parameters.
- TDataControlType has a generic constraint that requires it to be part of or a subclass of DataBoundControl (GridView, ListView, etc).
- TEnumerableType requires the source to inherit from IEnumerable (List, Array, etc).
Here are a few examples of using it this bit of code:
var gv = new GridView();
this.Page.Controls.Add(gv);
BindDataControl<GridView, Array>(
true, // this is new, so build a session variable.
“test”, // the session variable
gv, // the Id of our GridView
new[] // The data source, an array.
{ “hello”, “world” });
When rendered, we have a simple GridView with our two data items.
What about a more complicated example using collections and a ListView? On the current build of the WebStorage2 project, the galleries are built in a similar method (see this post for more details). I could just as easily replace the logic in Show.aspx’s Page_PreRender with:
BindDataControl<ListView, List<WebFile>>(
true,
“CurrentGallery”,
lv,
db.GetWebFilesByGalleryName(Request.QueryString["id"]));
So what’s the downfall to this method?
Downfall #1: It’s a performance nightmare. AFAIK, when passing a method (which GetWebFilesByGalleryName is a method from my LINQ DataContext), it is evaluated immediately. So, with that in mind, the hasBeenModified is irrelevant—it may not NEED to update the session, but the method will still go out, search the database, and return the results. That’s a bad deal.
What I don’t know and am not sure how to check is whether or not the lazy/delayed loading in LINQ would balance out this at all. Ideas?
Second Attempt
The second attempt adds in a bit more “generic” and a lot more reflective. By adding a reference to System.Reflection, we can simply pass a string reference to a “builder” method rather than the method it self—thus saving the prefabrication of the data source when it’s not really needed.
protected void BindDataControl<TDataControlType, TEnumerableType>
(bool hasBeenModified,
string sessionVariable,
TDataControlType dataControl,
string dataSourceMethod)
where TDataControlType : DataBoundControl,
new() where TEnumerableType : IEnumerable
{
// If session is null or has been modified (thus invalidated),
// update the session state.
if (Session[sessionVariable] == null || hasBeenModified)
{
// Invoke the specified method that
// creates our data source.
var data = Page.GetType().InvokeMember(
dataSourceMethod,.
BindingFlags.InvokeMethod |
BindingFlags.NonPublic |
BindingFlags.Instance,
null, this, null);
// Add it to session.
Session.Add(sessionVariable, data);
}
// Read the data from session and bind the data control.
dataControl.DataSource =
(TEnumerableType)Session[sessionVariable];
dataControl.DataBind();
}
In this method, the Page.GetType().InvokeMember method iterates through the methods on the page, finds the one that matches the string name passed to it, and executes it.
Then, with our “data” results, the rest is the same as the previous method.
Unfortunately, I cannot pass the LINQ direct lookup anymore because the scope of InvokeMember is limited to the calling page. I’ll need to create another little method, called GetResults in this case, to do the query for me.
protected List<WebFile> GetResults()
{
return db.GetWebFilesByGalleryName(Request.QueryString["id"]);
}
And the updated BindDataControl method:
BindDataControl<ListView, List<WebFile>>(
false,
“CurrentGallery”,
lv,
“GetResults”);
Now, since our constructor does not contain the method to fetch our data, simply a string, the results are not refetched each time the method is called—only when the requirements are met further in the code.
Downfall #1: This method requires an additional “helper” method on every page to fetch the data. You can’t access methods outside of the page—or can you?
Downfall #2: What happens if you need to pass parameters to your InvokeMember? You CAN, but the syntax is nasty and becomes even more difficult if the parameters are not always in the same order (which doubtfully they would be if you’re using generics).
Third Attempt
The third attempt looks more like the signature from Hell than a real method. There had to be a way around the “stuck on this page” snafu with the second attempt… and there was, by specifying the class too using a generic.
protected void BindDataControl
<TDataControlType, TEnumerableType, TDataSourceClass>
(bool hasBeenModified, string sessionVariable,
TDataControlType dataControl,
string dataSourceMethod,
TDataSourceClass dataSourceClass)
where TDataControlType : DataBoundControl,
new() where TEnumerableType : IEnumerable,
new() where TDataSourceClass : class
{
// If session is null or has been modified
// (thus invalidated), update the session state.
if (Session[sessionVariable] == null || hasBeenModified)
{
// Invoke the specified method that
// creates our data source.
var data = dataSourceClass.GetType().InvokeMember(
dataSourceMethod,
BindingFlags.InvokeMethod |
BindingFlags.NonPublic |
BindingFlags.Public |
BindingFlags.Instance,
null, dataSourceClass, null);
// Add it to session.
Session.Add(sessionVariable, data);
}
// Read the data from session and bind the data control.
dataControl.DataSource =
(TEnumerableType)Session[sessionVariable];
dataControl.DataBind();
}
Good grief.
This method adds a third generic to the constructor—TDataSourceClass—as well as the additional constraint requirement. I’ve also added an additional BindingFlag—Public—since most of the methods in LINQ DataContext classes are decorated public.
Rather than pulling from this.Page, we’re now calling InvokeMember from the parameter class and returning the results to the calling page. There’s one other change—rather than looking at “this” as the Binder parameter, we’re referencing the class passed along in the constructor—the dataSourceClass.
BindDataControl<ListView, List<WebFile>, WebGalleryDataContext>(
true,
“CurrentGallery”,
lv,
“GetWebFiles”,
db);
Here we have two additional parameters, the generic parameter, TDataSourceClass, that I’ve passed the LINQ Data Context into to define the Type of the dataSourceClass parameter passed later in the constructor.
“Verbalized”, the method’s generics read: BindDataControl to a ListView with the expected data format of a List<WebFile> using the WebGalleryDataContext class.
The parameters (which could be reordered to make better sense) read: the data is new or has changed, so store the results in “CurrentGallery” and return them to ‘lv’ (the ListView object on the web form). Fetch the data with GetWebFiles from the instance of db (the WebGalleryDataContext object instanciated previously in the page).
Downfall #1: Methods are still required—you cannot pass a simple data source to the BindDataControl method.
Downfall #2: Additional coding on the BindDataControl methods required to handle parameters.
This third attempt handles our most complex request—but what about the original “hello”/”world” array request? It can be done, but, as previously mentioned, requires extracting the array list outside of the method constructor.
protected void Page_Load(object sender, EventArgs e)
{
var gv = new GridView();
this.Page.Controls.Add(gv);
BindDataControl<GridView, ArrayList, Page>(
true, “junk”, gv, “Get”, this.Page);
}
protected ArrayList Get()
{
return new ArrayList {“hello”, “world”};
}
To reference methods that exist in the same code-behind page, this.Page and the Page class offer the correct class access.
So, is this the best way to do it? Probably not! How would you tidy this up or rewrite it? I’m interested!
In our Views > Home directory, we need to add a new MVC View Content Page item named Contact.