Sortieren einer DataTable nach mehreren Kriterien

    • C#

    Es gibt 1 Antwort in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

      Sortieren einer DataTable nach mehreren Kriterien

      Hi Leute,
      die Aufgabe bestand darin, bei mehreren sehr ähnlichen Forms mit DGVs die Daten nach mehreren Kriterien zu sortieren.
      Es genügen hier einfache DataTables mit String-Spalten, da die Daten lediglich anzuzeigen waren.
      Die Formatierung der Daten wird gleich bei der Befüllung vorgenommen.
      Ich war auf der Suche nach einem einfachen Code, der für diese Belange ausreichte.
      Mit Anleihen bei Microsoft:
      msdn.microsoft.com/de-de/libra…ang=csharp#code-snippet-2
      docs.microsoft.com/de-de/dotne…orms-datagridview-control
      kam dann dieser Code heraus (Form mit einem DataGridView):
      Spoiler anzeigen

      C#-Quellcode

      1. using System;
      2. using System.Data;
      3. using System.Windows.Forms;
      4. namespace WindowsFormsApplication1
      5. {
      6. public partial class Form1 : Form
      7. {
      8. private DataTable Table;
      9. public Form1()
      10. {
      11. this.InitializeComponent();
      12. // damit C&P funktioniert
      13. this.dataGridView1.ColumnHeaderMouseClick += new System.Windows.Forms.DataGridViewCellMouseEventHandler(this.dataGridView1_ColumnHeaderMouseClick);
      14. this.Table = new DataTable("Sort");
      15. // Add four columns
      16. this.Table.Columns.Add("Col 1");
      17. this.Table.Columns.Add("Col 2");
      18. this.Table.Columns.Add("Col 3");
      19. this.Table.Columns.Add("Col 4");
      20. // Add data
      21. this.Table.Rows.Add("²²", "mm", "##", "++");
      22. this.Table.Rows.Add("²²", "mm", "##", "--");
      23. this.Table.Rows.Add("²²", "mm", "@@", "++");
      24. this.Table.Rows.Add("²²", "mm", "@@", "--");
      25. this.Table.Rows.Add("²²", "xx", "##", "++");
      26. this.Table.Rows.Add("²²", "xx", "##", "--");
      27. this.Table.Rows.Add("²²", "xx", "@@", "++");
      28. this.Table.Rows.Add("²²", "xx", "@@", "--");
      29. this.Table.Rows.Add("oo", "mm", "##", "++");
      30. this.Table.Rows.Add("oo", "mm", "##", "--");
      31. this.Table.Rows.Add("oo", "mm", "@@", "++");
      32. this.Table.Rows.Add("oo", "mm", "@@", "--");
      33. this.Table.Rows.Add("oo", "xx", "##", "++");
      34. this.Table.Rows.Add("oo", "xx", "##", "--");
      35. this.Table.Rows.Add("oo", "xx", "@@", "++");
      36. this.Table.Rows.Add("oo", "xx", "@@", "--");
      38. this.Table.AcceptChanges();
      39. this.dataGridView1.DataSource = this.Table;
      40. // Spaltennamen explizit überschreiben
      41. this.dataGridView1.Columns[0].HeaderText = "Spalte 1";
      42. this.dataGridView1.Columns[1].HeaderText = "Spalte 2";
      43. this.dataGridView1.Columns[2].HeaderText = "Spalte 3";
      44. this.dataGridView1.Columns[3].HeaderText = "Spalte 4";
      45. }
      46. private void dataGridView1_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
      47. {
      48. // Primär-Spalte
      49. int index = e.ColumnIndex;
      50. // Array, in dem die Reihenfolge der nachgeordneten Spalten festgelegt wird
      51. int[] sortOrder;
      52. switch (index)
      53. {
      54. case 0: // => default
      55. sortOrder = new int[] { 0, 1, 2, 3 };
      56. break;
      57. case 1:
      58. sortOrder = new int[] { 1, 2, 3, 0 };
      59. break;
      60. case 2:
      61. sortOrder = new int[] { 2, 3, 0, 1 };
      62. break;
      63. case 3:
      64. sortOrder = new int[] { 3, 0, 1, 2 };
      65. break;
      66. default:
      67. // Weitere Spalten: keine weiteren Kriterien
      68. sortOrder = new int[] { index };
      69. break;
      70. }
      72. // der erste Wert muss die selektierte Spalte sein
      73. System.Diagnostics.Debug.Assert(sortOrder != null && index == sortOrder[0], "Array falsch befüllt");
      74. Form1.OrderTable(this.dataGridView1, sortOrder);
      75. }
      76. /// <summary>
      77. /// Sortierung der DataTable eines DataGridView
      78. /// nach mehereren Kriterien
      79. /// </summary>
      80. /// <param name="dgv">das DataGridView</param>
      81. /// <param name="sortOrder">Reihenfolge der Kriterien</param>
      82. private static void OrderTable(DataGridView dgv, int[] sortOrder)
      83. {
      84. DataTable table = dgv.DataSource as DataTable;
      85. string order = Form1.GetOrderString(dgv, sortOrder[0]); // "ASC", "DESC"
      86. string sort = Form1.GetSortString(table, sortOrder, order); // "Color1 ASC, State ASC"
      87. Form1.Sort(table, sort);
      88. }
      89. /// <summary>
      90. /// Generieren des eigentlichen Sort-Strings
      91. /// </summary>
      92. /// <param name="table">Tabelle mit den Spaltennamen</param>
      93. /// <param name="sortOrder">Sortierabhängigkeit der Spalten untereinander</param>
      94. /// <param name="order">Sortierrichtung</param>
      95. /// <returns>der Sort-String</returns>
      96. private static string GetSortString(DataTable table, int[] sortOrder, string order)
      97. {
      98. // Spaltennamen in der Tabelle
      99. string sortString = string.Empty;
      100. // Länge begrenzen
      101. for (int i = 0; i < Math.Min(sortOrder.Length, table.Columns.Count); i++)
      102. {
      103. int elem = sortOrder[i];
      104. string name = table.Columns[elem].ColumnName;
      105. if (i < sortOrder.Length - 1)
      106. {
      107. sortString += string.Format("{0} {1}, ", name, order);
      108. }
      109. else
      110. {
      111. // der letzte String anders
      112. sortString += string.Format("{0} {1}", name, order);
      113. }
      114. }
      115. return sortString;
      116. }
      117. /// <summary>
      118. /// Generierung des Order-Strings anhand des DGV und des Spaltenindex'
      119. /// </summary>
      120. /// <param name="dgv">das zu sortierende DGV</param>
      121. /// <param name="index">der Spaltenindex</param>
      122. /// <returns>der Order-String</returns>
      123. private static string GetOrderString(DataGridView dgv, int index)
      124. {
      125. DataGridViewColumn oldColumn = dgv.SortedColumn;
      126. DataGridViewColumn newColumn = dgv.Columns[index];
      127. if (oldColumn == newColumn && dgv.SortOrder == SortOrder.Ascending)
      128. {
      129. // Sort the same column again, reversing the SortOrder.
      130. return "DESC";
      131. }
      132. // If oldColumn is null, then the DataGridView is not currently sorted.
      133. // Sort a new column
      134. return "ASC";
      135. }
      136. /// <summary>
      137. /// Sortieren einer DataTable
      138. /// </summary>
      139. /// <param name="table">die zu sortierende DataTable</param>
      140. /// <param name="sort">der Sort-String</param>
      141. private static void Sort(DataTable table, string sort)
      142. {
      143. // Create DataView
      144. DataView view = new DataView(table);
      145. // Sort DataView
      146. view.Sort = sort;
      147. // separate Instanz erforderlich, sonst ist die mit Clear() Tabelle weg
      148. DataTable table2 = view.ToTable();
      149. // Merge the sorted Table
      150. table.Clear();
      151. table.Merge(table2);
      152. table.AcceptChanges();
      153. }
      154. }
      155. }
      Zum Sortieren wird das DataGridView übergeben, um die letzte Sortierung auslesen zu können, so dass sich das Sortrieren wie das übliche Sortieren verhält.
      Die zu sortierende DataTable wird als DataSource aus dem DataGridView ausgelesen.
      --------------
      Die Testdaten sind so angelegt, dass immer die jeweils nächste Spalte die nächste Ordnung darstellt (0 - 1 - 2 - 3 - 0 - ...):
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „RodFromGermany“ () aus folgendem Grund: Daten für zyklische Tauschung eingefügt

      Guck - ich mach sowas ähnliches über die BindingSource:

      VB.NET-Quellcode

      1. Imports System.Windows.Forms
      2. Imports System.ComponentModel
      4. Public Class frmHierarchicalSortTester
      6. Private WithEvents _Hierarchical As BindingSource
      8. Public Sub New()
      9. InitializeComponent()
      10. DataSet1.GenerateData()
      11. _Hierarchical = _Bs
      12. End Sub
      14. Private _RecentSorts() As String
      16. Private Sub Hirarchical_ListChanged(sender As Object, e As ListChangedEventArgs) Handles _Hierarchical.ListChanged
      17. If e.ListChangedType <> ListChangedType.Reset Then Return
      18. Dim dv = DirectCast(_Bs.List, DataView)
      19. Dim sort = dv.Sort ' Beispiel: dv.Sort = "[Zweiteiliger ColumnName] DESC"
      20. If sort = "" Then Return
      21. If _RecentSorts Is Nothing Then _RecentSorts = {sort, sort}
      22. Dim sortCol = sort.Split("]"c)(0) ' erste Sortierspalte ohne 'DESC'
      23. If sortCol <> _RecentSorts(0).Split("]"c)(0) Then _RecentSorts(1) = _RecentSorts(0) ' Recentliste ggfs. aufrücken
      24. _RecentSorts(0) = sort.Split(","c)(0) ' erste Sortierung - kann 'DESC' enthalten
      25. Dim DoubletteFree = _RecentSorts.Where(Function(s, i) i = 0 OrElse s.Split("]"c)(0) <> sortCol)
      26. sort = String.Join(", ", DoubletteFree)
      27. If dv.Sort <> sort Then dv.Sort = sort ' Beispiel neu: dv.Sort = "[Zweiteiliger ColumnName] DESC, [VorherigeColumn]"
      28. Diagnostics.Debug.Print(dv.Sort)
      29. End Sub
      31. End Class
      Ich habe mich aber auf maximal 2-stufige Sortierung festgelegt, noch mehr Stufen hab ich nie benötigt bzw. waren sogar im GUI ungünstig.
      Kann man aber sicher einfach erweitern.
      Die Funktionalität ist: Wenn man auf einen SpaltenHeader klickst, dann sortiert das DGV ja. Wenn man dann auf einen anderen klickst, dann sortiert es den, und übernimmt die vorherige Primär-Sortierung als sekundäre.
      War ziemliches Gefummel, weil man klickst ja auch denselben Header mehrmals, um dessen Sortierung umzudrehen - sowas soll die Sekundär-Sortierung ja beibehalten.
      Oder wenn mans mal auf 3 Spalten erweitert können Sort-Order-Dubletten entstehen, wenn man zw. 2 Spalten mehrmals hin-her - klickst.

      Ich verwende das übrigens für einen sehr interessanten m:n - View. Der kommt mit nur einem DGV aus, und ist quasi Umschaltbar von m->n zu n->m - naja so in Kürze schwer zu erklären.
      Ah - hier kann mans angugge: Dgv-Extensions

      Aber hier inne Anwendung verfolgt man die Korrektheit der Sort-Strings am einfachsten inne Debug-Ausgabe.
      An meinen Daten sieht mans zwar auch, aber da muss man genau gucken, ums zu erkennen.
      Dateien

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Facebook
    Telefonspende