SO WIRD'S GEMACHT: Sort ListView Items

  • Artikel

Dieser Dokumentation für die Vorschau nur ist und in späteren Versionen geändert. Leere Themen wurden als Platzhalter eingefügt.]

.NET Compact Framework keine Unterstützung der Sort -Methode für ein ListView, aber Sie können weiterhin Elemente mithilfe der IComparer Schnittstelle und verwenden Sie die Sort -Methode auf ein ArrayList sortieren.

In der folgende Tabelle werden drei Klassen definiert.

Klasse

Beschreibung

ColHeader

Von der ColumnHeader -Klasse abgeleitet ist, wird diese Klasse zum Hinzufügen von Spalten, die das Steuerelement ListView und zum Sortieren der Spalte, auf der geklickt wurde verwendet. Es umfasst die ascending-Eigenschaft um die Richtung die Sortierung anzugeben: true gibt aufsteigender und false gibt Absteigend.

SortWrapper

Wenn eine Spalte geklickt wird, wird eine Instanz dieser Klasse für jede ListItem erstellt und ein ArrayList hinzugefügt. Jedes eingebundene Element enthält eine Eigenschaft mit dem Index der Spalte, auf die geklickt wurde.

Diese Klasse enthält die SortComparer-Klasse.

SortComparer

Innerhalb der Klasse SortWrapper definiert diese Klasse eine Implementierung der IComparer -Schnittstelle, deren Methode Compare Objekte, zwei zu einem Zeitpunkt vergleicht, als ArrayList sortiert ist.

Der Ereignishandler für das ColumnClick-Ereignis führt den Sortiervorgang wie folgt aus:

  1. Erstellt eine Instanz der Klasse ColHeader zum Bestimmen, welche Spalte geklickt wird.

  2. Legt die aufsteigende-Eigenschaft des Objekts ColHeader zum Sortieren in der entgegengesetzten Richtung fest.

  3. Ruft die Anzahl der Elemente in der Liste ab.

  4. Das Neuaufbauen der Anzeige während der Sortierung mit der BeginUpdate-Methode deaktiviert.

  5. Ein SortWrapper hinzugefügt ein ListView für jedes Element ArrayList.

  6. Sortiert die Elemente in der ArrayList mithilfe einer neuen Instanz der SortComparer -Klasse, deren Implementierung der Schnittstelle IComparer die Logik der Sortierung in der Compare-Methode enthält.

  7. Löscht das ListView -Steuerelement von Elementen und füllt das Steuerelement mit den sortierten Elementen von ArrayList.

  8. Das Neuaufbauen der Anzeige mit der Methode EndUpdate ermöglicht.

Beachten Sie, dass die Sort -Methode für ein ArrayList eine instabile Sortierung; ausführtd. h., wenn zwei Elemente gleich sind, kann deren Reihenfolge nicht beibehalten werden. Im Gegensatz dazu behält bei einer stabile Sortierung die Reihenfolge der Elemente, die gleich sind.

Zum Erstellen der Anwendung

  1. Fügen Sie die SortWrapper -Klasse hinzu Ihrem Projekt auch die SortComparer-Klasse enthält.

                                ' An instance of the SortWrapper class is created for 
                            ' each item and added to the ArrayList for sorting.
                            Public
                            Class SortWrapper
    Friend sortItem As ListViewItem
    Friend sortColumn AsInteger
    ' A SortWrapper requires the item and the index of the clicked column.PublicSubNew(ByVal Item As ListViewItem, ByVal iColumn AsInteger)
        sortItem = Item
        sortColumn = iColumn
    EndSub
    ' Text property for getting the text of an item.PublicReadOnlyProperty [Text]() AsStringGetReturn sortItem.SubItems(sortColumn).Text
        EndGetEndProperty
    ' Implementation of the IComparer     ' interface for sorting ArrayList items.PublicClass SortComparer
        Implements IComparer
        Private ascending AsBoolean

        ' Constructor requires the sort order;        ' true if ascending, otherwise descending.PublicSubNew(ByVal asc AsBoolean)
            Me.ascending = asc
        EndSub

        ' Implemnentation of the IComparer:Compare         ' method for comparing two objects.PublicFunction [Compare](ByVal x AsObject, ByVal y AsObject) AsIntegerImplements IComparer.Compare
            Dim xItem As SortWrapper = CType(x, SortWrapper)
            Dim yItem As SortWrapper = CType(y, SortWrapper)

            Dim xText AsString = xItem.sortItem.SubItems(xItem.sortColumn).Text
            Dim yText AsString = yItem.sortItem.SubItems(yItem.sortColumn).Text
            Return xText.CompareTo(yText) * IIf(Me.ascending, 1, -1)
        EndFunctionEndClassEndClass

                                // An instance of the SortWrapper class is created for
                            // each item and added to the ArrayList for sorting.
                            public
                            class SortWrapper
{
    internal ListViewItem sortItem;
    internalint sortColumn;


    // A SortWrapper requires the item and the index of the clicked column.public SortWrapper (ListViewItem Item, int iColumn)
    {
        sortItem = Item;
        sortColumn = iColumn;
    }

    // Text property for getting the text of an item.publicstring Text
    {
        get
        {
            return sortItem.SubItems[sortColumn].Text;
        }
    }

    // Implementation of the IComparer// interface for sorting ArrayList items.publicclass SortComparer : IComparer
    {
        boolascending;

        // Constructor requires the sort order;// true if ascending, otherwise descending.public SortComparer(bool asc)
        {
            this.ascending = asc;
        }

        // Implemnentation of the IComparer:Compare// method for comparing two objects.publicint Compare(object x, object y)
        {
            SortWrapper xItem = (SortWrapper) x;
            SortWrapper yItem = (SortWrapper) y;

            string xText = xItem.sortItem.SubItems[xItem.sortColumn].Text;
            string yText = yItem.sortItem.SubItems[yItem.sortColumn].Text;
            return xText.CompareTo(yText) * (this.ascending ? 1 : -1);
        }
    }
}

  2. Fügen Sie die ColHeader-Klasse hinzu Ihres Projekts.

                                ' The ColHeader class is a ColumnHeader object with an 
                            ' added property for determining an ascending or descending sort.
                            ' True specifies an ascending order, false specifies a descending order.
                            Public
                            Class ColHeader
    Inherits ColumnHeader
    Public ascending AsBooleanPublicSubNew(ByVal [text] AsString, ByVal width AsInteger, ByVal align As HorizontalAlignment, ByVal asc AsBoolean)
        Me.Text = [text]
        Me.Width = width
        Me.TextAlign = align
        Me.ascending = asc
    EndSubEndClass

                                // The ColHeader class is a ColumnHeader object with an
                            // added property for determining an ascending or descending sort.
                            // True specifies an ascending order, false specifies a descending order.
                            public
                            class ColHeader : ColumnHeader
{
    publicboolascending;
    public ColHeader(string text, int width,  HorizontalAlignment align, bool asc)
    {
        this.Text = text;
        this.Width = width;
        this.TextAlign = align;
        this.ascending = asc;
    }
}

  3. Hinzufügen von Spalten mit der Klasse ColHeader und ListView Elemente hinzufügen.

                                ' Set to Details view.
                            Me.listView1.View = View.Details

' Add columns using the ColHeader class. The fourth    ' parameter specifies true for an ascending sort order.
listView1.Columns.Add(New ColHeader("Name", 110, HorizontalAlignment.Left, True))
listView1.Columns.Add(New ColHeader("Region", 50, HorizontalAlignment.Left, True))
listView1.Columns.Add(New ColHeader("Sales", 70, HorizontalAlignment.Left, True))

' Add the data.
listView1.Items.Add(New ListViewItem(NewString() {"Archer, Karen", "4", "0521.28"}))
listView1.Items.Add(New ListViewItem(NewString() {"Benson, Max", "8", "0828.54"}))
listView1.Items.Add(New ListViewItem(NewString() {"Bezio, Marin", "3", "0535.22"}))
listView1.Items.Add(New ListViewItem(NewString() {"Higa, Sidney", "2", "0987.50"}))
listView1.Items.Add(New ListViewItem(NewString() {"Martin, Linda", "6", "1122.12"}))
listView1.Items.Add(New ListViewItem(NewString() {"Nash, Mike", "7", "1030.11"}))
listView1.Items.Add(New ListViewItem(NewString() {"Sanchez, Ken", "1", "0958.78"}))
listView1.Items.Add(New ListViewItem(NewString() {"Smith, Ben", "5", "0763.25"}))

' Connect the ListView.ColumnClick event to the ColumnClick event handler.AddHandlerMe.listView1.ColumnClick, AddressOf listView1_ColumnClick

                                this.listView1.View = View.Details;

// Add columns using the ColHeader class. The fourth// parameter specifies true for an ascending sort order.
listView1.Columns.Add(new ColHeader("Name", 110, HorizontalAlignment.Left, true));
listView1.Columns.Add(new ColHeader("Region", 50, HorizontalAlignment.Left, true));
listView1.Columns.Add(new ColHeader("Sales", 70, HorizontalAlignment.Left, true));

// Add the data.
listView1.Items.Add(new ListViewItem(newstring[] {"Archer, Karen","4","0521.28"}));
listView1.Items.Add(new ListViewItem(newstring[] {"Benson, Max","8","0828.54"}));
listView1.Items.Add(new ListViewItem(newstring[] {"Bezio, Marin","3","0535.22"}));
listView1.Items.Add(new ListViewItem(newstring[] {"Higa, Sidney","2","0987.50"}));
listView1.Items.Add(new ListViewItem(newstring[] {"Martin, Linda","6","1122.12"}));
listView1.Items.Add(new ListViewItem(newstring[] {"Nash, Mike","7","1030.11"}));
listView1.Items.Add(new ListViewItem(newstring[] {"Sanchez, Ken","1","0958.78"}));
listView1.Items.Add(new ListViewItem(newstring[] {"Smith, Ben","5","0763.25"}));

// Connect the ListView.ColumnClick event to the ColumnClick event handler.this.listView1.ColumnClick += new ColumnClickEventHandler(listView1_ColumnClick);

  4. Fügen Sie Code zum Durchführen des Sortiervorgangs.

                                Private
                            Sub listView1_ColumnClick(ByVal sender AsObject, ByVal e As ColumnClickEventArgs)

    ' Create an instance of the ColHeader class. Dim clickedCol As ColHeader = CType(Me.listView1.Columns(e.Column), ColHeader)

    ' Set the ascending property to sort in the opposite order.
    clickedCol.ascending = Not clickedCol.ascending

    ' Get the number of items in the list.Dim numItems AsInteger = Me.listView1.Items.Count

    ' Turn off display while data is repoplulated.Me.listView1.BeginUpdate()

    ' Populate an ArrayList with a SortWrapper of each list item.Dim SortArray AsNew ArrayList
    Dim i AsIntegerFor i = 0 To numItems - 1
        SortArray.Add(New SortWrapper(Me.listView1.Items(i), e.Column))
    Next i

    ' Sort the elements in the ArrayList using a new instance of the SortComparer    ' class. The parameters are the starting index, the length of the range to sort,    ' and the IComparer implementation to use for comparing elements. Note that    ' the IComparer implementation (SortComparer) requires the sort      ' direction for its constructor; true if ascending, othwise false.
    SortArray.Sort(0, SortArray.Count, New SortWrapper.SortComparer(clickedCol.ascending))

    ' Clear the list, and repopulate with the sorted items.Me.listView1.Items.Clear()
    Dim z AsIntegerFor z = 0 To numItems - 1
        Me.listView1.Items.Add(CType(SortArray(z), SortWrapper).sortItem)
    Next z
    ' Turn display back on.Me.listView1.EndUpdate()
EndSub

                                private
                            void listView1_ColumnClick(object sender, ColumnClickEventArgs e)
{

    // Create an instance of the ColHeader class.
    ColHeader clickedCol = (ColHeader)this.listView1.Columns[e.Column];

    // Set the ascending property to sort in the opposite order.
    clickedCol.ascending = !clickedCol.ascending;

    // Get the number of items in the list.int numItems = this.listView1.Items.Count;

    // Turn off display while data is repoplulated.this.listView1.BeginUpdate();

    // Populate an ArrayList with a SortWrapper of each list item.
    ArrayList SortArray = new ArrayList();
    for (int i = 0; i < numItems; i++)
    {
        SortArray.Add(new SortWrapper(this.listView1.Items[i], e.Column));
    }

    // Sort the elements in the ArrayList using a new instance of the SortComparer// class. The parameters are the starting index, the length of the range to sort,// and the IComparer implementation to use for comparing elements. Note that// the IComparer implementation (SortComparer) requires the sort// direction for its constructor; true if ascending, othwise false.
    SortArray.Sort(0, SortArray.Count, new SortWrapper.SortComparer(clickedCol.ascending));

    // Clear the list, and repopulate with the sorted items.this.listView1.Items.Clear();
    for  (int i = 0; i < numItems; i++)
        this.listView1.Items.Add(((SortWrapper)SortArray[i]).sortItem);

    // Turn display back on.this.listView1.EndUpdate();
}

Kompilieren des Codes

In diesem Beispiel sind Verweise auf die folgenden Namespaces erforderlich:

Siehe auch

Konzepte

Benutzerdefinierte Control Development

.NET compact Framework Gewusst-wie-Themen

Weitere Ressourcen

Windows Forms-Steuerelemente in .NET Compact Framework