Create a paging control for ASP.NET

ASP.NET control.

[/ html]

The following code illustrates the data binding process implemented by the SQLPAger control.

Public override void database.databinding (); // must recreate control ChildControlScreated = false after data binding (); // Make sure the control exists and list control _ControlTopaginate = Page.FindControl controlToPaginate); if (_controlToPaginate == null) return; if ((_ controlToPaginate is BaseDataList || _controlToPaginate is ListControl!)) return; // ensure adequate connection information and specify the query if (ConnectionString == "" || SelectCommand = = "") Return; // Get data IF (PagingMode == PagingMode.cached) fetchaLData (); else fetchPageData (); // Bind data to partner control basedataDataList baseDataListControl = null; ListControl ListControl = NULL; if (IF _controlToPaginate is BaseDataList) {baseDataListControl = (BaseDataList) _controlToPaginate; baseDataListControl.DataSource = _dataSource; baseDataListControl.DataBind (); return;} if (_controlToPaginate is ListControl) {listControl = (ListControl) _controlToPaginate; listControl.Items.Clear (); listControl .Datasource = _datasource; listControl.database (); return;}} Different acquisition routines are called according to the value of the PagingMode property. In any case, the result set binds to the instance of the PagedDataSource class. This class provides some features used to page data. In particular, when the entire data set is stored in the cache, the class will automatically retrieve the record of the current page and return to the Boolean value to provide information about the first page and the last page. The internal structure of this class will be described later. In the above list, the PageDataSource object of the help program is represented by the _DataSource variable.

The SQLPAger control then calculates the type of the partner control and binds the contents of the PageDataSource object to the DataSource property of the partner control.

Sometimes the above DATABIND method also re-sets the ChildControlScreated property to false. So why do you do this?

When the page containing the paging program is returned, all controls are recreated; paging programs are no exception. Normally, all controls and their sub-controls are created before preparing to display the page. At a moment before receiving an onprender notification, the protected ensurechildControls method will be called so that each control can generate its own control tree. After this event, the data binding process is complete, and the new data is stored in the cache.

However, when the page returns due to a constituent control of the paging program (ie, the user clicks to change the page), the control tree of the sub-page program will be generated, and the display phase is not reached. In particular, when processing related server-end events, the control tree must be generated, so that the control tree is generated before the data binding begins. Difficulties are that the data binding will modify the page index, which must be reflected in the user interface. If you do not take some countermeasures, when the user switches to another page, the page index in the paging program will not be refreshed. There are various ways to solve this problem, but it is important to figure out the problem and its real reasons. You can avoid generating control trees and generate all outputs in the Render method. Alternatively, you can also modify the part of the affected data binding changes in the tree. This article selects a third method, which requires less code, and it is possible to solve the problem regardless of which portion of the user interface is subject to data binding changes. You can invalidate the trees of previously created controls by setting the ChildControlScreated property to False. This will recreate the control tree before display.

Pagination engine

The SQLPAger control supports two ways to retrieve data - cache and non-cache. If the former is used, select commands to execute, and the entire result set will be bound to the data source object that is paid inside. The PageDDataSource object will automatically return a record that is suitable for a specific page. The PagedDataSource class is also a system component that is running behind the DataGrid default paging mechanism.

Retrieve all records but only a few records suitable for the page, which is usually not a wise approach. Due to the stateless characteristics of the web application, in fact, a large number of queries may be run each time the page is requested. To make the operation valid, adopting a cache data retrieval method must rely on a cache object, ASP.NET's Cache object is a good candidate object. The use of cache technology speeds up the running speed of the application, but the data snapshot provided cannot reflect the latest changes. In addition, it needs to use more memory on the web server. And ridiculous is that if a large amount of data is cached by a session, it may even cause a big problem. The Cache container is globally for the application; if the data is stored in it, you need to generate a specific item name with a session.

The top of the Cache object is fully supported expiration strategy. In other words, the data stored in the cache can be automatically released after a period of time. The following code illustrates a private method used to get the data and store it in the cache in the SQLPAger class.

[quote]

Private void fetchaalldata ()

{

// Find data in ASP.NET Cache

DataTable data;

Data = (DATATABLE) Page.cache [cachekeyname];

IF (data == null)

{

// Modify SELECTCOMMAND using Order-by information

AdjustSelectCommand (TRUE);

// Go to the database if the data expires or never been acquired

SqlDataAdapter Adapter = New SqldataAdapter (SELECTCOMMAND, CONNECTION);

Data = new datatable ();

Adapter.Fill (data);

Page.cache.insert (CacheKeyname, Data, NULL,

DateTime.now.addseconds (Cacheduration),

System.Web.caching.cache.noslidingExpiration;

}

// Configuring the data source components of the paging

IF (_datasource == null) _DataSource = new pagedDataSource ();

_DataSource.DataSource = data.defaultview;

_DataSource.Allowpaging = true;

_DataSource.pageSize = itemsperpage;

Totalpages = _datasource.pagecount;

/ / Make sure the page index is valid

ValidatePageIndex ();

IF (currentpageIndex == -1)

{

_DataSource = null;

Return;

}

// Select the page you want to view

_DataSource.currentPageIndex = CURRENTPAGEINDEX;

}

[/ quote]

The control and request cache project name are unique. It includes a page of the URL and the ID of the control. Data is bind to the cache within the specified time (in seconds). To expire, you must use the cache.insert method. The following simpler code adds the item to the cache, but does not include any expiration strategy.

[quote]

Page.cache [cachekeyname] = DATA;

[/ quote]

PagedDataSource object Gets data to be paid through its DataSource property. It is worth noting that the DataSource attribute of the PagedDataSource class accepts only the IEnumerable object. DataTable does not satisfy this request, this is why the defaultview property is taken.

The SelectCommand property determines the query running on the SQL Server database. This string is preferably in the form of select-from-where. The ORDER BY clause is not supported, and if the clause is specified, it will be deleted. This is what the AdjustSelectCommand method is. Use the sortfield property to specify any sorting information. The AdjustSelectCommand method itself will add a correct ORDER BY clause according to the value of sortfield. Does this do this?

When the paging program operates in a noncached mode, the original query will be modified to ensure that the current page record is retrieved. The actual query text performed on SQL Server will take the following form.

Select * from (select top itemsperpage * from (select Top Itemsperpage * CurrentpageIndex * from (selectcommand) AS T0 Order by Sortfield ASC) AS T1ORDER BY SORTFIELD DESC) AS T2 ORDER BY SORTFIELD

The query makes up for the defect of the ROWNUM clause in SQL Server 2000, and reorders the record so that only the "Nth" block of the x item is returned after proper sorting. You can specify a base query, and the paging program will be broken down into multiple smaller pages. Only records suitable for a page are returned. As you can see, in addition to the query command, the above query needs to process the sort field. That's why add the sortfield property added. The only drawback of this code is that the default is sorted in ascending. This code is really perfect by allowing ASC / DESC keywords.

Private void fetchPageData () {// Need a validated page index to get data. // The actual page number is also required to verify the page index. AdjustSelectCommand (false); VirtualRecordCount countInfo = CalculateVirtualRecordCount (); TotalPages = countInfo.PageCount; // verification page (or to ensure effective CurrentPageIndex "-1") ValidatePageIndex (); if (CurrentPageIndex == -1) return; // prepare And run the command SQLCommand cmd = prepareCommand (countinfo); if (cmd == null) return; sqldataadapter adapter = new SqlDataAdapter (CMD); DataTable Data = new data (); adapter.fill (data); // Configuring data source assembly if (_dataSource == null) _dataSource = new PagedDataSource (); _dataSource.AllowCustomPaging = true; _dataSource.AllowPaging = true; _dataSource.CurrentPageIndex = 0; _dataSource.PageSize = ItemsPerPage; _dataSource.VirtualCount = countInfo.RecordCount; _dataSource. DataSource = Data.defaultView;} In Noncached mode, the PageDDataSource object does not provide the entire data source, so the total number of pages to be paid can not be calculated. Thereby, the AllowCustomPaging property must be tagged and the actual number of records in the data source is provided. Typically, the actual number is to retrieve the Select Count (*) query. This model is almost the same as DataGrid's custom paging. In addition, the current page index selected in the PagedDataSource object is usually 0, because one page record has been stored.

The implementation method of the SQLPAger control is introduced here. Let's introduce it to its method.

Use SQLPAGER controls

Assume that there is a sample page containing the ListBox control. To use a paging program, make sure the .aspx page registers the assembly of the control.

<% @ Register tagprefix = "expo" namespace = "devcenter" assembly = "sqlpager"%>

The tag of the control depends on the properties of the actual setting. The following tags are an rational example:

In addition to the page program, the page also contains a list box and a button. The list box will display the contents of each page; the button is only used for the first time fill the list box. This button has a clicking event handler, defined as follows.

Private void loadingfirst1_click (object sender, evenetargs e) {sqlpager1.currentpageIndex = 0; sqlpager1.databind ();

Figure 2 shows the page in the operation.

Figure 2: SQLPAger control works with the ListBox control.

Use the DataList control to generate a more interesting example. The goal is to use the paging program to browse the personal record of each Northwind staff. This DataList is shown in the following list.