IdeaSparx

PowerGuard - Free Android Power Management Application

noreply@blogger.com (John Eric Sobrepena) — Sun, 01 Jul 2012 03:39:00 +0000

Hello everyone. It has been so long since I made a post. I would like to thank all the subscribers, viewers and developers out there that provided feedback, encouragement and contribution to the ASP.NET CoolGrodView open-source project.

I have made a shift to Android development and therefore I am not doing any active development or update on IdeaSparx CoolGridView at this point in time. Having said that, I would like to announce one of my free Android application called PowerGuard.

PowerGuard defends the battery power of an Android device from power hungry WiFi and 2G/3G data connections. It regulates these WiFi and/or 2G/3G connections based on the need and configuration of a user. It extends battery life to lasts almost twice the amount of time than without it - given the same usage behavior. PowerGuard will always try to connect through WiFi and 2G/3G first. If it is unable to make a connection through WiFi, after some delay it will disable WiFi to conserve more battery power.

Screenshot

Features
★ Choose connection method whether to use WiFi only, 2G/3G only or both.
★ Turn on Wi-Fi/3G only when specific application is opened.
★ Option to ask subtly (using notification bar) if you need internet when an application is opened.
★ Turn on Wi-Fi/3G when device is unlocked. This only works if application monitoring is off.
★ Turn off Wi-Fi/3G when display goes off.
★ Schedule when Wi-Fi/3G should turn on or off every day.
★ Make periodic Wi-Fi/3G connection at specific duration when device's display is off giving the device more time to enter into sleep mode but still give a chance for your emails to synchronize.
★ Hit Emergency Connect in notification to enable Wi-Fi/3G connection for 30mins (configurable) then turns off automatically.
★ Disable Power Guard when certain battery power level is reached.
★ Shows battery level and temperature in notification area.*
★ Shows WiFi and 2G/3G connectivity status in notification area.*
★ Widget to enable or disable Service*
★ Widget to enable or disable Emergency connection to internet.*
★ Widget that displays battery level and temperature.*

*Note: Available in Pro version only

Try it out at Google Playstore. Thank you everyone for your support.

Build 20100207 fixes alignment of header's and table cell's width of CoolGridView

noreply@blogger.com (John Eric Sobrepena) — Mon, 08 Feb 2010 04:32:00 +0000

A new build release (Build 20100207) of CoolControls is now available at codeplex. Build 20100207 contains the following changes:

COLGROUP and COL is back! These are generated for the header, table content and footer. This feature can align the header and table cell's width of CoolGridView.
AllowResizeColumn property is added to CoolGridView. Set this property to true to enable user to resize the columnns manually, set it to false to disable. The default value of this property if true.

CoolGridView February 2010 Release

noreply@blogger.com (John Eric Sobrepena) — Mon, 01 Feb 2010 15:05:00 +0000

The newest release of CoolGridView is available for download. There are a handful enhancements, optimizations and bug fixes in this release. Here are the ones worth mentioning.

DefaultColumnWidth Property

You can now define the default column width of CoolGridView columns through the DefaultColumnWidth property. The value for this property can not be of type UnitType.Percentage. On older releases of CoolControls, if a HeaderStyle-Width is not defined for a data column, it defaults to 100px. This value is hard coded inside the control. Now you can specify your own default column width. I got a lot of requests to allow column and table widths to be specified in percentage. Allowing column or table widths to be in percentage and at the same time making sure that the column widths can still be resized by the properly is a great challenge. However, rest assured that I am not dropping this request and that the development of this functionality is still being considered.

SPAN inside Table Cell

There was a bug in CoolGridView when displayed in IE 6 and 7. It was reported by developers that it seems that the style "white-space:nowrap" does not behave properly when applied to TD and TH element when the "width" is also defined in the style. Consider the following code:

<table style="table-layout:fixed;width:90px" border="1">
 <tr>
  <td style="white-space:nowrap; width:30px; overflow:hidden;">Test inside the cell.</td>
  <td style="white-space:nowrap; width:30px; overflow:hidden;">Test inside the cell.</td>
  <td style="white-space:nowrap; width:30px; overflow:hidden;">Test inside the cell.</td>
 </tr>
</table>

If you view the code above in IE 6 or 7, you will see that the text inside the cell wraps and breaks on white spaces even though the style was set not to wrap on white spaces. The fix for this is to put a SPAN that encloses the text inside the cell and put the style "white-space:nowrap" on the SPAN instead of the TD. The code below now works properly in IE 6 or 7. CoolGridView uses something similar to this but uses CSS instead.

<table style="table-layout:fixed;width:90px" border="1">
 <tr>
  <td style="width:30px; overflow:hidden;"><span style="white-space:nowrap;">Test inside the cell.</span></td>
  <td style="width:30px; overflow:hidden;"><span style="white-space:nowrap;">Test inside the cell.</span></td>
  <td style="width:30px; overflow:hidden;"><span style="white-space:nowrap;">Test inside the cell.</span></td>
 </tr>
</table>

"Gradient" Theme

There is a theme included in the sample project in this release that gives a 3D look on the table headers. In this theme, the white spaces inside the cell is not set to wrapped. When user resizes the column width and if text does not fit inside the cell, ellipsis will appear at the end of the text to indicate that there are portion of the text that is hidden.

To use this theme, you have to copy the "Gradient" folder into your "App_Themes" directory and copy the headerbg.gif file into your website in the location "\images\". Set EnableTheming to "True" for your ASPX page and set the Theme property to "Gradient".

COLGROUP and COL Elements Removed

Older releases of CoolGridView generates COLGROUP and COL html tags to control the column widths. However, the control does not render properly in the browser if the entire cells for a column is hidden using the style "display: none". Therefore, COLGROUP and COL were removed.

For more information of what are the other changes, you can read the release notes included in the latest build.

Have a great week everyone!

CoolGridView New Release : Resizable Column Widths and Keeping Scroll Position

noreply@blogger.com (John Eric Sobrepena) — Mon, 25 Jan 2010 15:37:00 +0000

I am pleased to announce that CoolGridView control for ASP.NET 2.0 now allows user-resizable columns and it remembers the current scroll position and column widths after a postback or callback.

You can download the latest release at Codeplex.com. Here are the following changes in this release (Build 20100124). Please take note that item #1 and #2 and breaking changes. If you are going to replace your CoolGridView from old releases with this new one, please modify your code according to the instructions provided.

CoolCore.js and CoolCore.cs were added to IdeaSparx.CoolControls.Web project.

If you are using CoolGridView inside an UpdatePanel, the add-on script is not needed anymore. You should remove the JavaScript code (as shown here) from your ASPX page. This functionality is now fully integrated in the CoolGridView control.

//Remove this JavaScript from your ASPX
function AjaxEndRequestHandler(sender, args) {
    var p = sender._updatePanelClientIDs;
    if (p != null)
    for (var j = 0; j < p.length; j++) {
        var scripts = $get(p[j]).getElementsByTagName("script");
        // .text is necessary for IE.
        for (var i = 0; i < scripts.length; i++) {
            try {
                eval(scripts[i].innerHTML || scripts[i].text);
            } catch (e2) { }
        }
    }
}

try {Sys.WebForms.PageRequestManager.getInstance() .add_endRequest(AjaxEndRequestHandler);
}catch (e) { }

User can resize column headers' width.
Column header and scroll position are preserved after a postback or callback.

What a great way to start the week!

Have a great Monday everyone.

Data Bind CoolGridView to IQueryable<>

noreply@blogger.com (John Eric Sobrepena) — Fri, 22 Jan 2010 07:47:00 +0000

I recently received a question about how to data bind CoolGridView to an object of type IQueryable<> with automatic sorting and paging. CoolGridView extends ASP.NET GridView control. GridView does not directly support DataSource of type IQueryable<>, and the same is true for CoolGridView. We can use LinqDataSource control to bridge the gap. Quickly bind CoolGridView control to IQueryable<> with automatic sorting and paging capability by following these easy steps.

Drop a CoolGridView and a LinqDataSource control into your ASPX page.
In the "Properties" toolbox, set the DataSourceID of CoolGridView to point to your LinqDataSource control. Set the properties of CoolGridView control to the following:
- AllowPaging : True
- AllowSorting : True
Handle the "Selecting" event of LinqDataSource
In the "Selecting" event handler, call your method that returns an IQueryable<> object and assign it to the event argument's property "e.Result".

There you have it!

Have a great weekend everyone.

Down Memory Lane - How this idea sparked

noreply@blogger.com (John Eric Sobrepena) — Mon, 18 Jan 2010 11:41:00 +0000

Four months back I started this blog and my open-source project - IdeaSparx CoolControls. I am a fan of ASP.NET 2.0 GridView. In my opinion it is simple yet flexible, plain yet lightweight, unsophisticated yet powerful. GridView control is well designed that it is easy to customize and extend. Not only that, it is also possible to extend GridView so that it can nearly match any popular and commercially available third-party controls out there. The only thing, of course, is that it requires a lot of work. But the huge amount of "sweat" i put into this is all worth it. I have this monumental dream which I planned out in my head that someday, somewhere, somehow (haha, now i am being a bit melodramatic..) the ASP.NET community will have an open-source alternative over the commercially available grid controls. Therefore, I named this dream project - IdeaSparx CoolControls.

All About IdeaSparx CoolControls

One of its controls is CoolGridView which extends ASP.NET 2.0 GridView. At the end of 2009, CoolGridView was able to render GridView with fixed header, footer or pager and scrollable content. Now think about these features - resizable columns, rearrange columns, present hierarchical data, selective area reloading through AJAX, feature-rich Visual Studio designer support, sorting using multiple columns, data grouping, data binding tools for complex data structures, enhanced data editing and delivery of data-pages through streaming. I think these features are very much possible! Don't you think its cool? (hence, the name CoolGridView, by the way :) my next installment - having a CoolGridView with resizable columns is already on the way.

Thinking Ahead : To Infinity and beyond..

This year I have decided to jump a little higher and put a little more "sweat" into the project. And surely I will be blogging more about it. But I cannot run the next mile alone.. I need your help. Your inputs are very valuable (not to mention, it boosts my confidence from zero to maybe, 10). Whenever I log on and see a few comments which meant somebody out there finds this dream of mine workable, doable.. possible, I literally dash to my work desk and start pounding on my keyboard and try to do my best to keep you all in the loop of things.

I am glad to tell everyone that because of the recent string of feedback I received in the past couple of months, we were able to make CoolGridView more stable . We were able to make sure that the features worked perfectly on different browsers - Internet Explorer 8/7/6, Firefox 3.5/3.0, Safari and Chrome. This was made possible because you have all used the control and provided feedback. It's Teamwork, i guess so I thank you. I am indeed very grateful.

I hope that you would all stand by me in making this distant dream of mine a reality. This year let's create a CoolGridView control that is easy to use and packed with lots of useful features.

"To infinity and beyond..."

Render ASP.NET GridView Control with Resizable Column Header

noreply@blogger.com (John Eric Sobrepena) — Sun, 10 Jan 2010 05:47:00 +0000

Make the column headers of ASP.NET GridView control user-resizable with this three easy steps.

Download the JavaScript file from here.
Include the JavaScript file into your ASPX page.
Finally, initialize the component for your GridView control by inserting this JavaScript code at the end of your ASPX page.
```
var _ResizeTableHeaderDecorator = new ResizeTableHeaderDecorator({ GridID: "<%=GridView1.ClientID %>" });
```
Replace "GridView1" by the ID of the GridView control you want to enable column resizing.

It's that easy. It is tested to work with IE 8, Firefox 3.5, Safari and Chrome. This feature will soon be integrated with CoolGridView ASP.NET control. Here is a live example.

Column 1	Column 2	Column 3	Column 4	Column 5	Column 6	Column 7
Orange	Orange	Drive Sample	Great	Orange	Gateway	Gateway
Apple Drive	Doorway	Apple	Drive	Apple	Orange Doorway	Drive Sample
Great Apple	Gateway Gateway	Apple	Drive	Apple	Sample Drive	Sample Orange
Gateway	Doorway Doorway	Great	Great	Great Orange	Orange Doorway	Doorway Drive
Drive	Sample	Apple	Gateway	Apple Great	Orange Great	Orange Gateway
Gateway	Sample Drive	Sample Drive	Apple Apple	Orange Gateway	Drive	Gateway
Great Drive	Gateway	Drive	Great Doorway	Doorway	Orange	Doorway Sample
Gateway	Doorway	Great Doorway	Great Orange	Sample Doorway	Orange Apple	Sample
Drive	Great Gateway	Apple Apple	Gateway Orange	Drive	Gateway	Drive
Drive	Drive	Orange	Drive	Great	Doorway	Great Sample
Great Sample	Sample Sample	Drive Sample	Apple Great	Great Sample	Gateway Orange	Great
Great	Orange Gateway	Apple Doorway	Great Gateway	Drive	Apple Great	Great Great
Orange	Great	Apple Sample	Great Drive	Doorway	Doorway	Great Great
Orange	Drive	Doorway	Doorway	Gateway	Drive	Doorway Drive
Orange Gateway	Sample Apple	Apple Orange	Orange Gateway	Sample	Drive	Great Orange
Doorway Drive	Orange	Apple Doorway	Sample Orange	Orange	Sample	Apple Great
Gateway	Gateway Orange	Apple Apple	Gateway Apple	Great Orange	Doorway Great	Great
Doorway	Sample	Great Gateway	Drive Apple	Great	Orange Great	Orange Sample
Sample Great	Apple	Sample Sample	Doorway Apple	Gateway	Orange	Apple Doorway
Sample	Drive	Great Orange	Sample	Doorway Gateway	Doorway	Orange Apple

CoolGridView Quick Fixes Related to IE 6, Scrolling and UpdatePanel

noreply@blogger.com (John Eric Sobrepena) — Tue, 29 Dec 2009 03:55:00 +0000

I recently posted a quick fix for CoolGridView control. Below is a list of fixes.

It now works correctly in Internet Explorer 6.0 and 7.0.
Fixed the alignment of the fixed headers and footers when there are other HTML element or server controls before the CoolGridView in a page.
Control's scroll bars are properly rendered in the browser or in a modal window after a postback, or after a callback using AJAX control toolkit UpdatePanel.

Download the updated CoolControls and sample web application project from here.

For those who are using the CoolGridView control inside AJAX control toolkit's UpdatePanel control, make sure you have the following javascript code at the bottom portion of your ASPX page.

//This javascript code is required if you are using a CoolGridView inside an update panel.

function AjaxEndRequestHandler(sender, args) {
   var p = sender._updatePanelClientIDs;
   if (p != null)
   for (var j = 0; j < p.length; j++) {
          var scripts = $get(p[j]).getElementsByTagName("script");
          // .text is necessary for IE.
          for (var i = 0; i < scripts.length; i++) {
              try {
                   eval(scripts[i].innerHTML || scripts[i].text);
              } catch (e2) { }
          }
    }
}

try {
Sys.WebForms.PageRequestManager.getInstance() .add_endRequest(AjaxEndRequestHandler);
}
catch (e) { }

You can place this code in your master page if you wish. Please look at the sample web application included in the ZIP file.

CoolGridView Hot Fix Available for Download

noreply@blogger.com (John Eric Sobrepena) — Tue, 27 Oct 2009 15:25:00 +0000

Fixes to reported issues of using CoolGridView is now available at ASP.NET CoolControls for download. The top issues fixed were related to using CoolGridView control inside ASP.NET AJAX control toolkit's UpdatePanel. This alpha release was tested to work properly using Internet Explorer 8.0.6001, Firefox 3.5.3 and Safari 4.0.2.

Hierarchical presentation of data either through AJAX callback or postback rendering is in the works. Stay tuned.

Extend ASP.NET GridView to Support Fixed Header, Fixed Footer and Scrollable Content

noreply@blogger.com (John Eric Sobrepena) — Sun, 27 Sep 2009 17:02:00 +0000

I have started a project in CodePlex called IdeaSparx.CoolControls. The objective of this project is to extend the already powerful ASP.NET family of web controls. I initially started extending GridView to CoolGridView. CoolGridView, in addition to what GridView control can already provide, delivers the following features.

Fixed column header, footer and pager
Scrollable content
User-resizeable column widths (new!)
Maintains scroll position and column widths after a postback or callback (new!)

This release is tested in Internet Explorer 8.0.6001, Firefox 3.5.3 and Safari 4.0.2.
The features being developed in the pipeline are as follows.

Hierarchical presentation of data
Asynchronous streaming of data
AJAX sorting and paging
Enhanced data editing

If you think there are features that you need and are not in the list, just make your requests or comments.

Download the source code and demo project at IdeaSparks ASP.NET CoolControls

Run JavaScript Event-Handler in Another Context

noreply@blogger.com (John Eric Sobrepena) — Thu, 24 Sep 2009 10:04:00 +0000

When a JavaScript function is called by an event such as "onclick" or "onmouseover", it runs in the context of the calling DOM element. What if you do not want this event-handler to run under the context of the DOM element but instead you would like to run it under a custom object that you have created? Let us have the following example.

Listing 1

function MessageHandle(divObject, message) 
{
    this.Message = message;
    this.OnClick = function() 
    {
        alert(this.Message);
    }

    divObject.attachEvent('onclick', this.OnClick);
}

var divObject = document.getElementById("_divMain");
var _h = new MessageHandle(divObject, "Hello World!");

We are creating a function called MessageHandle that is later on used to instantiate a MessageHandle object at line 13. In the constructor of MessageHandle, we can see that the message ("Hellow World!") is stored in the property Message (line 3) and OnClick function is attached to the divObject's onclick event (line 9). The OnClick event handler simply shows an alert box showing the message "Hello World!".

So far so good. Now if you run this code and the click event of _divMain is triggered then you will get not the message "Hello World" but instead the message "undefined". What went wrong? Though OnClick is declared as a method of the object MessageHandle, the function will always run in the context of the calling object which is in this case _divMain and not the MessageHandle object. The "this" in line 6 is actually referring to _divMain. So how do we make sure that OnClick will run in the context of MessageHandle? We will create a new function and use the JavaScript's function apply().

Listing 2

function RunHandlerInContextOf(Context, Handler){
    return function() { 
             return Handler.apply(Context); 
         }
}

The function RunHandlerInContextOf has two parameters Context and Handler. Handler is the event-handler to execute and Context is the object context that Handler will run under. Notice that RunHandlerInContextOf function returns a function that is a wrapper to the event-handler call at line 3.

Now here is our updated JavaScript code.

Listing 3

function RunHandlerInContextOf(Context, Handler){
    return function() { 
             return Handler.apply(Context); 
         }
}

function MessageHandle(divObject, message) 
{
    this.Message = message;
    this.OnClick = function() 
    {
        alert(this.Message);
    }

    divObject.attachEvent('onclick', RunHandlerInContextOf(this,this.OnClick));
}

var divObject = document.getElementById("_divMain");
var _h = new MessageHandle(divObject, "Hello World!");

Here is a JavaScript cross-browser utility I created for attaching event-handlers and gives you an option to run the event-handler in the default context or specify another object as the context.

Listing 4

var CoolScriptingUtil = {
    //cross-browser attach event.
    //Element - is the object where eventhandler will be attached to
    //EventString    - is the event name to handle of Element
    //Handler is a function pointing to the event handler
    //Context is what context the Handler will be executed
    attachEvent: function(Element, EventString, Handler, Context) {
        if (typeof (Context) != 'undefined' && Context != null) {
            if (Element.addEventListener) // W3C DOM
                Element.addEventListener(EventString, CoolScriptingUtil.ContextOf(Context, Handler), false);
            else if (Element.attachEvent) // IE DOM
                Element.attachEvent('on' + EventString, CoolScriptingUtil.ContextOf(Context, Handler));
            else
                alert('Unable to attach to event ' + EventString + ' of ' + Element.toString());
        } else {
            if (Element.addEventListener) // W3C DOM
                Element.addEventListener(EventString, Handler, false);
            else if (Element.attachEvent) // IE DOM
                Element.attachEvent('on' + EventString, Handler);
            else
                alert('Unable to attach to event ' + EventString + ' of ' + Element.toString());
        }
    },

    //Returns a function that executes [Method] in the context of [ThisObj]
    ContextOf: function(ThisObj, Method) {
        return function() { Method.apply(ThisObj); };
    }
}

To use this utility we can now replace the command on listing 3 line 15 "divObject.attachEvent('onclick', RunHandlerInContextOf(this,this.OnClick));" with the following.

Listing 5

CoolScriptingUtil.attachEvent(divObject, 'click', this.OnClick, this);

The fourth parameter is optional. When you remove the fourth parameter, the event-handler will run in the default context.

Stream Data-Pages in ASP.NET Using GridView and SqlDataReader

noreply@blogger.com (John Eric Sobrepena) — Sat, 19 Sep 2009 14:58:00 +0000

This is my first blog entry. I am starting this blog to document ideas and most of the time - how these ideas were implemented. This will serve as a note and reminder for me and hopefully it will help other people (such as I.T. professionals) like you. This article is the first of two or three parts.

Let us move on directly to the topic I will be discussing. Say we have a time-consuming SQL query with the following characteristics:

The time of completion of execution is at T60 (e.g. 60 seconds)
The time-to-first-record* is at T10 (e.g. 10 seconds)
The SQL query is already fully optimized

*Note: for the purpose of this article, time-to-first-record is the point in time when the first row becomes available in the buffer for reading using SqlDataReader’s Read method.

The objective is to be able to respond to the web request as soon as possible by showing some data to the browser while a background thread continues to pull data from the data store. In other words, as soon as there are enough rows available for the first data-page, we can bind that data to the GridView and render it to the client while more data is retrieved and buffered on the background. This strategy is quite common in windows applications, but how can we achieve this in a web application? Here are four simple strategies we will use to achieve this.

Asynchronously buffer data from data store
Stream data-pages to the client
Cache the buffer in server-side
Cache the data-pages on the client-side

Below are some assumptions before we move on.

Paging of data will be used.
One data-page contains 200 rows.
The time-consuming SQL query returns 5,000 rows.
DataTable will be used as a buffer.
SqlDataReader will be used to read rows from data store. This will allow us to read one row at a time while data comes in from the data store.
GridView will be used to present the data-pages.
ICallbackEventHandler will be implemented to facilitate AJAX calls.

The illustration below should give you a better picture of how these strategies are implemented. This shows us the complete HTTP request-response flow in retrieving and presenting the first data-page from the SQL query.

An HTTP request to retrieve data is received from the web browser and is processed by the ASPX handler or ASPX page in the web server. At this point, we need to generate a cache ticket or id that will be unique for this first request.
Rather than executing the time-consuming query straight away against our data store, a background thread is created first from the ASPX handler.
The background thread opens a connection to the data store, executes the time-consuming SQL query and retrieves a SqlDataReader instance. Using the SqlDataReader, the background thread creates an empty DataTable with the same schema as the data that will be read from the data store. The buffer will be cached in memory for future reference using the cache ticket.
The background thread starts reading rows and copies them into the buffer until the end is reached.
While the background thread is copying rows to the buffer, the ASPX page is actually waiting for either of two things to happen, either a) the buffer has enough rows for one data-page or b) the background thread has completed filling the buffer. In any of these two conditions, the ASPX page will copy 200 or less number of rows and data-bind it to the GridView control.
ASPX page is rendered with the GridView control displaying the first data-page.

How do we retrieve the other data-pages now? Simple, we will do the same way as we did for getting the first data-page with some few modifications. This time we will make the request through AJAX, pass the cache ticket and page number, and return the rendered GridView control in response to the AJAX call. Here is how our implementation would look like.

Succeeding request to get the next data-pages is made through AJAX call using the Callback framework of ASP.NET 2.0. The cache ticket and page number of the data-page being requested are transmitted with the AJAX call.
ASPX page handles the request and inspect the buffer if it has rows for the requested data-page with page number page number. Because the buffer is cached in memory, we are able to obtain a reference to the buffer using the cache ticket. Note that at this point in time, the background thread may still be populating our buffer or it might have already completed (as seen in the diagram above).
If there are enough rows for the requested data-page, the rows are then data-bind to the GridView control. GridView control is then rendered in memory using the RenderControl method. The resulting HTML is then transmitted to the web browser. The web browser then stores or caches this data-page (now represented in HTML) into a JavaScript array of string.

These steps repeats continuously until there is no data-page left that can be read from the buffer.

Here is the outcome of the process that implements our strategy. First, we were able to respond to the web request as soon as possible instead of waiting for the time-consuming SQL query to finish before showing data on the web browser. Secondly, we now have all the data-pages in the client-side stored in a JavaScript array of string. What this means is we can go from one data-page to another very quickly, seamlessly and it does not require us to make another request to the web server. Finally, we still have the DataTable acting as a buffer which is cached in the server-side. We can use the cached buffer to perform sorting instead of hitting again the data store, or we can use this to search within a search results.

One caveat - the implementation I just presented has a trade-off. We are actually allocating more memory to have a more responsive web application. This implementation allows web applications to respond to retrieval of data quicker and navigating though data-pages faster and more seamless. Another advantage of using this implementation is that it will work with any data store and we do not need to implement any paging on the database’s side (like using ROW_NUMBER() in SQL 2005). One way I can think of to minimize the impact of allocating more memory is to destroy the data-page in the server-side cache after it is transmitted to the client-side. Another way is to have a distributed caching strategy so that buffering will only be initiated in one server in a web server farm (more about this in my future posts).

In my next post, I will be showing you how this is actually implemented in ASP.NET and C#. I will also share with you one complete example that can be downloaded as a Visual Web Express 2008 solution. We will also explore a distributed caching strategy to efficiently implement this technique in a server farm.

I hope you found this post helpful. If you have questions, please feel free to email me or leave a comment and I will get back to you as soon as I can.