DropDownList sortieren? - C #, ASP.NET

Eine C # -Lösung für .NET 3.5 (benötigt System.Linq und System.Web.UI): 

    public static void ReorderAlphabetized(this DropDownList ddl)
    {
        List<ListItem> listCopy = new List<ListItem>();
        foreach (ListItem item in ddl.Items)
            listCopy.Add(item);
        ddl.Items.Clear();
        foreach (ListItem item in listCopy.OrderBy(item => item.Text))
            ddl.Items.Add(item);
    }

Rufen Sie es an, nachdem Sie Ihre Dropdown-Liste gebunden haben, z. OnPreRender:

    protected override void OnPreRender(EventArgs e)
    {
        base.OnPreRender(e);
        ddlMyDropDown.ReorderAlphabetized();
    }

Bewahren Sie es zur einfachen Wiederverwendung in Ihrer Utility-Bibliothek auf.

Vorausgesetzt, Sie verwenden die neueste Version von .NET Framework, wird dies funktionieren 

List<string> items = GetItemsFromSomewhere();
items.Sort((x, y) => string.Compare(x, y));
DropDownListId.DataSource = items;
DropDownListId.DataBind();

DropDownList nimmt jedes IEnumerable als DataSource an. 

Sortieren Sie es einfach mit LINQ.

Normalerweise lade ich eine DropDownList mit Werten aus einer Datenbanktabelle. Daher ist es am einfachsten, die Ergebnisse mit der ORDER BY-Klausel Ihrer SELECT-Anweisung wie gewünscht zu sortieren. Anschließend werden die Ergebnisse einfach durchlaufen und in der DropDownList abgelegt.

Schauen Sie sich den diesen Artikel von CodeProject an, der den Inhalt einer Dropdown-Liste neu anordnet. Bei der Datenbindung müssen Sie den Sortierer ausführen, nachdem die Daten an die Liste gebunden sind.

Eine andere Option besteht darin, die ListItems in ein Array zu legen und zu sortieren. 

        int i = 0;
        string[] array = new string[items.Count];

        foreach (ListItem li in dropdownlist.items)
        {
            array[i] = li.ToString();
            i++;

        }

        Array.Sort(array);

        dropdownlist.DataSource = array;
        dropdownlist.DataBind();

Es wird empfohlen, die Daten vor dem Datenbinden an DropDownList zu sortieren. Falls dies nicht möglich ist, sortieren Sie die Elemente in DropDownList.

Zuerst benötigen Sie eine Vergleichsklasse

Public Class ListItemComparer
    Implements IComparer(Of ListItem)

    Public Function Compare(ByVal x As ListItem, ByVal y As ListItem) As Integer _
        Implements IComparer(Of ListItem).Compare

        Dim c As New CaseInsensitiveComparer
        Return c.Compare(x.Text, y.Text)
    End Function
End Class

Dann benötigen Sie eine Methode, die diesen Comparer zum Sortieren der DropDownList verwendet

Public Shared Sub SortDropDown(ByVal cbo As DropDownList)
    Dim lstListItems As New List(Of ListItem)
    For Each li As ListItem In cbo.Items
        lstListItems.Add(li)
    Next
    lstListItems.Sort(New ListItemComparer)
    cbo.Items.Clear()
    cbo.Items.AddRange(lstListItems.ToArray)
End Sub

Rufen Sie schließlich diese Funktion mit Ihrer DropDownList auf (nach dem Datenaustausch).

SortDropDown(cboMyDropDown)

P.S. Tut mir leid, aber meine Sprachauswahl ist VB. Sie können http://converter.telerik.com/ verwenden, um den Code von VB in C # zu konvertieren.

Versuch es

------- Store-Prozedur ----- (SQL)

USE [Your Database]
GO


CRATE PROC [dbo].[GetAllDataByID]

@ID int


AS
BEGIN
        SELECT * FROM Your_Table
        WHERE [email protected]
        ORDER BY Your_ColumnName 
END

---------- Default.aspx ---------

<asp:DropDownList ID="ddlYourTable" runat="server"></asp:DropDownList>

--------- Default.aspx.cs -------

protected void Page_Load(object sender, EventArgs e)

{

      if (!IsPostBack)
            {
                List<YourTable> table= new List<YourTable>();

                YourtableRepository tableRepo = new YourtableRepository();

                int conuntryInfoID=1;

                table= tableRepo.GetAllDataByID(ID);

                ddlYourTable.DataSource = stateInfo;
                ddlYourTable.DataTextField = "Your_ColumnName";
                ddlYourTable.DataValueField = "ID";
                ddlYourTable.DataBind();

            }
        }

------- LINQ-Hilfsklasse ----

public class TableRepository

   {

        string connstr;

        public TableRepository() 
        {
            connstr = Settings.Default.YourTableConnectionString.ToString();
        }

        public List<YourTable> GetAllDataByID(int ID)
        {
            List<YourTable> table= new List<YourTable>();
            using (YourTableDBDataContext dc = new YourTableDBDataContext ())
            {
                table= dc.GetAllDataByID(ID).ToList();
            }
            return table;
        }
    }

Welche Art von Objekt verwenden Sie für das Datenbinden? Normalerweise verwende ich Collection <T>, List <T> oder Queue <T> (abhängig von den Umständen). Diese sind relativ einfach mit einem benutzerdefinierten Delegierten zu sortieren. Siehe - MSDN-Dokumentation zum Vergleich (T) -Delegierten .

Ich stimme der Sortierung mit ORDER BY zu, wenn Sie mit einer Datenbankabfrage füllen. Wenn Sie nur die angezeigten Ergebnisse alphabetisch sortieren möchten, müssen Sie dies tun. Lassen Sie die Datenbank-Engine die Sortierarbeit erledigen.

Manchmal möchten Sie jedoch eine andere Sortierreihenfolge als alphabetisch . Sie möchten beispielsweise eine logische Sequenz wie: Neu, Öffnen, In Bearbeitung, Abgeschlossen, Genehmigt, Geschlossen. In diesem Fall könnten Sie der Datenbanktabelle eine Spalte hinzufügen, um die Sortierreihenfolge explizit festzulegen. Nennen Sie es etwas wie SortOrder oder DisplaySortOrder. Dann würden Sie in SQL Ihre Sortierung nach dem Sortierfeld durchführen (ohne dieses Feld abzurufen). 

var list = ddl.Items.Cast<ListItem>().OrderBy(x => x.Text).ToList();

ddl.DataSource = list;
ddl.DataTextField = "Text";
ddl.DataValueField = "Value"; 
ddl.DataBind();

Sie können diese JavaScript-Funktion verwenden:

function sortlist(mylist)
{
   var lb = document.getElementById(mylist);
   arrTexts = new Array();
   arrValues = new Array();
   arrOldTexts = new Array();

   for(i=0; i<lb.length; i++)
   {
      arrTexts[i] = lb.options[i].text;
      arrValues[i] = lb.options[i].value;

      arrOldTexts[i] = lb.options[i].text;
   }

   arrTexts.sort();

   for(i=0; i<lb.length; i++)
   {
      lb.options[i].text = arrTexts[i];
      for(j=0; j<lb.length; j++)
      {
         if (arrTexts[i] == arrOldTexts[j])
         {
            lb.options[i].value = arrValues[j];
            j = lb.length;
         }
      }
   }
}

Wenn Ihre Daten als System.Data.DataTable zu Ihnen kommen, rufen Sie die .Select () - Methode der DataTable auf, übergeben "" für die filterExpression und "COLUMN1 ASC" (oder die Spalte, nach der sortiert werden soll). Dadurch wird ein Array von DataRow-Objekten zurückgegeben, die wie angegeben sortiert sind, die Sie dann durchlaufen und in die DropDownList-Datei speichern können.

es ist besser, wenn Sie die Quelle sortieren, bevor Sie sie an DropDwonList binden sortieren Sie DropDownList.Items jedoch folgendermaßen:

    Dim Lista_Items = New List(Of ListItem)

    For Each item As ListItem In ddl.Items
        Lista_Items.Add(item)
    Next

    Lista_Items.Sort(Function(x, y) String.Compare(x.Text, y.Text))

    ddl.Items.Clear()
    ddl.Items.AddRange(Lista_Items.ToArray())

(In diesem Fall sortiere ich nach einer Zeichenfolge (dem Text des Artikels), es könnte der Name des Lieferanten und die Lieferanten-ID sein.

die Sort()-Methode kann für jeden List(of )/List<MyType> verwendet werden.

Ich stimme den Leuten zu, wenn Sie Ihre Daten im Modell sortieren, bevor Sie sie in die DropDownList einfügen. Wenn Sie diese Daten also von einer Datenbank aus füllen, ist es eine gute Sache, sie dort mit einer einfachen order by -Klausel zu sortieren Dadurch werden Ihnen einige Zyklen auf dem Webserver erspart, und ich bin sicher, dass die Datenbank das viel schneller erledigt. Wenn Sie dies aus einer anderen Datenquelle (z. B. XML-Datei) auffüllen, ist die Verwendung von LINQ eine gute Idee oder sogar jede Variation von Array.Sort ist gut.

Wenn Sie der Dropdown-Liste nacheinander Optionen ohne Datensatz hinzufügen und diese später nach dem Hinzufügen von Elementen sortieren möchten, finden Sie hier eine Lösung:

DataTable dtOptions = new DataTable();
DataColumn[] dcColumns = { new DataColumn("Text", Type.GetType("System.String")), 
                           new DataColumn("Value", Type.GetType("System.String"))};
dtOptions.Columns.AddRange(dcColumns);
foreach (ListItem li in ddlOperation.Items)
{
   DataRow dr = dtOptions.NewRow();
   dr["Text"] = li.Text;
   dr["Value"] = li.Value;
   dtOptions.Rows.Add(dr);
}
DataView dv = dtOptions.DefaultView;
dv.Sort = "Text";
ddlOperation.Items.Clear();
ddlOperation.DataSource = dv;
ddlOperation.DataTextField = "Text";
ddlOperation.DataValueField = "Value";
ddlOperation.DataBind();

Dadurch werden die Dropdown-Elemente in alphabetischer Reihenfolge sortiert.

Versuche dies:

/// <summary>
/// AlphabetizeDropDownList alphabetizes a given dropdown list by it's displayed text.
/// </summary>
/// <param name="dropDownList">The drop down list you wish to modify.</param>
/// <remarks></remarks>
private void AlphabetizeDropDownList(ref DropDownList dropDownList)
{
    //Create a datatable to sort the drop down list items
    DataTable machineDescriptionsTable = new DataTable();
    machineDescriptionsTable.Columns.Add("DescriptionCode", typeof(string));
    machineDescriptionsTable.Columns.Add("UnitIDString", typeof(string));
    machineDescriptionsTable.AcceptChanges();
    //Put each of the list items into the datatable
    foreach (ListItem currentDropDownListItem in dropDownList.Items) {
            string currentDropDownUnitIDString = currentDropDownListItem.Value;
            string currentDropDownDescriptionCode = currentDropDownListItem.Text;
            DataRow currentDropDownDataRow = machineDescriptionsTable.NewRow();
            currentDropDownDataRow["DescriptionCode"] = currentDropDownDescriptionCode.Trim();
            currentDropDownDataRow["UnitIDString"] = currentDropDownUnitIDString.Trim();
            machineDescriptionsTable.Rows.Add(currentDropDownDataRow);
            machineDescriptionsTable.AcceptChanges();
    }
    //Sort the data table by description
    DataView sortedView = new DataView(machineDescriptionsTable);
    sortedView.Sort = "DescriptionCode";
    machineDescriptionsTable = sortedView.ToTable();
    //Clear the items in the original dropdown list
    dropDownList.Items.Clear();
    //Create a dummy list item at the top
    ListItem dummyListItem = new ListItem(" ", "-1");
    dropDownList.Items.Add(dummyListItem);
    //Begin transferring over the items alphabetically from the copy to the intended drop
     downlist
    foreach (DataRow currentDataRow in machineDescriptionsTable.Rows) {
            string currentDropDownValue = currentDataRow["UnitIDString"].ToString().Trim();
            string currentDropDownText = currentDataRow["DescriptionCode"].ToString().Trim();
            ListItem currentDropDownListItem = new ListItem(currentDropDownText, currentDropDownValue);
    //Don't deal with dummy values in the list we are transferring over
    if (!string.IsNullOrEmpty(currentDropDownText.Trim())) {
        dropDownList.Items.Add(currentDropDownListItem);
    }
}

}

Dadurch wird eine bestimmte Dropdown-Liste mit einer Text- und einer Value-Eigenschaft des Listenelements in die entsprechende Dropdown-Liste aufgenommen.

Wenn Sie eine datenbeschränkte DropDownList verwenden, wechseln Sie zum Assistenten und bearbeiten Sie die Begrenzungsabfrage wie folgt:

1. Wechseln Sie zur ASPX-Seite (Entwurfsansicht).
2. Klicken Sie in der Dropdown-Liste auf den magischen Pfeil ">".
3. Wählen Sie "Datenquelle konfigurieren". 
4. Weiter klicken.
5. Klicken Sie auf der rechten Seite des geöffneten Fensters auf "ORDER BY ...".
6. Sie haben dort zwei Feldkariterien, nach denen Sie sortieren können. Wählen Sie das gewünschte Feld aus und klicken Sie auf OK und anschließend auf Fertig stellen.

Sie können es so machen, ist einfach

private void SortDDL(ref DropDownList objDDL)
{
ArrayList textList = new ArrayList();
ArrayList valueList = new ArrayList();
foreach (ListItem li in objDDL.Items)
{
    textList.Add(li.Text);
}
textList.Sort();
foreach (object item in textList)
{
    string value = objDDL.Items.FindByText(item.ToString()).Value;
    valueList.Add(value);
}
objDDL.Items.Clear();
for(int i = 0; i < textList.Count; i++)
{
     ListItem objItem = new ListItem(textList[i].ToString(), valueList[i].ToString());
     objDDL.Items.Add(objItem);
}

}

Und nennen Sie die Methode diese SortDDL (ref yourDropDownList); Und das ist es. Die Daten in Ihrer Dropdown-Liste werden sortiert.

siehe http://www.codeproject.com/Articles/20131/Sorting-Dropdown-list-in-ASP-NET-using-C#

Um eine Objektdatenquelle zu sortieren, die eine Datenmenge zurückgibt, verwenden Sie die Sort - Eigenschaft des Steuerelements. 

Verwendungsbeispiel Auf der Aspx-Seite nach aufsteigender Reihenfolge von ColumnName sortieren 

<asp:ObjectDataSource ID="dsData" runat="server" TableName="Data" 
 Sort="ColumnName ASC" />

        List<ListItem> li = new List<ListItem>();
        foreach (ListItem list in DropDownList1.Items)
        {
            li.Add(list);
        }
        li.Sort((x, y) => string.Compare(x.Text, y.Text));
        DropDownList1.Items.Clear();
        DropDownList1.DataSource = li;
        DropDownList1.DataTextField = "Text";
        DropDownList1.DataValueField = "Value";
        DropDownList1.DataBind();