Asp.Net ग्रिडव्यू

Question

में डेटािंग डेटा में मेरे पास दो संग्रहीत प्रक्रियाएं हैं जो संबंधित डेटा के दो सेट लौट रही हैं। डेटा इस तरह है। पहले प्रक्रिया की तरह इस

ISSUE_ID   ISSUETYPE   
------------------------------------- 
1   ISSUE 1 TYPE 
2   ISSUE 2 TYPE 
3   ISSUE 3 TYPE 
4   ISSUE 4 TYPE 

दूसरा प्रक्रिया रिटर्न इस ISSUE_ID के आधार पर की तरह डेटा

HEADER ID   HEADER NAME   ISSUE_ID  
----------------------------------------------------- 
1     HEADER 1 NAME    1 
2     HEADER 2 NAME    1 
3     HEADER 3 NAME    2 
4     HEADER 4 NAME    2 
5     HEADER 5 NAME    3 

बात कैसे मैं समूह इस ISSUE_ID के आधार पर कर सकते हैं और दोनों संग्रहीत का उपयोग कर gridview में समूहों में प्रदर्शित डेटा रिटर्न प्रक्रियाओं। मैंने बहुत सारे मंचों में गुमराह किया है और मैंने पाया कि विकल्प ग्रिडव्यू घोंसला था। क्या मैं इस नेस्टेड ग्रिडव्यू का उपयोग किए बिना इसे प्राप्त कर सकता हूं।

अंततः मैं इस तरह ग्रिडव्यू में प्रदर्शित करना चाहता हूं।

ISSUE 1 TYPE 
----------------------------- 
      HEADER 1 NAME     
      HEADER 2 NAME 
ISSUE 2 TYPE 
----------------------------- 
      HEADER 3 NAME     
      HEADER 4 NAME     
ISSUE 3 TYPE 
----------------------------- 
      HEADER 5 NAME     

अग्रिम में धन्यवाद लाखों .. इसे प्राप्त करने के लिए कुछ सुझावों की आवश्यकता है।

Answer 1

ASP.Net GridView

<asp:GridView ID="grdViewOrders" CssClass="serh-grid" runat="server" AutoGenerateColumns="False" TabIndex="1" Width="100%" CellPadding="4" ForeColor="Black" GridLines="Vertical" OnRowDataBound="grdViewOrders_RowDataBound" OnRowCommand="grdViewOrders_RowCommand" OnRowCreated="grdViewOrders_RowCreated" BackColor="White" BorderColor="#DEDFDE" BorderStyle="None" BorderWidth="1px"> 
    <Columns>  
     <asp:BoundField DataField="OrderID" HeaderText="OrderID" SortExpression="OrderID" />    
     <asp:BoundField DataField="ProductName" HeaderText="ProductName" SortExpression="ProductName" />    
     <asp:BoundField DataField="UnitPrice" HeaderText="UnitPrice" SortExpression="UnitPrice" />   
     <asp:BoundField DataField="Quantity" HeaderText="Quantity" SortExpression="Quantity" />   
     <asp:BoundField DataField="Discount" HeaderText="Discount" SortExpression="Discount" />   
     <asp:BoundField DataField="Amount" HeaderText="Amount" SortExpression="Amount" />      
    </Columns>  
    <FooterStyle BackColor="#CCCC99" />  
    <SelectedRowStyle CssClass="grid-sltrow" />  
    <HeaderStyle BackColor="#6B696B" Font-Bold="True" ForeColor="White" BorderStyle="Solid" BorderWidth="1px" BorderColor="Black" />   
</asp:GridView> 

नोट्स में समूह का एक उदाहरण:

• मुख्य तर्क है GridView के RowCreated और RowDataBound घटनाओं में।

• सभी पंक्तियों के माध्यम से पुनरावृत्ति जब मैं

  • ग्राहक आईडी (प्राथमिक इंडेक्स) में देखना और अन्य पंक्तियों की जाँच कर रहा हूँ।
  • एक चल GrandTotal (रों) एक चल उप-योग (रों)

• की

• रखते हुए ट्रैक के रखते हुए ट्रैक हर बिंदु पर प्राथमिक सूचकांक परिवर्तन करते हुए परिणाम-सेट के माध्यम से पुनरावृत्ति:
  • जोड़े उप-योग (रों) पंक्ति
  • रीसेट उप-योग (रों) अगले समूह के लिए तैयार

• ग्रिड व्यू में एक नई पंक्ति के रूप में प्रदर्शित शीर्षक।

GridView सहायक

GridViewHelper

का उपयोग करते हुए नीचे हम कुछ GridViewHelper नमूने देखेंगे। सबसे पहले हम ग्रिड दिखाते हैं जिसमें समूह और सारांश बनाए जाएंगे।नमूना डेटा में कुछ संशोधनों के साथ, करेंनॉर्थविंडडेटाबेस से आता है:

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    helper.RegisterSummary("ItemTotal", SummaryOperation.Sum); 
} 

पहले हम बनाते हैं:

हम केवल वादा किया 2 कोड की लाइनों की जरूरत है ItemTotal स्तंभ के लिए एक सारांश बनाने के लिए ग्रिडव्यूहेल्पर ग्रिड को स्थापित करता है जिसमें यह कन्स्ट्रक्टर में कार्य करेगा। फिर हम स्तंभ नाम और सारांश ऑपरेशन को निर्दिष्ट करने के सारांश को पंजीकृत करते हैं। परिणाम के नीचे है:

इस नमूने में एक नई लाइन सारांश प्रदर्शित करने के लिए जोड़ा गया है। एक और विकल्प एक नया निर्माण करने के बजाय सारांश प्रदर्शित करने के लिए पाद लेख पंक्ति का उपयोग करना है। जब ग्रिड में एक नई पंक्ति जोड़ दी जाती है, तो संक्षेप में कॉलम प्रदर्शित करने के लिए केवल आवश्यक कक्ष बनाए जाते हैं। पाद लेख का उपयोग करके, सभी कोशिकाएं बनाई जाती हैं। समूह सारांश के मामले में, सभी कोशिकाओं की पीढ़ी या केवल आवश्यक कोशिकाएं समूह विशेषता है।

अब हम एक समूह बनायेंगे। कोड नीचे दिखाया गया है:

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    helper.RegisterGroup("ShipRegion", true, true); 
    helper.ApplyGroupSort(); 
} 

रजिस्टर समूह विधि का पहला पैरामीटर कॉलम को परिभाषित करता है जिस पर समूह बनाया जाना चाहिए। एक समग्र समूह बनाना भी संभव है, जिसमें कॉलम की एक सरणी शामिल है। दूसरा पैरामीटर निर्दिष्ट करता है कि समूह स्वचालित है या नहीं। इस मामले में समूह शीर्षलेख के लिए स्वचालित रूप से एक नई पंक्ति बनाई जाएगी। तीसरा पैरामीटर निर्दिष्ट करता है कि समूह कॉलम छुपाया जाना चाहिए या नहीं। ApplyGroupSort विधि ग्रिड की क्रम अभिव्यक्ति को समूह कॉलम के रूप में सेट करती है, इस मामले में, शिपरियन। डेटा को डेटाबेस से ऑर्डर करने के अलावा, इसे ठीक से काम करने के लिए आवश्यक है।

ऊपर नमूने में स्तंभ ShipRegion छुपाए गए हैं:

चलो कुछ अधिक दिलचस्प बनाने, चलो बनाई समूह के लिए एक सारांश जोड़ते हैं। समूह में सारांश पंजीकृत करने के लिए हमें केवल एक और पंक्ति की आवश्यकता है:

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    helper.RegisterGroup("ShipRegion", true, true); 
    helper.RegisterSummary("ItemTotal", SummaryOperation.Sum, "ShipRegion"); 
    helper.ApplyGroupSort(); 
} 

इस बार, रजिस्टरसमरी विधि एक और पैरामीटर लेती है। पैरामीटर उस समूह का नाम निर्दिष्ट करता है जिस पर सारांश बनाया जाना चाहिए। समूह नाम स्वचालित रूप से समूह कॉलम नामों से उत्पन्न होता है। यदि समूह में केवल एक कॉलम है, तो समूह का नाम उस कॉलम का नाम होगा। यदि समूह में एक से अधिक कॉलम हैं, तो समूह का नाम समूह को लिखने वाले स्तंभों का क्रमबद्ध संयोजन होगा, जो प्लस साइन ("+"): "शिपरियन + शिपनाम" के साथ जुड़ गया है।

हम समूह के साथ ग्रिड और समूह के लिए एक सारांश नीचे देख सकते हैं:

यह नीचे के रूप में देखा, ग्रिड में एक से अधिक समूह बनाने के लिए, एक पदानुक्रमित समूह का अनुकरण संभव है:

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    helper.RegisterGroup("ShipRegion", true, true); 
    helper.RegisterGroup("ShipName", true, true); 
    helper.ApplyGroupSort(); 
} 

परिणाम:

एक से अधिक समूह होने पर विज़ुअलाइज़ेशन समझौता किया गया है।GridViewHelper में दृश्य या कार्यात्मक समायोजन के आसान कार्यान्वयन की अनुमति देने के लिए ईवेंट हैं। घटनाओं की सूची नीचे दी गई है:

• ग्रुपस्टार्ट: जब कोई नया समूह शुरू होता है, तो इसका मतलब है, जब समूह कॉलम में नए मान पाए जाते हैं।
• समूह अंत: समूह की अंतिम पंक्ति में होता है
• समूहहेडर: जब समूह के लिए स्वचालित हेडर पंक्ति जोड़ा जाता है तो होता है। यदि समूह स्वचालित नहीं है तो ईवेंट ट्रिगर नहीं होता है।
• समूहसमरी: समूह के लिए सारांश पंक्ति उत्पन्न होने पर होती है। यदि समूह स्वचालित नहीं है, तो ईवेंट ट्रिगर नहीं होता है, लेकिन समूह ट्रिगर हो जाएगा यदि समूह एक दमन समूह है (बाद में देखा जाएगा)।
• सामान्य सारांश: सामान्य सारांशों की गणना के बाद होता है। यदि सारांश स्वचालित है तो सारांश पंक्ति जोड़ने के बाद घटना होती है और सारांश मान पंक्ति में रखा जाना चाहिए।
• पाद लेखडेटाउंड: पाद लेख डेटाबेस में होता है। सौंदर्य प्रसाधन के बाद

  protected void Page_Load(object sender, EventArgs e) 
  { 
      GridViewHelper helper = new GridViewHelper(this.GridView1); 
      helper.RegisterGroup("ShipRegion", true, true); 
      helper.RegisterGroup("ShipName", true, true); 
      helper.GroupHeader += new GroupEvent(helper_GroupHeader); 
      helper.ApplyGroupSort(); 
  } 
  
  private void helper_GroupHeader(string groupName, object[] values, GridViewRow row) 
  { 
      if (groupName == "ShipRegion") 
      { 
       row.BackColor = Color.LightGray; 
       row.Cells[0].Text = "  " + row.Cells[0].Text; 
      } 
      else if (groupName == "ShipName") 
      { 
       row.BackColor = Color.FromArgb(236, 236, 236); 
       row.Cells[0].Text = "     " + row.Cells[0].Text; 
      } 
  } 
  

  ग्रिड:

  

  अधिक समूहीकरण विकल्प

कोड की कुछ लाइनों के साथ अधिक

हम ग्रिड के दृश्य पहलू सुधार कर सकते हैं

इसमें दो और हैं teresting नमूने। पहला एक समग्र समूह प्रस्तुत करता है। दूसरा एक दमन समूह को परिभाषित करता है, जिसमें एसक्यूएल ग्रुप बाय क्लॉज का वही व्यवहार होता है। दोहराने वाले मान दबाने वाले हैं, और अन्य कॉलम पर सारांश ऑपरेशन किया जाता है।

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    string[] cols = new string[2]; 
    cols[0] = "ShipRegion"; 
    cols[1] = "ShipName"; 
    helper.RegisterGroup(cols, true, true); 
    helper.ApplyGroupSort(); 
} 

हम समूह के लिए एक सारांश जोड़ सकते हैं:

हम नीचे कोड और समग्र समूह के लिए ग्रिड उपस्थिति देख सकते हैं।

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    string[] cols = new string[2]; 
    cols[0] = "ShipRegion"; 
    cols[1] = "ShipName"; 
    helper.RegisterGroup(cols, true, true); 
    helper.RegisterSummary("ItemTotal", SummaryOperation.Avg, "ShipRegion+ShipName"); 
    helper.GroupSummary += new GroupEvent(helper_GroupSummary); 
    helper.ApplyGroupSort(); 
} 

private void helper_GroupSummary(string groupName, object[] values, GridViewRow row) 
{ 
    row.Cells[0].HorizontalAlign = HorizontalAlign.Right; 
    row.Cells[0].Text = "Average"; 
} 

पिछले नमूना एक दबाने समूह बन जाएगा: इस बार हम एक औसत आपरेशन को परिभाषित करने और एक लेबल जोड़ देगा आपरेशन से संकेत मिलता है। यह उल्लेख करना महत्वपूर्ण है कि यदि एक दबाने वाले समूह को परिभाषित किया गया है, तो कोई अन्य समूह नहीं बनाया जा सकता है। इसी तरह, यदि पहले से ही एक समूह परिभाषित किया गया है, तो हम एक दबाने वाले समूह नहीं बना सकते हैं और यदि हम इसे आज़माते हैं तो अपवाद उठाया जाएगा।

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    helper.SetSuppressGroup("ShipName"); 
    helper.RegisterSummary("Quantity", SummaryOperation.Sum, "ShipName"); 
    helper.RegisterSummary("ItemTotal", SummaryOperation.Sum, "ShipName"); 
    helper.ApplyGroupSort(); 
} 

कोई मान कॉलम कि एक सारांश आपरेशन परिभाषित नहीं है के लिए प्रदर्शित होता है:

हम नीचे कोड और दबाने समूह के लिए ग्रिड उपस्थिति देख सकते हैं। यह समझ में आता है क्योंकि GridViewHelper को पता नहीं है कि समूह पंक्तियों में पाए गए मानों को एक अद्वितीय मूल्य में सारांशित करने के लिए कैसे आगे बढ़ना है।यह कुछ ज्ञात संदेश को याद दिलाता है:

"कॉलम 'कॉलम_नाम' चयनित सूची में अमान्य है क्योंकि यह या तो कुल कार्य या ग्रुप बाय क्लॉज में निहित नहीं है।"

यह कॉलम कि एक सारांश आपरेशन की जरूरत नहीं है प्रदर्शित करने के लिए कोई मतलब नहीं है, और उन्हें छिपाने के लिए हम एक विधि कॉल करने की जरूरत है:

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    helper.SetSuppressGroup(rdBtnLstGroup.SelectedValue); 
    helper.RegisterSummary("Quantity", SummaryOperation.Sum, "ShipName"); 
    helper.RegisterSummary("ItemTotal", SummaryOperation.Sum, "ShipName"); 
    helper.SetInvisibleColumnsWithoutGroupSummary(); 
    helper.ApplyGroupSort(); 
} 

मुझे पता है, यह एक बड़ा बड़ा नाम है! जिसके परिणामस्वरूप ग्रिड के नीचे देखा जा सकता है:

सारांश आपरेशन

GridViewHelper है तीन में निर्मित सारांश संचालन: योग, औसत और पंक्ति संख्या। कस्टम सारांश संचालन को परिभाषित करने की संभावना बहुत उपयोगी सुविधा है। इसे प्राप्त करने के लिए हमें ग्रिड व्यूहेल्पर को दो विधियां प्रदान करने की आवश्यकता है। ग्रिड (या समूह) में मिली प्रत्येक पंक्ति के लिए एक विधि कहा जाएगा और दूसरे को सारांश ऑपरेशन के परिणाम को पुनर्प्राप्त करने के लिए बुलाया जाएगा। नीचे हमारे पास एक कस्टम सारांश ऑपरेशन का नमूना है। अर्ध-डमी ऑपरेशन न्यूनतम मूल्य वापस लौटाएगा:

private List<int> mQuantities = new List<int>(); 

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    helper.RegisterSummary("Quantity", SaveQuantity, GetMinQuantity); 
} 

private void SaveQuantity(string column, string group, object value) 
{ 
    mQuantities.Add(Convert.ToInt32(value)); 
} 

private object GetMinQuantity(string column, string group) 
{ 
    int[] qArray = new int[mQuantities.Count]; 
    mQuantities.CopyTo(qArray); 
    Array.Sort(qArray); 
    return qArray[0]; 
} 

उपरोक्त कोड में हम आवश्यक विधियों के हस्ताक्षर देख सकते हैं। दोनों सारांशित समूह और कॉलम नाम प्राप्त करते हैं। यदि सारांश किसी समूह के सापेक्ष नहीं है, तो समूह पैरामीटर शून्य होगा। ग्रिड में मिली प्रत्येक पंक्ति के लिए बुलाया जाने वाला तरीका, वर्तमान पंक्ति में कॉलम का मान भी प्राप्त करता है।

जिसके परिणामस्वरूप ग्रिड के नीचे देखा जा सकता है:

सीमाएं

एक नमूने में हमने कहा है कि हम एक पदानुक्रमित समूह अनुकरण कर सकते हैं। यद्यपि ग्रिड एक पदानुक्रमित समूह प्रस्तुत करना प्रतीत होता है, वास्तविक कार्यान्वयन पदानुक्रमित नहीं है। कोई समूह या उपसमूह नहीं है। केवल अनुक्रमिक रूप से पंजीकृत समूह हैं। अगर हमें किसी आंतरिक समूह के लिए सारांश बनाने की आवश्यकता है तो यह एक समस्या बन जाती है। नीचे हम देख सकते हैं कि इस स्थिति में होता है:

protected void Page_Load(object sender, EventArgs e) 
{ 
    GridViewHelper helper = new GridViewHelper(this.GridView1); 
    helper.RegisterGroup("ShipRegion", true, true); 
    helper.RegisterGroup("ShipName", true, true); 
    helper.RegisterSummary("ItemTotal", SummaryOperation.Sum, "ShipName"); 
    helper.RegisterSummary("ItemTotal", SummaryOperation.Sum); 
    helper.GroupSummary += new GroupEvent(helper_Bug); 
    helper.ApplyGroupSort(); 
} 

private void helper_Bug(string groupName, object[] values, GridViewRow row) 
{ 
    if (groupName == null) return; 

    row.BackColor = Color.Bisque; 
    row.Cells[0].HorizontalAlign = HorizontalAlign.Center; 
    row.Cells[0].Text = "[ Summary for " + groupName + " " + values[0] + " ]"; 
} 

हम देख सकते हैं, सारांश बाहरी समूह के हेडर के बाद बनाई गई है। यह तब होता है क्योंकि घटना अनुक्रम है:

Group1_Start 
Group1_End 
Group2_Start 
Group2_End 

एक पदानुक्रमित समूह के लिए

, घटना अनुक्रम होना चाहिए:

Group1_Start 
Group2_Start 
Group2_End 
Group1_End 

कार्यान्वयन

GridViewHelper एक के बजाय एक स्टैंडअलोन वर्ग के रूप में लागू किया गया था विरासत वर्ग यह किसी भी ग्रिड व्यू के साथ ग्रिडव्यूहेल्पर का उपयोग करना संभव बनाता है, और डेवलपर को विशिष्ट ग्रिड व्यू का वारिस करने के लिए मजबूर नहीं करता है, जो क्लास डिज़ाइन को प्रभावित कर सकता है। समाधान में एक और चार वर्ग हैं: ग्रिड व्यूसमरी, ग्रिड व्यू ग्रुप, ग्रिड व्यूसमरीलिस्ट और ग्रिड व्यू ग्रुपलिस्ट। स्ट्रिंग इंडेक्सर द्वारा एक्सेस की अनुमति देने के लिए "सूची" कक्षाएं बनाई गई थीं: सहायक। सामान्य सारांश ["आइटमटॉट"]। मान।

जब GridViewHelper बनाया जाता है, लक्ष्य GridView के लिए एक संदर्भ सहेजा जाता है, और RowDataBound घटना विधि कि कड़ी मेहनत करता है के लिए बाध्य है:

public GridViewHelper(GridView grd, bool useFooterForGeneralSummaries, SortDirection groupSortDirection) 
{ 
    this.mGrid = grd; 
    this.useFooter = useFooterForGeneralSummaries; 
    this.groupSortDir = groupSortDirection; 
    this.mGeneralSummaries = new GridViewSummaryList(); 
    this.mGroups = new GridViewGroupList(); 
    this.mGrid.RowDataBound += new GridViewRowEventHandler(RowDataBoundHandler); 
} 

कुछ तरीकों GridViewHelper द्वारा आंतरिक रूप से उपयोग परिभाषित किया गया सार्वजनिक क्योंकि वे कुछ अनुकूल सुविधाएं प्रदान करते हैं जिन्हें कुछ अनुकूलन के लिए आवश्यक हो सकता है। कुछ अन्य विकल्प हैं जो नमूने में नहीं दिखाए गए थे लेकिन इसे विजुअल स्टूडियो इंटेलिजेंस के साथ आसानी से सत्यापित किया जा सकता है।

ज्ञात मुद्दे

प्रदर्शन अत्यधिक मुक्केबाजी और मूल्य प्रकार के unboxing साथ समझौता किया जा सकता है। इसे हल करने के लिए हम जेनेरिक के साथ अंतर्निहित सारांश संचालन को कार्यान्वित कर सकते हैं, लेकिन यह उतना आसान नहीं है जितना हम चाहते हैं, जैसा गणना के लिए जेनेरिक का उपयोग करने पर देखा जा सकता है। एक और संभावना: जेनेरिक के साथ ऑपरेटर ओवरलोडिंग। वास्तविक जीवन में यह एक लाख पंक्तियों के अलावा, यदि हजारों उपयोगकर्ता समूह समेकित और सारांशित करते हैं तो आवेदन को प्रभावित नहीं करेंगे।

ऑनलाइन नमूना GridView EnableViewState को गलत रखता है। यह आवश्यक है क्योंकि जब EnableViewState सत्य है, तो पृष्ठ पोस्टबैक में है, तो GridView को ViewState से पुनर्निर्मित किया जाएगा, और RowDataBound ईवेंट को ट्रिगर नहीं करेगा। हम ASP.Net 2.0 में ViewState को सुरक्षित रूप से अक्षम कर सकते हैं क्योंकि कंट्रोलस्टेट अभी भी सहेजा जाएगा।

Answer 2

यह सवाल का जवाब नहीं देता है, यहां मैं प्रश्न में से किसी एक के बजाय एक असामान्य परिणाम सेट का उपयोग कर रहा हूं, हालांकि डेटा को अपनाना मुख्य मुद्दा नहीं होना चाहिए।

यहाँ है कि कैसे मैं मेरा समूहीकरण मिलता है, पहले मैं समूहों मिल ही डेटा पंक्ति देते हैं, और यह भी मैं प्रस्तुत करना प्रतिनिधि का अपहरण:

readonly Dictionary<Control, string> _groupNames = new Dictionary<Control, string>(); 
private Group _lastGroup; 
protected void gv_RowDataBound(object sender, GridViewRowEventArgs e) 
{ 
    if (e.Row.RowType == DataControlRowType.DataRow) 
    { 
     var obj = (Obj)e.Row.DataItem; 
     if (obj.Group != _lastGroup) 
     { 
      e.Row.SetRenderMethodDelegate(RenderGridViewRowWithHeader); 
      _lastGroup = obj.Group; 

      // Cache group description for this row, note that you might 
      // like to implement this differently if you have your data normalized. 
      _groupNames[e.Row] = obj.Group.Description;     } 
     } 
    } 
} 

तो विधि प्रस्तुत करना में

:

private void RenderGridViewRowWithHeader(HtmlTextWriter output, Control container) 
{ 
    // Render group header 
    var row = new TableRow { CssClass = "groupingCssClass" }; 
    row.Cells.Add(new TableCell()); 
    row.Cells.Add(new TableCell 
    { 
     ColumnSpan = ((GridViewRow)container).Cells.Count - 1, 
     Text = _groupNames[container] 
    }); 
    row.RenderControl(output); 

    // Render row 
    container.SetRenderMethodDelegate(null); // avoid recursive call 
    container.RenderControl(output); 
} 

मुझे पता है कि यह एक हैक है, लेकिन जब आप विवरण प्राप्त करते हैं तो एएसपी.नेट इस बारे में सब कुछ है। यह समाधान नियंत्रण स्थिति के साथ काफी अनुकूल है, रनटाइम पर ग्रिड में पंक्तियों को जोड़ने से एस्ट्रेंज व्यवहार हो सकता है।