Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

Fast GridView

, 4 Nov 2008 CPOL
A fast and optimized GridView.
Article_demo.zip
smartgridview with smartpager
App_Code
bin
SmartPagerIcon.bmp
using System;
using System.Net;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using Avg.Controls;
/// <summary>
/// Summary description for GridViewExtender
/// </summary>
/// 
namespace Avg.Controls
{
    public delegate void DataSourceChangedEventHandler(object sender, bool isEmpty);

    [ToolboxData("<{0}:GridViewPager runat=server></{0}:GridViewPager>")]
    public class GridViewPager : GridView
    {
        /// <summary>
        /// Handling when the DataSourceChange
        /// </summary>
        public event DataSourceChangedEventHandler DataSourceChanged;
       
        /// <summary>
        /// A readonly unique ID for the current view.
        /// </summary>
        public string CurrentViewID
        {
            get { return string.Concat("CurrentView_", UniqueID); }
        }
       
        /// <summary>
        /// Overrides the data source property, so that we get a chance to test whether the source
        /// being bound contains data or not.
        ///
        /// This is used to communicate with the pager so that for an empty list no pager is shown.
        /// </summary>
        public override object DataSource
        {
            get
            {
                if (ViewState[CurrentViewID] != null)
                    return ViewState[CurrentViewID];
                else
                    return base.DataSource;

            }
            set
            {

                base.DataSource = value;
                ViewState[CurrentViewID] = value;


                if (value == null)
                {
                    if (DataSourceChanged != null)
                        DataSourceChanged(this, true);
                }
                else
                {
                    if (DataSourceChanged != null)
                        DataSourceChanged(this, false);
                }
            }
        }

        /// <summary>
        /// Smart Pager
        /// </summary>
        protected SmartPager pager;

        /// <summary>
        /// Numero of Page cliked
        /// </summary>
        public int PageNumberCliked
        {
            get { return (ViewState["PageNumberCliked"] == null) ? 1 : Int32.Parse(ViewState["PageNumberCliked"].ToString()); }
            set { ViewState["PageNumberCliked"] = value; }
        }


        /// <summary>
        /// Display pager numeros grouped by  Display value before '...' buton
        /// </summary>
        public int Display
        {
            get { return pager.Display; }
            set { pager.Display = value; }
        }

        /// <summary>
        /// Current first row to display
        /// </summary>
        public int rowB
        {
            get { return (Page.Session["rowB"] == null) ? 0 : Int32.Parse(Page.Session["rowB"].ToString()); }
            set { Page.Session["rowB"] = value; }
        }
        
        /// <summary>
        /// Current end row to display
        /// </summary>
        public int rowE
        {
            get { return (Page.Session["rowE"] == null) ? PageSize : Int32.Parse(Page.Session["rowE"].ToString()); }
            set { Page.Session["rowE"] = value; }
        }

        /// <summary>
        /// Calculate Page Count
        /// </summary>
        public int PageCount
        {
            get
            {

                if (RowCount == 0)
                {
                    return PageSize;
                }

                if (this.DataSource == null)
                {
                    throw new Exception("Datasource is empy");
                }

                if (PageSize == 0)
                {
                    throw new Exception("Page size must be positive");
                }

                return (int)(RowCount / PageSize) + 1;


            }
        }

        /// <summary>
        /// Calculate Row Count
        /// </summary>
        public int RowCount
        {
            get { return (Page.Session["RowCount"] == null) ? 5 : Int32.Parse(Page.Session["RowCount"].ToString()); }
            set { Page.Session["RowCount"] = value; }
        }

        /// <summary>
        /// Current Page
        /// </summary>
        public int CurrentPage
        {
            get { return (ViewState["CurrentPage"] == null) ? 1 : Int32.Parse(ViewState["CurrentPage"].ToString()); }
            set { ViewState["CurrentPage"] = value; }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        public GridViewPager() : base()
        {

            pager = new SmartPager();
            pager.OnClickEvent += new OnClickPagerNumberEventHandler(pager_OnClickEvent);
           
        }

        #region events to implement on the page side

        private static readonly object OnSelectRowEventKey = new object();
        /// <summary>
        /// This events must be implemented with a select statement to get rows
        /// </summary>
        public event EventHandler DoSelectRow
        {
            add { Events.AddHandler(OnSelectRowEventKey, value); }
            remove { Events.RemoveHandler(OnSelectRowEventKey, value); }
        }

        protected virtual void OnSelectedRow(EventArgs e)
        {
            EventHandler handler = Events[OnSelectRowEventKey] as EventHandler;

            if (handler != null)
                handler(this, e);
            else
                throw new Exception("You must implement OnSelectRow method");
        }

        private static readonly object OnLoadRowCountEventKey = new object();
        /// <summary>
        /// This events must be implemented to know the row count
        /// </summary>
        public event EventHandler DoLoadRowCount
        {
            add { Events.AddHandler(OnLoadRowCountEventKey, value); }
            remove { Events.RemoveHandler(OnLoadRowCountEventKey, value); }
        }

        protected virtual void OnLoadedRowCount(EventArgs e)
        {
            EventHandler handler = Events[OnLoadRowCountEventKey] as EventHandler;

            if (handler != null)
                handler(this, e);
            else
                throw new Exception("You must implement OnLoadRowCount method");
        }


        #endregion events to implement on the page side


        #region Component event

        /// <summary>
        /// OnInit Event
        /// </summary>
        /// <param name="e"></param>
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);
            Page.Load += new EventHandler(Page_Load);
        }

        /// <summary>
        /// PageLoad Event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void Page_Load(object sender, EventArgs e)
        {

            if (!Page.IsPostBack)
                OnLoadedRowCount(EventArgs.Empty);

            bool goodCall = true;

            //the current page is posted 2 times : 
            // 1- in javascript SmartPager.js by SmartPagerSelectPage when a new page is clicked (with callback parameter)
            // 2- on  the pager_OnClickEvent (without callback parameter)
            foreach (string Key in Page.Request.Form.AllKeys)
            {
                if (Key.EndsWith("CALLBACKPARAM"))
                {
                    goodCall = false;
                }
            }

            //Handle just one time after pager_OnClickEvent call when the  CALLBACKPARAM is missing        
            if (goodCall)
            OnSelectedRow(EventArgs.Empty);
        }

        /// <summary>
        /// Load the Control
        /// </summary>
        /// <param name="e"></param>
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            Controls.Add(pager);
        }

        /// <summary>
        /// PreRender the Control
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPreRender(EventArgs e)
        {
            base.OnPreRender(e);
            pager.PageCount = PageCount;

        }

        /// <summary>
        /// Event Handler Click Page with ICallBackEventHandler in SmartPager
        /// </summary>
        void pager_OnClickEvent(object sender, string pPageNum)
        {

            PageNumberCliked = Int32.Parse(pPageNum);

            CurrentPage = PageNumberCliked;

            if (CurrentPage == 1)
            {
                rowB = 0;
                rowE = PageSize;
            }
            else 
            {
                rowE = (PageSize * CurrentPage) - 1;
                rowB = rowE - (PageSize - 1);
            }

            //Call postabck without call back parameters
            Page.Response.Write(
            "<script language='Javascript'>__doPostBack('__Page', 'MyCustomArgument');</script>"
            );

        }
        
        #endregion Component event
        

        #region IStateManager Members

        /// <summary>
        /// Load the ViewState
        /// </summary>
        /// <param name="savedState"></param>
        protected override void LoadViewState(object savedState)
        {
            if (savedState != null)
            {
                object[] state = savedState as object[];
                if (state != null && state.Length == 2)
                {
                    base.LoadViewState(state[0]);
                    if (state[1] != null)
                        ((IStateManager)this.pager).LoadViewState(state[1]);
                }
            }
            else
                base.LoadViewState(savedState);
        }

        /// <summary>
        /// Save the ViewState
        /// </summary>
        /// <param name="savedState"></param>
        protected override object SaveViewState()
        {
            object[] state = new object[2];
            state[0] = base.SaveViewState();
            if (pager != null)
                state[1] = ((IStateManager)this.pager).SaveViewState();
            return state;
        }

        /// <summary>
        /// Track the Viewstate
        /// </summary>
        protected override void TrackViewState()
        {
            base.TrackViewState();
            if (pager != null)
                ((IStateManager)this.pager).TrackViewState();
        }

        #endregion

    }

}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

David Zenou
Software Developer Several
France France
I am a Fan of dotnet technologies. I began to work with Java j2ee technologies and today i made my choice : .Net Framework is very pleasant , has excellents article codes and documentation.
I found very useful articles in codeproject , and today i want to give my contribution , and i hope that my articles will be useful.
 
Go to see my blog : http://davidzenou.blogspot.com/2009/01/david.html

| Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.141223.1 | Last Updated 4 Nov 2008
Article Copyright 2008 by David Zenou
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid