To read the article online, visit

Displaying Custom Classes in a DataGrid, Part 2

By Scott Mitchell

  • Read Part 1

  • In Part 1 we discussed the basics of n-tier architectures and looked at how we would create our UserInfo class. In this part we'll look at how to create the UserCollection class.

    Creating the UserCollection Class

    At this point we have a class to abstractly define a particular user - UserInfo - but we need some way to define a collection of users. From our collection of users we want to be able to add users, remove users, pick out a particular user, and iterate through all of the users. Sounds like what the .NET collection classes were made for, eh? While we could use one of these .NET collection classes, such as an ArrayList, we may need to, at some point, add features to the UserCollection class that the ArrayList does not support.

    An ideal situation is to use inheritance. That is, our UserCollection class will inherit the base functionality of the ArrayList class, allowing us to reuse the functionality of the ArrayList and still be able to add our own functionality at some later point. (For more on inheritance, be sure to read Ian Stalling's article Using Object-Orientation in ASP.NET: Inheritance.)

    By inheriting the ArrayList class, the code for our UserCollection class is quite minimal, as shown below:

    Imports System
    Imports System.Collections
    Namespace MyObjects
        Public Class UserCollection
            Inherits ArrayList
            Public Sub New()
            End Sub
        End Class
    End Namespace

    Don't let the short amount of code for the UserCollection class fool you into thinking that this class doesn't provide any functionality - it just doesn't provide any original functionality. Since the UserCollection class is derived from the ArrayList class it supports all of the public methods and properties of the ArrayList class. That is, one can create an instance of the UserCollection class and then add elements to the collection by using the Add(object) method.

    Displaying the UserCollection Class in an ASP.NET Web Page

    If you've worked with ASP.NET much you're likely well aware of the ease with which ASP.NET allows you to display data. For example, the DataGrid control allows one to display a collection of data in an HTML table with just a few lines of code. (See An Extensive Examination of the DataGrid for more information on the DataGrid Web control.) Essentially, to display data in a DataGrid (or DataList or Repeater) you simply read some data into a DataSet or DataReader, and then set the DataGrid's DataSource property equal to this DataSet or DataReader. Finally, calling the DataGrid's DataBind() method renders the DataGrid as an HTML table populated with the data specified in the DataSource.

    The DataSource, however, need not be a DataSet or DataReader object. In fact, it can be any object that implements the IEnumerable interface, and guess what class implements the IEnumerable interface? Our UserCollection class! (It implements the IEnumerable interface since the ArrayList class implements this interface.) Therefore, we can bind a collection of users to a DataGrid.

    Not only can we bind a UserCollection instance to a DataGrid, but the DataGrid is smart enough when rendering the DataGrid to be able to render the UserInfo object instances that reside in the UserCollection instance that is to be displayed. In fact, in the DataGrid's Columns tag we can explicitly specify which properties of the UserInfo object to display. If this doesn't make sense, the following code example should help clear things up:

    <%@ Import Namespace="MyObjects" %>
    <script runat="server" language="VB">
      Sub Page_Load(sender as Object, e as EventArgs)
        'Create a user collection object
        Dim users as New UserCollection()
        'Now, fill it with some users
        users.Add(New UserInfo("Scott","Mitchell","111-222-3333",20))
        users.Add(New UserInfo("Jisun","Leeb","111-222-3333",25))
        users.Add(New UserInfo("Ed","North","111-555-3333",2))
        users.Add(New UserInfo("John","South","555-555-3322",105))
        'Now, bind the users collection to the DataGrid
        dgUserList.DataSource = users
      End Sub
    <form runat="server">
        <asp:DataGrid id="dgUserList" runat="server"
                <asp:BoundColumn DataField="FirstName" HeaderText="First Name" />
                <asp:BoundColumn DataField="LastName" HeaderText="Last Name" />
                <asp:BoundColumn DataField="PhoneNumber" HeaderText="Phone" />
                <asp:BoundColumn DataField="Visits" HeaderText="Number of Visits"
                    DataFormatString="{0:d}" ItemStyle-HorizontalAlign="center" />
    [View a Live Demo!]

    For this demo to work we need to be sure to copy our .NET components (the DLL files) to the Web application's /bin directory.

    Note that to bind a collection of UserInfo objects to a DataGrid we simply create a UserCollection object and add some UserInfo objects to it. We then set our DataGrid's DataSource property to the UserCollection object and call DataBind(). Our DataGrid can then display the various properties of the UserInfo objects. As our DataGrid declaration shows, in the Columns tag we can specifically specify what properties of the UserInfo object to show.

    Note that we are not limited to using a DataGrid. We could have used a DataList or Repeater control. To display a property using the databinding syntax you could do: <# DataBinder.Eval(Container.DataItem, "PropertyName") %>.

    Fleshing out the Business Object

    At this point the only way a UserCollection object is created is by creating one by hand, and adding UserInfo objects to it, as shown in the previous code example. However, from our ASP.NET Web page we would want to be able to call some business object method like GetUsers() that would retrieve all users from the database, returning a corresponding UserCollection object. Ideally you'd want to create a class, perhaps one named UserMethods, that would have a public, shared method called GetUsers() that would return a UserCollection object. This pseudocode might look like:

    Namespace MyObjects
        Public Class UserMethods
          Public Shared Function GetUsers() as UserCollection
            'Create an instance of the UserCollection object
            'Create a connection to the database
            'Get a DataReader of users
            'For each item in the datareader, create an instance of
            'the UserInfo class, setting its properties to the fields in
            'the particular DataReader row.  Finally, add this new UserInfo
            'object to the UserCollection object created earlier.
            'Once you've iterated through all of the rows in the DataReader,
            'return the built-up UserCollection object.
          End Function
        End Class
    End Namespace

    Once you had this function written you'd want to compile the component and deploy the DLL to the Web application's /bin directory. After compiling and deploying this DLL you could display a list of all the users from an ASP.NET Web page by using the following simple code:

    <%@ Import Namespace="MyObjects" %>
    <script runat="server" language="VB">
      Sub Page_Load(sender as Object, e as EventArgs)
        'Bind the users collection to the DataGrid
        dgUserList.DataSource = UserMethods.GetUsers()
      End Sub
    <asp:DataGrid id="dgUserList" runat="server" />

    Pretty easy and concise, eh? The benefit of using business objects is illustrated in the above example. Note that the ASP.NET Web page that displays a list of users can be ignorant to the database structure. That is, the ASP.NET Web page only cares about the UserMethods.GetUsers() interface. If the underlying database structure is altered, only the business objects have to be changed - the ASP.NET Web pages that utilize the business objects will just keep on working.


    In this article we have examined what business objects are and where they fit in an n-tiered architecture. The advantage of an n-tiered architecture is that each tier of the architecture need only be concerned with its neighboring tiers. That is, in our last example, the ASP.NET Web page only needs to know about the business objects and the Web browser. It does not need to know about the database makeup at all. This approach leads to quicker development time, fewer bugs, and more maintainable code. In addition, we saw just how easy it was to display custom classes through an ASP.NET Web page using a DataGrid.

    Happy Programming!

  • By Scott Mitchell

  • Article Information
    Article Title: ASP.NET.Displaying Custom Classes in a DataGrid, Part 2
    Article Author: Scott Mitchell
    Published Date: October 23, 2002
    Article URL:

    Copyright 2021 QuinStreet Inc. All Rights Reserved.
    Legal Notices, Licensing, Permissions, Privacy Policy.
    Advertise | Newsletters | E-mail Offers