Head London

Late Binding of C# objects from NHibernate into the ASP.NET DataGrid control

Wednesday 26th April 2006 at 1:57 pm

It’s not a full example with code downloads, but here’s an example of late binding in C#, when we don’t know whether a class being bound into a DataGrid is going to be of type Article, Vacancy, Image, or whatever. I’ve found this to be a good approach when customizing a DataGrid that we can re-use in our internally-developed content management system.

Since the objects we get back from NHibernate, wonderfully enough, are just objects of the type we ask for instead of some stupid intermediate typeless object contained in a DataSet, we can just bind them into the DataGrid. The one thing that’s necessary is that we need to know anything going into the DataGrid needs to implement certain properties, like Title and Active.

First, we define an interface that content objects must implement:

[code]using System;
using System.Collections;

namespace com.headlondon.cms.models
{
///

/// IContent interface specifies the methods and properties that a piece of content must
/// implement. Other classes, such as headcms.admin.common.controls.datagrid.HeadGrid
/// rely on these details to be able to do late binding.
///

interface IContent
{
int Id { get; set; }
string Title { get; set; }
bool Active { get; set; }
void Save();
void Delete();
}
}
[/code]

Then we make sure our concrete classes do in fact implement this interface:

[code]using System;
using System.Collections;
using com.headlondon.cms.dataaccess;

namespace com.headlondon.cms.models
{
///

/// The base Article class representing HTML text content in the system. It can show up as-is, but is
/// also used by other classes such as Vacancy and FAQ for inheritance.
///

public class Article : IContent
{
private ArticleDao dao = new ArticleDao();

private int id;
private string title;
private string body;
private bool active;

///

/// Constructor.
///

public Article()
{
Id = -1;
Active = false;
}

///

/// Save the article to the database.
///

public void Save()
{
dao.Save(this);
}

public static IList List()
{
ArticleDao dao = new ArticleDao();
return dao.List(typeof(Article));
}
///

/// List articles that share a property value.
///

public static IList List(string property, object propertyValue)
{
ArticleDao dao = new ArticleDao();
return dao.ListByPropertyValue(typeof(Article), property, propertyValue);
}

///

/// List articles that share a property, order by an orderPropertyName and a value "ASC" or "DESC".
///

public static IList List(string property, object propertyValue, string orderPropertyName, string orderValue)
{
ArticleDao dao = new ArticleDao();
return dao.ListByPropertyValueOrderBy(typeof(Article), property, propertyValue, orderPropertyName, orderValue);
}

///

/// List articles by an orderPropertyName, and a value "ASC" or "DESC".
///

public static IList List(string orderPropertyName, string orderValue)
{
ArticleDao dao = new ArticleDao();
return dao.List(typeof(Article), orderPropertyName, orderValue);
}

///

/// Get an article by its Id.
///

public static Article Get(int id)
{
ArticleDao dao = new ArticleDao();
return dao.Get(typeof(Article), id) as Article;
}

///

/// Delete the article object from the database.
///

public void Delete()
{
dao.Delete(this);
}

// Accessors

///

/// The Article's Id.
///

public int Id
{
get { return id; }
set { id = value; }
}

///

/// The Article's Title.
///

public string Title
{
get { return title; }
set { title = value; }
}

///

/// The Article's Body text.
///

public string Body
{
get { return body; }
set { body = value; }
}

///

/// Is this Article active? I.e. does it show up on the public site?
///

public bool Active
{
get { return active; }
set { active = value; }
}
}
}[/code]

Then when we want to grab a piece of content from the database and stick it in a DataGrid using a DataBind method call, we don’t have to worry about what its concrete class is, we just say something like this:

[code]
///

/// Handler for the DataBinding event where we bind the data for a specific row
/// to the CheckBox.
///
/// Any type in the DataGrid must implement the interface IContent, which specifies that the
/// item must have an Id, Active, and a bunch of other properties.
///

private void BindData(object sender, EventArgs e)
{
CheckBox checkBox = (CheckBox)sender;
DataGridItem container = (DataGridItem) checkBox.NamingContainer;
IContent content = (IContent)container.DataItem;
checkBox.Checked = content.Active;
HtmlInputHidden oHid = (HtmlInputHidden)container.FindControl("oHid");
oHid.Value = content.Id.ToString();
}
[/code]

That code was from a custom CheckBoxItem class, the custom DataGrid class does something like this during its DataBind event:

[code]
IContent content = (IContent) e.Item.DataItem;
((HyperLink)e.Item.Cells[0].FindControl("lblC1")).Text = content.Title;
((HyperLink)e.Item.Cells[0].FindControl("lblC1")).NavigateUrl = formPath + content.Id;
[/code]

This blog post is just to put you on the right track, if you need more help with this sort of thing just reply in the comments. It’s been a pleasant way to get a lot of functionality out of very little code.

Web References:

If you’re not familiar with the basic concepts, there is a good discussion of late binding in C# and VB.NET here. Oddly it doesn’t include this interface trick above, so maybe this will help someone.

Posted by Dave Hrycyszyn in All, Head Labs | .