Ripetitori annidati in ASP.NET

Ho una class che contiene dati gerarchici. Voglio presentare questi dati nella mia webapp ASP.net usando ripetitori nidificati. Come faccio a fare questo? Ho sempre fatto solo un livello di nidificazione, come posso dire cinque livelli?

Ogni articolo può avere zero o molti sottovoci. Fondamentalmente sto indentando ogni singolo sottotitoli usando roba di css. Non voglio usare il controllo treeview, voglio attenermi strettamente a un ripetitore.

Aggiornare:
I miei dati provengono da un database. Ho un object datatable con alcune proprietà di base.

Item { ID, Name, Description, ... } 

Poi ho un tavolo da molti a molti con:

 Parent { ParentID, ChildID } 

Sto iterando attraverso ogni object e mostrando i suoi figli; e i figli dei suoi figli. Presumo che questo sarebbe meglio realizzato con ripetitori annidati, ma potrei sbagliarmi.

    È sempre più pulito trattare l’origine dati piuttosto che scherzare con ItemDataBound, ma questo è ancora più vero quando si annidano i ripetitori:

          <%#SomeExtractingMethodLikeEval()%>      

    L’origine dati interna potrebbe anche essere una proprietà valutata o una chiamata a un metodo che restituisce l’enumerazione desiderata. Basta essere consapevoli che sarà chiamato con un object. Preferisco scrivere la versione specifica e quindi sovraccaricare:

     protected IEnumerable GetNames(Family fam) { foreach(Person p in fam.Members) yield return p.FirstName + " " + p.Surname; } protected IEnumerable GetNames(object famObj) { return GetNames((Family)famObj); } 

    Una cosa di cui essere consapevoli è che se si vuole ottenere l’object corrente nel ripetitore genitore di quello che si deve ottenere con:

     ((RepeaterItem)Container.Parent.Parent).DataItem 

    Ho trovato che il modo più semplice per eseguire ripetitori annidati senza preoccuparsi degli eventi di associazione dati è semplicemente impostare DataSource usando la syntax <%# %> .

    Per esempio:

       Name: <%# Eval("DeptName") %> Employees:  <%# Eval("Name") %> ,    

    Questo presume che la tua class Departments abbia una proprietà Employees, ad esempio:

     public class Department { public string DeptName {get; set;} public IEnumerable Employees {get; set;} } public class Employee { public string Name {get; set;} } 

    Se il tuo object ripetitore esterno non ha una proprietà corrispondente all’object ripetitore interno, puoi ancora usare questo trucco, aggiungendo un metodo nel tuo code-behind che esegue il calcolo. Quindi il tuo ripetitore interiore potrebbe diventare:

      

    e quindi GetEmployees potrebbe sembrare qualcosa di simile:

     protected IEnumerable GetEmployees(object item) { var dept = (Department) item; // then do whatever is necessary to get the employees from dept return employees; } 

    È ansible nidificare ripetitori senza problemi. Più di 2 livelli di profondità diventano cattivi però. Ecco come:

    Il codice HTML assomiglia a questo:

               

    Il codebehind si presenta così:

      protected void r1_ItemDataBound(object sender, RepeaterItemEventArgs e) { Repeater r2 = (Repeater)e.Item.FindControl("r2"); r2.DataSource = yourDataSourceHere; // you'll have to query for appropriate data r2.DataBind(); } protected void r2_ItemDataBound(object sender, RepeaterItemEventArgs e) { // do the same thing here for the 3rd nested repeater if you have a third, and so on } 
           R1.ItemDataBound += (s, e) => { var r2 = e.Item.FindControl("R2") as Repeater; r2.DataSource = something; r2.DataBind(); }; 

    Tieni presente che FindControl non è ricorsivo, ma otterrà solo i bambini.