How to delegate telerik grid view common methods to be call from parent page from every child page?

Question

I am using Telerik Gridview for displaying list of records and i have more than 10 pages on which i am using this gridview with this following common events code copy pasted(with some minor changes) on all this pages:

protected void Page_Load(object sender, EventArgs e)
{
    DisplayRecords()
}

public void DisplayRecords()
{
    //Grid view names are different on different pages.
    GridView1.DataSource=Fetching records from database.
    GridView1.DataBind();
}

protected void GridView1_SortCommand(object sender, GridSortCommandEventArgs e)
{
    DisplayRecords()
}

protected void GridView1_PageIndexChanged(object sender, GridPageChangedEventArgs e)
{
    var index = e.NewPageIndex;
    DisplayRecords()
}

protected void GridView1_PageSizeChanged(object sender, GridPageSizeChangedEventArgs e)
{
    var size = e.NewPageSize;
    DisplayRecords()
}

This is my one page which inherits from following page:

public partial class LoadSettings : ParentPage
{
    //Load events and other events
}

[Serializable]
public class ParentPage: RadAjaxPage
{

}

Page 1:**ttt.aspx**
public void DisplayRecords()
    {
        //Grid view names are different on different pages.
        GridView1.DataSource=this.GetAlltttData()
        GridView1.DataBind();
    }

    public DataTable GetAlltttData()
            {
                using (var context = new MyDataContext())
                {
                    var data = from c in context.ttt select c;
                    return MyDataContext.LINQToDataTable(data);
                }
            }


Page 2:**bbb.aspx**
public void DisplayRecords()
    {
        //Grid view names are different on different pages.
        GridView1.DataSource=this.GetAllbbbData()
        GridView1.DataBind();
    }

    public DataTable GetAllbbbData()
            {
                using (var context = new MyDataContext())
                {
                    var data = from c in context.bbb select c;
                    return MyDataContext.LINQToDataTable(data);
                }
            }

protected void rgbbb_SortCommand(object sender, GridSortCommandEventArgs e)
        {
           DisplayRecords()
        }
protected void rgbbb_PageIndexChanged(object sender, GridPageChangedEventArgs e)
        {
            var index = e.NewPageIndex;
            DisplayRecords()
        }

 protected void rgbbb_PageSizeChanged(object sender, GridPageSizeChangedEventArgs e)
        {
           var size = e.NewPageSize;
           DisplayRecords()
        }

So is this possible that i can place all this events in this ParentPage page and just call from every child page instead of polluting my every page with this events??

Note:In some of my pages this DisplayRecords methods can contains some parameters but rest all events are just common.

Answer 1

May be you can put you common logic inside abstract class with method (or property) that returns reference on concrete GridView and inherit from this class. Then on each page your just have to implement that method.

Something like this:

public abstract class ParentPage
{
    public virtual void DisplayRecords()
    {
        var gridView = this.GetGridView();
        gridView.DataSource = this.GetAllData();
        gridView.DataBind();
    }

    protected abstract  DataTable GetAllData();

    protected string GetSortOrder()
    {
        if (this.sortOrder != GridSortOrder.Assending)
            return string.Format("{0} DESC", this.sortExpression)
        return this.sortExpression;
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        DisplayRecords();
    }

    protected void GridView1_SortCommand(object sender, GridSortCommandEventArgs e)
    {
        if (!e.Item.OwnerTableView.SortExpressions.ContainsExpression(e.SortExpression))
        {
            GridSortExpression sortExpr = new GridSortExpression();
            sortExpr.FieldName = e.SortExpression;
            sortExpr.SortOrder = GridSortOrder.Ascending;
            e.Item.OwnerTableView.SortExpressions.AddSortExpression(sortExpr);
        }
    }

    protected void GridView1_PageIndexChanged(object sender, GridPageChangedEventArgs e)
    {
        e.Item.OwnerTableView.PageIndex = e.NewPageIndex;
        DisplayRecords();
    }

    protected void GridView1_PageSizeChanged(object sender, GridPageSizeChangedEventArgs e)
    {
        e.Item.OwnerTableView.PageSize = e.NewPageSize;
        DisplayRecords();
    }
}

Page 1:**ttt.aspx**
public class **tttPage : BasePage 
{
    protected override GridView GetGridView()
    {
        //return GridView of this page 
        return GridView1;
    }

    protected override  DataTable GetAllData()
    {
        using (var context = new MyDataContext())
        {
            var data = c in context.ttt select c;
            return MyDataContext.LINQToDataTable(data);
        }
    }
}

Page 1:**bbb.aspx**
public class **bbbPage : BasePage
{
    protected override GridView GetGridView()
    {
        //return GridView of this page 
        return GridView1;
    }

    protected override  DataTable GetAllData()
    {
        using (var context = new MyDataContext())
        {
            var data = c in context.bbb select c;
            return MyDataContext.LINQToDataTable(data);
        }
    }
}

Or you can put you common logic inside base class with virtual methods where use event args for getting GridView like e.Item.OwnerTableView.

By making it virtual you will be able to override this logic in any page class

Something like this:

public abstract class ParentPage<TEntity>
{
    public virtual void DisplayRecords(GridView gridView)
    {
        gridView.DataSource = this.GetAllData();
        gridView.DataBind();
    }

    protected abstract  DataTable GetAllData();

    protected void Page_Load(object sender, EventArgs e)
    {
        DisplayRecords(e.Item.OwnerTableView);
    }

    protected void GridView_SortCommand(object sender, GridSortCommandEventArgs e)
    {
        DisplayRecords(e.Item.OwnerTableView);
    }

    protected void GridView_PageIndexChanged(object sender, GridPageChangedEventArgs e)
    {
        DisplayRecords(e.Item.OwnerTableView);
    }

    protected void GridView_PageSizeChanged(object sender, GridPageSizeChangedEventArgs e)
    {
        DisplayRecords(e.Item.OwnerTableView);
    }
}

public class **tttPage : ParentPage 
{
    protected override  DataTable GetAllData()
    {
        using (var context = new MyDataContext())
        {
            var data = c in context.ttt select c;
            return MyDataContext.LINQToDataTable(data);
        }
    }
}

public class **bbbPage : ParentPage 
{
    protected override  DataTable GetAllData()
    {
        using (var context = new MyDataContext())
        {
            var data = c in context.bbb select c;
            return MyDataContext.LINQToDataTable(data);
        }
    }
}

Also you can use generic parameter for getting values from db.

Answer 2

There are many principles that you generally apply when trying to refactor code. Currently you are trying to refactor your code as to not violate the DRY principle (DRY = don't repeat yourself).
But, some other principals might come in to play that you might want to consider. The single responsibility principle would suggest that each method does only one unambiguous thing.

As per your scenario, You need to generate whole GridView dynamically or runtime with custom columns and custom GridView configuration logic which will be more expensive than writing those events in each page.

Also all events must be tied up to 'GridView' to trigger properly. You can not separate those events to other files otherwise events will not fire.

You have another option of using ASP.Net user controls but again you need to write logic to manipulate GridView custom columns and custom GridView configuration logic. So again making it more expensive. So I won't recommend to do so. It's better off as to keep methods individually for each page.