Using the ObjectDataSource Control

Representing Objects with the ObjectDataSource Control

The ObjectDataSource control includes five main properties:

• TypeName—The name of the type of object that the ObjectDataSource control represents.
• SelectMethod—The name of a method that the ObjectDataSource calls when selecting data.
• UpdateMethod—The name of a method that the ObjectDataSource calls when updating data.
• InsertMethod—The name of a method that the ObjectDataSource calls when inserting data.
• DeleteMethod—The name of a method that the ObjectDataSource calls when deleting data.

An ObjectDataSource control can represent any type of object in the .NET Framework. This section discusses several types of objects you might want to represent. For example, you learn how to use the ObjectDataSource control with components that represent collections, ADO.NET DataReaders, DataSets, LINQ to SQL queries, and web services.

You can use the ObjectDataSource control to represent any object (any class that derives from the System.Object class). If the object does not support the IEnumerable interface, the ObjectDataSource control automatically wraps the object in a new object that supports the IEnumerable interface. You can even represent an ASP.NET ListBox control with an ObjectDataSource (not that a ListBox has any interesting methods).

Binding to a Component

Let’s start with a really simple component. The component in Listing is named MovieCollection. It contains one method named GetMovies(), which returns a collection of movie titles.

The ObjectDataSource control includes two properties named TypeName and SelectMethod. The  TypeName property contains the name of the component that you want to represent with the ObjectDataSource control. The SelectMethod property represents the method of the component that you want to call when selecting data. Notice that the GridView control is bound to the ObjectDataSource control through its DataSourceID property. When you open the page, the list of movies is retrieved from the MovieCollection component and displayed in the GridView. The MovieCollection component contains instance methods. The ObjectDataSource automatically creates a new instance of the  MovieCollection component before calling its GetMovies() method. It automatically destroys the object after it is finished using the object. You also can use the ObjectDataSource control to call shared (static) methods. In that case, the ObjectDataSource doesn’t need to instantiate a component before calling the

method.

Binding to a DataReader

Typically, you use the ObjectDataSource control to represent database data. The .NET Framework  provides you with multiple ways of representing data. This section discusses how you can use an ObjectDataSource to represent a DataReader.

The different ADO.NET objects are compared and contrasted in “Building Data Access Components with ADO.NET.” The ADO.NET DataReader object provides you with a fast, read-only representation of database data. If you need to retrieve database records in the fastest possible way, then you should use a DataReader object.

For example, the component in Listing 16.3, the MovieDataReader component, returns all the movies from the Movies database table by using the SqlDataReader object. Notice that the component imports the System.Data.SqlClient namespace to use this Microsoft SQL Server–specific ADO.NET object.

Binding to a DataSet

You also can use the ObjectDataSource when you need to represent an ADO.NET DataSet. Using a DataSet is slower than using a DataReader. However, you can perform advanced operations, such as filtering and sorting, on data represented with a DataSet.

Binding to a LINQ to SQL Query

LINQ to SQL is the preferred method of data access in the .NET Framework 3.5. The expectation is that you will use LINQ to SQL instead of ADO.NET to interact with a database. Chapter, “Data Access with LINQ to SQL,” is devoted to the topic of LINQ.

Binding to a Web Service

Web services enable you to share information across the Internet. When you communicate with a remote web service, you use a local proxy class to represent the web service located on the remote machine. You can use the ObjectDataSource to represent this proxy class.

If you are not using Visual Web Developer, you can create a web service proxy class from the command line by using the Wsdl.exe (Web Services Description Language) tool. When you click Add Reference, a new folder is added to your project named App_WebReferences. The App_WebReferences folder contains a subfolder named LocalServices. Finally, your web configuration file is updated to include the URL to the TimeService web service. Now that we have a consumable web service, we can represent the Web service using the ObjectDataSource control.

If you open the ShowWebService.aspx page from the CD that accompanies this book, you receive an error. Before the page will work correctly, you need to update the web configuration file with the correct path to the web service on your computer.

Using Parameters with the ObjectDataSource Control

You can use parameters when calling a method with the ObjectDataSource control. The ObjectDataSource control includes five parameter collections:

• SelectParameters—Collection of parameters passed to the method represented by the SelectMethod property.
• InsertParameters—Collection of parameters passed to the method represented by the InsertMethod property.
• UpdateParameters—Collection of parameters passed to the method represented by the UpdateMethod property.
• DeleteParameters—Collection of parameters passed to the method represented by the DeleteParameters property.
• FilterParameters—Collection of parameters used by the FilterExpression property.
• DataBound controls—such as the GridView, DetailsView, and FormView controls—can build the necessary parameter collections for you automatically.

Passing Objects as Parameters

Passing long lists of parameters to methods can make it difficult to maintain an application. If the list of parameters changes, you need to update every method that accepts the list of parameters. Rather than pass a list of parameters to a method, you can pass a particular object. For example, you can pass a CompanyEmployee object to a method used to update an employee, rather than a list of parameters that represent employee properties.

Using Parameters with the ObjectDataSource Control If you specify a value for an ObjectDataSource control’s DataObjectTypeName property, then you can pass an object rather than a list of parameters to the methods that an ObjectDataSource represents. In that case, the ObjectDataSource parameters represent properties of the object.

The DataObjectTypeName property has an effect on only the methods represented by the InsertMethod, UpdateMethod, and DeleteMethod properties. It does not have an effect on the method represented by the SelectMethod property. There is one important limitation when using the DataObjectTypeName property. The object represented by this property must have a parameterless constructor.

Paging, Sorting, and Filtering Data with the ObjectDataSource Control

The ObjectDataSource control provides you with two options for paging and sorting database data. You can take advantage of either user interface or data source paging and sorting. The first option is easy to configure, and the second option has much better performance. In this section, you learn how to take advantage of both options. You also learn how to take advantage of the ObjectDataSource control’s support for filtering. When you combine filtering with caching, you can improve the performance of your data-driven web pages dramatically.

User Interface Paging

Imagine that you want to use a GridView control to display the results of a database query in multiple pages. The easiest way to do this is to take advantage of user interface paging. User interface paging is convenient because you can enable it by setting a single property. However, there is a significant drawback to this type of paging. When user interface paging is enabled, all the movie records must be loaded into server memory. If the Movies database table contains 3 billion records, and you are displaying 3 records a page, then all 3 billion records must be loaded to display the 3 records. This places an incredible burden on both the web server and database server. In the next section, you learn how to use data source paging, which enables you to work efficiently with large sets of records.

Data Source Paging

Data source paging enables you to write custom logic for retrieving pages of database records. You can perform the paging in the component, a stored procedure, or a LINQ to SQL query. If you want the best performance, then you should write your paging logic in either a stored procedure or a LINQ query. We’ll examine both approaches in this section.

Designer surface, the Designer creates a new entity named Movy. The Designer is attempting to singularize the word and it fails badly. You must rename the entity to Movie in the Properties window. (I hope this Visual Web Developer grammar bug will be fixed by the time you read this). You are not required to use LINQ to SQL when you want to implement data source paging. As an alternative to LINQ to SQL, you can perform your paging logic within a SQL stored procedure.

The paging mechanism described in this section is based on the mechanism used by the Microsoft ASP.NET forums at http://www.asp.net/forums and the XBOX forums at http://www.xbox.com. Both of these websites handle an incredible number of message posts every day. The forums software was written with ASP.NET, and it is available from TelligentSystems (www.telligentsystems.com) as part of their Community Server product.

User Interface Sorting

If you need to sort the records displayed by the GridView control, then the easiest type of sorting to enable is user interface sorting. When you take advantage of user interface sorting, the records are sorted in the server’s memory.

Data Source Sorting

Imagine that you are working with a database table that contains 3 billion records and you want to enable users to both sort the records contained in this table and page through the records contained in this table. In that case, you’ll want to implement both data source sorting and paging.

Filtering Data

You can supply the ObjectDataSource control with a filter expression. The filter expression is applied to the data returned by the control’s select method. A filter is particularly useful when used in combination with caching. You can load all the data into the cache and then apply different filters to the cached data.

You learn how to cache data with the ObjectDataSource control in Chapter, “Caching Application Pages and Data.”

Behind the scenes, the ObjectDataSource control uses the DataView.RowFilter property to filter database rows. You can find detailed documentation on proper filter syntax by looking up the DataColumn.Expression property in the .NET Framework SDK Documentation.

Handling ObjectDataSource Control Events

The ObjectDataSource control supports the following events:

• Deleting—Occurs immediately before the method represented by the DeleteMethod property is called.
• Deleted—Occurs immediately after the method represented by the DeleteMethod property is called.
• Inserting—Occurs immediately before the method represented by the InsertMethod property is called.
• Inserted—Occurs immediately after the method represented by the InsertMethod property is called.
• Selecting—Occurs immediately before the method represented by the SelectMethod property is called.
• Selected—Occurs immediately after the method represented by the InsertMethod property is called.
• Updating—Occurs immediately before the method represented by the InsertMethod property is called.
• Updated—Occurs immediately after the method represented by the InsertMethod property is called.
• Filtering—Occurs immediately before the filter expression is evaluated.
• ObjectCreating—Occurs immediately before the object represented by the ObjectDataSource control is created.
• ObjectCreated—Occurs immediately after the object represented by the ObjectDataSource control is created.
• ObjectDisposing—Occurs before the object represented by the ObjectDataSource control is destroyed.

Notice that most of these events come in pairs. One event happens immediately before a method is called, and one event happens immediately after a method is called. You can handle these events to modify the parameters and objects represented by an ObjectDataSource control. You can also handle these events to handle any errors that might result from calling methods with the ObjectDataSource control.

Adding and Modifying Parameters

You can handle the Selecting, Inserting, Updating, and Deleting events to modify the parameters that are passed to the methods called by the ObjectDataSource control. There are several situations in which you might want to do this.

First, if you are working with an existing component, you might need to change the names of the parameters passed to the component. For example, instead of passing a parameter named id to an update method, you might want to rename the parameter to movieId. Second, you might want to pass additional parameters to the method being called. For example, you might need to pass the current username, the current IP address, or the current date and time as a parameter to a method.

Handling Method Errors

You can handle the Selected, Inserted, Updated, or Deleted events in order to handle any errors that might result from calling a method. For example, the page handles the Inserting event to capture any errors raised when the method represented by the ObjectDataSource control’s InsertMethod property is called.

Instead of handling errors at the level of the DataSource control, you can handle errors at the level of the DataBound control. For example, the DetailsView control supports an ItemInserted event.

Handling the ObjectCreating Event

By default, the ObjectDataSource control can represent only components that have a constructor that does not require any parameters. If you are forced to use a component that does require parameters for its constructor, then you can handle the ObjectDataSource control’s ObjectCreating event.

The ObjectCreating event is not raised when a shared method is called.

Concurrency and the ObjectDataSource Control

Imagine that two users open the same page for editing the records in the movies database table at the same time. By default, if the first user submits changes before the second user, then the first user’s changes are overwritten. In other words, the last user to submit changes wins.

This default behavior of the ObjectDataSource control can be problematic in an environment in which a lot of users are working with the same set of data. You can modify this default behavior by modifying the ObjectDataSource control’s ConflictDetection property. This property accepts the following two values:

• CompareAllValues—Causes the ObjectDataSource control to track both the original and new values of its parameters.
• OverwriteChanges—Causes the ObjectDataSource to overwrite the original values of its parameters with new values (the default value).

When you set the ConflictDetection property to the value CompareAllValues, you should add an OldValuesParameterFormatString property to the ObjectDataSource control. You use this property to indicate how the original values the database columns should be named.

Extending the ObjectDataSource Control

In this final section, we examine two methods of extending the ObjectDataSource control. You learn how to create a custom data source control by deriving a new control from the ObjectDataSource control. You also learn how to create custom parameters that can be used with the ObjectDataSource (and other DataSource controls).

As an alternative to registering the MovieDataSource control in a page, you can register the control for an entire application in the web configuration file within the <pages> element.

Creating Custom Parameter Objects

The standard DataSource Parameter objects included in the ASP.NET Framework enable you to represent objects such as query string values, items from Session state, and values of control properties. If none of the standard Parameter objects satisfy your requirements, you always have the option of creating a custom Parameter object.