Jak delegować widok siatki telerik, aby uzyskać wspólne metody wywoływania ze strony nadrzędnej z każdej strony podrzędnej?

Question

Używam Telerik Gridview do wyświetlania listy rekordów i mam więcej niż 10 stron, w którym używam tego GridView z tego następujący kod wspólne imprezy kopia wklejony (z niewielkimi zmianami) na wszystkich tych stronach:

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() 
} 

to moja jedna strona, która dziedziczy z następującej strony:

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() 
     } 

Więc to jest możliwe, że mogę umieścić wszystkie te wydarzenia w tym ParentPage strony i po prostu zadzwonić z każdego dziecka Pag e zamiast zanieczyszczać każdą moją stronę tymi wydarzeniami?

Uwaga: W niektórych z moich stron tej DisplayRecords metod może zawiera kilka parametrów, ale reszta wszystkie zdarzenia są tak powszechne.

Answer 1

Możliwe, że możesz umieścić wspólną logikę w klasie abstrakcyjnej za pomocą metody (lub właściwości), która zwraca referencję na temat betonu GridView i dziedziczy z tej klasy. Następnie na każdej stronie wystarczy wdrożyć tę metodę.

coś takiego:

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); 
     } 
    } 
} 

Albo można umieścić Cię wspólną logikę wewnątrz klasy podstawowej z metod wirtualnych gdzie args wykorzystanie zdarzeń do uzyskania GridView jak e.Item.OwnerTableView.

Poprzez to wirtualny będzie można zastąpić tę logikę w każdej klasie widoku

coś takiego:

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); 
     } 
    } 
} 

Również można użyć parametru rodzajowego do uzyskania wartości z db.

Answer 2

Istnieje wiele zasad, które generalnie mają zastosowanie podczas próby kodowania kodu. Obecnie próbujesz zmienić kod, aby nie naruszać zasady DRY (DRY = nie powtarzaj się).
Ale niektórzy inni zleceniodawcy mogą przyjść do gry, co warto wziąć pod uwagę. single responsibility principle sugeruje, że każda metoda ma tylko jedną rzecz jednoznaczną.

Zgodnie ze scenariuszem, należy wygenerować cały dynamiczny lub wykonawczy cały GridView z niestandardowymi kolumnami i niestandardową logiką konfiguracji GridView, która będzie droższa niż zapisywanie tych zdarzeń na każdej stronie.

Również wszystkie zdarzenia muszą być powiązane z "GridView", aby prawidłowo uruchomić. Nie można oddzielić tych zdarzeń od innych plików, w przeciwnym razie zdarzenia nie zostaną uruchomione.

Masz inną opcję użycia kontrolek użytkownika ASP.Net, ale znowu musisz napisać logikę, aby manipulować niestandardowymi kolumnami GridView i niestandardową logiką konfiguracji GridView. Więc znowu czyni to droższym. Nie polecam tego robić. Lepiej jest zachować metody indywidualnie dla każdej strony.