Exportieren (0) Drucken
Alle erweitern
Dieser Artikel wurde manuell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen.
Übersetzung
Original

ListViewGroupCollection-Klasse

Stellt die Auflistung von Gruppen in einem ListView-Steuerelement dar.

System.Object
  System.Windows.Forms.ListViewGroupCollection

Namespace:  System.Windows.Forms
Assembly:  System.Windows.Forms (in System.Windows.Forms.dll)

[ListBindableAttribute(false)]
public class ListViewGroupCollection : IList, 
	ICollection, IEnumerable

Der ListViewGroupCollection-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche EigenschaftCountRuft die Anzahl der Gruppen in der Auflistung ab.
Öffentliche EigenschaftItem[Int32]Ruft eine ListViewGroup am angegebenen Index in der Auflistung ab oder legt diese fest.
Öffentliche EigenschaftItem[String]Ruft die ListViewGroup mit dem angegebenen ListViewGroup.Name-Eigenschaftswert ab oder legt diese fest.
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeAdd(ListViewGroup)Fügt der Auflistung die angegebene ListViewGroup hinzu.
Öffentliche MethodeAdd(String, String)Fügt der Auflistung eine neue ListViewGroup unter Verwendung der angegebenen Werte zum Initialisieren der Name-Eigenschaft und der Header-Eigenschaft hinzu.
Öffentliche MethodeAddRange(ListViewGroup[])Fügt der Auflistung ein Array von Gruppen hinzu.
Öffentliche MethodeAddRange(ListViewGroupCollection)Fügt der Auflistung die Gruppen in einer vorhandenen ListViewGroupCollection hinzu.
Öffentliche MethodeClearEntfernt alle Gruppen aus der Auflistung.
Öffentliche MethodeContainsBestimmt, ob die angegebene Gruppe in der Auflistung enthalten ist.
Öffentliche MethodeCopyToKopiert die Gruppen in der Auflistung in ein kompatibles eindimensionales Array, beginnend ab dem angegebenen Index im Zielarray.
Öffentliche MethodeEquals(Object) Bestimmt, ob das übergegebene Object und das aktuelle Object gleich sind. (Von Object geerbt.)
Geschützte MethodeFinalize Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Von Object geerbt.)
Öffentliche MethodeGetEnumeratorGibt einen Enumerator zurück, mit dem die Auflistung durchlaufen werden kann.
Öffentliche MethodeGetHashCodeFungiert als Hashfunktion für einen bestimmten Typ. (Von Object geerbt.)
Öffentliche MethodeGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeIndexOfGibt den Index der angegebenen ListViewGroup in der Auflistung zurück.
Öffentliche MethodeInsertFügt die angegebene ListViewGroup am angegebenen Index in die Auflistung ein.
Geschützte MethodeMemberwiseCloneErstellt eine flache Kopie des aktuellen Object. (Von Object geerbt.)
Öffentliche MethodeRemoveEntfernt die angegebene ListViewGroup aus der Auflistung.
Öffentliche MethodeRemoveAtEntfernt die ListViewGroup am angegebenen Index aus der Auflistung.
Öffentliche MethodeToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Zum Seitenanfang

  NameBeschreibung
Öffentliche ErweiterungsmethodeAsParallelErmöglicht die Parallelisierung einer Abfrage. (Durch ParallelEnumerable definiert.)
Öffentliche ErweiterungsmethodeAsQueryableKonvertiert einen IEnumerable in einen IQueryable. (Durch Queryable definiert.)
Öffentliche ErweiterungsmethodeCast<TResult>Konvertiert die Elemente eines IEnumerable in den angegebenen Typ. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeOfType<TResult>Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs. (Durch Enumerable definiert.)
Zum Seitenanfang

  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate EigenschaftICollection.IsSynchronizedInfrastruktur. Ruft einen Wert ab, der angibt, ob der Zugriff auf die Auflistung synchronisiert (threadsicher) ist.
Explizite SchnittstellenimplementierungPrivate EigenschaftICollection.SyncRootInfrastruktur. Ruft ein Objekt ab, mit dem der Zugriff auf die Auflistung synchronisiert werden kann.
Explizite SchnittstellenimplementierungPrivate MethodeIList.AddInfrastruktur. Fügt der ListViewGroupCollection eine neue ListViewGroup hinzu.
Explizite SchnittstellenimplementierungPrivate MethodeIList.ContainsInfrastruktur. Bestimmt, ob die angegebene Wert in der Auflistung enthalten ist.
Explizite SchnittstellenimplementierungPrivate MethodeIList.IndexOfGibt den Index des angegebenen Werts in der Auflistung zurück.
Explizite SchnittstellenimplementierungPrivate MethodeIList.InsertFügt eine ListViewGroup in die ListViewGroupCollection ein.
Explizite SchnittstellenimplementierungPrivate EigenschaftIList.IsFixedSizeRuft einen Wert ab, der angibt, ob die Auflistung eine feste Größe hat.
Explizite SchnittstellenimplementierungPrivate EigenschaftIList.IsReadOnlyRuft einen Wert ab, der angibt, ob die Auflistung schreibgeschützt ist.
Explizite SchnittstellenimplementierungPrivate EigenschaftIList.ItemRuft eine ListViewGroup am angegebenen Index in der Auflistung ab oder legt diese fest.
Explizite SchnittstellenimplementierungPrivate MethodeIList.RemoveEntfernt die ListViewGroup aus der ListViewGroupCollection.
Zum Seitenanfang

Verwenden Sie die ListView.Groups-Eigenschaft, um die ListViewGroupCollection abzurufen, die einem ListView-Steuerelement zugeordnet ist. Diese Auflistung enthält die ListViewGroup-Objekte, die die im Steuerelement angezeigten Gruppen darstellen, wenn die ListView.View-Eigenschaft nicht auf View.List festgelegt ist. Alle Elemente, die keiner Gruppe zugewiesen sind, werden in der Standardgruppe angezeigt, die die Headerbezeichnung "DefaultGroup{0}" trägt. Die Standardgruppe ist nicht in der ListView.Groups-Auflistung enthalten und kann nicht geändert werden. Die Zuordnung sämtlicher Elemente zu Gruppen ist insbesondere zum Debuggen sinnvoll. Wenn die ListView.Groups-Auflistung keine Gruppen enthält, wird das Gruppierungsfeature deaktiviert.

Mit der Add-Methode können Sie der Auflistung eine einzelne Gruppe hinzufügen. Mit der Insert-Methode können Sie eine Gruppe an einem bestimmten Index innerhalb der Auflistung hinzufügen. Zum Entfernen einer Gruppe verwenden Sie die Remove-Methode. Mit der RemoveAt-Methode können Sie die Gruppe an einem bestimmten Index entfernen.

Sie können eine ListViewGroup nur einmal in der Auflistung hinzufügen. Zum Ändern der Position einer Gruppe innerhalb der Auflistung muss die Gruppe zunächst aus der Auflistung entfernt und dann an der gewünschten Position wieder eingefügt werden. Mit der Contains-Methode können Sie bestimmen, ob eine bestimmte Gruppe bereits in der Auflistung vorhanden ist. Verwenden Sie die IndexOf-Methode, um den Index einer Gruppe innerhalb der Auflistung abzurufen. Mit dem Item-Indexer können Sie die Gruppe an einem bestimmten Index abrufen oder festlegen.

Mit der AddRange-Methode werden der Auflistung mehrere Gruppen hinzugefügt. Mehrere Gruppen können Sie als Array von Gruppen oder als ListViewGroupCollection hinzufügen, das Sie über die ListView.Groups-Eigenschaft eines anderen ListView-Steuerelements abrufen können. Mit der Clear-Methode entfernen Sie alle Gruppen aus der Auflistung.

HinweisHinweis

Die Remove-Methode, die RemoveAt-Methode und die Clear-Methode entfernen Gruppen aus der Auflistung, aber keine Elemente aus dem ListView-Steuerelement. Wenn die ListView.Groups-Auflistung keine Gruppen enthält, wird das Gruppierungsfeature deaktiviert, und sämtliche Elemente im Steuerelement werden normal angezeigt.

Die AddRange-Methode und die Clear-Methode sind sinnvoll, wenn Sie mehrere Varianten für das Gruppieren der Elemente in einem ListView-Steuerelement bereitstellen möchten. Erstellen Sie dafür mehrere Gruppenarrays. Verwenden Sie zum Ändern der Gruppierung zunächst die Clear-Methode, um alle Gruppen aus der Auflistung zu entfernen, und fügen Sie dann mit der AddRange-Methode das nächste Array von Gruppen für die Anzeige hinzu.

Mit der CopyTo-Methode können Sie die Gruppen in einer Auflistung ab einem angegebenen Index in ein kompatibles Array kopieren. Dies ist z. B. dann sinnvoll, wenn Sie die Gruppen in der Auflistung mit der Array.Sort-Methode sortieren möchten. Kopieren Sie dafür die Gruppen in ein kompatibles Array, und sortieren Sie anschließend das Array. Entfernen Sie dann mit der Clear-Methode alle Gruppen aus der Auflistung, und fügen Sie das sortierte Array mit der AddRange-Methode wieder in der Auflistung hinzu.

Mit der Count-Eigenschaft können Sie die Anzahl der Gruppen in der Auflistung bestimmen. Zum Durchlaufen der Auflistung verwenden Sie den von der GetEnumerator-Methode zurückgegebenen IEnumerator.

HinweisHinweis

Das Gruppierungsfeature ist nur unter Windows XP und der Windows Server 2003-Produktfamilie verfügbar, wenn die Anwendung die Application.EnableVisualStyles-Methode aufruft. Unter früheren Betriebssystemen wird Code mit Bezug auf Gruppen ignoriert, und die Gruppen werden nicht angezeigt. Code, der vom Gruppierungsfeature abhängt, könnte daher u. U. nicht ordnungsgemäß funktionieren. Sie könnten mit einem hinzufügten Test ermitteln, ob das Gruppierungsfeature verfügbar ist, und ggf. eine Ausweichfunktion bereitstellen. So könnten Sie z. B. für die Ausführung unter Betriebssystemen, die keine Sortierung nach Gruppen unterstützen, ein anderes Sortierverfahren bereitstellen.

Das Feature für Einfügemarken wird von derselben Bibliothek bereitgestellt, die das Feature für Betriebssystemdesigns zur Verfügung stellt. Wenn Sie die Verfügbarkeit dieser Bibliothek überprüfen möchten, rufen Sie die FeatureSupport.IsPresent(Object)-Methodenüberladung auf, und übergeben Sie den OSFeature.Themes-Wert.

Im folgenden Codebeispiel wird veranschaulicht, wie Elemente mithilfe des ListView-Gruppierungsfeatures in der Detailansicht nach dem Wert eines Unterelements angeordnet werden. Dieses Verfahren ähnelt der in Windows Explorer verwendeten Gruppierung. Im vorliegenden Beispiel werden die Gruppen dynamisch erstellt. Dabei wird in allen Unterelementspalten für jeden eindeutigen Unterelementwert eine Gruppe erstellt. In der Spalte mit dem übergeordneten Element wird für jeden eindeutigen Anfangsbuchstaben eine Gruppe erstellt. Durch das Klicken auf einen Spaltenheader werden die Elemente in die für diese Spalte erstellten Gruppen sortiert. Bei erneutem Klicken auf den Spaltenheader wird die Reihenfolge der Gruppen umgekehrt.


using System;
using System.Collections; 
using System.Windows.Forms;

public class ListViewGroupsExample : Form
{
    private ListView myListView;

    // Determine whether Windows XP or a later
    // operating system is present.
    private bool isRunningXPOrLater = 
        OSFeature.Feature.IsPresent(OSFeature.Themes);

    // Declare a Hashtable array in which to store the groups.
    private Hashtable[] groupTables;

    // Declare a variable to store the current grouping column.
    int groupColumn = 0;

    public ListViewGroupsExample()
    {
        // Initialize myListView.
        myListView = new ListView();
        myListView.Dock = DockStyle.Fill;
        myListView.View = View.Details;
        myListView.Sorting = SortOrder.Ascending;

        // Create and initialize column headers for myListView.
        ColumnHeader columnHeader0 = new ColumnHeader();
        columnHeader0.Text = "Title";
        columnHeader0.Width = -1;
        ColumnHeader columnHeader1 = new ColumnHeader();
        columnHeader1.Text = "Author";
        columnHeader1.Width = -1;
        ColumnHeader columnHeader2 = new ColumnHeader();
        columnHeader2.Text = "Year";
        columnHeader2.Width = -1;

        // Add the column headers to myListView.
        myListView.Columns.AddRange(new ColumnHeader[] 
            {columnHeader0, columnHeader1, columnHeader2});

        // Add a handler for the ColumnClick event.
        myListView.ColumnClick += 
            new ColumnClickEventHandler(myListView_ColumnClick);

        // Create items and add them to myListView.
        ListViewItem item0 = new ListViewItem( new string[] 
            {"Programming Windows", 
            "Petzold, Charles", 
            "1998"} );
        ListViewItem item1 = new ListViewItem( new string[] 
            {"Code: The Hidden Language of Computer Hardware and Software", 
            "Petzold, Charles", 
            "2000"} );
        ListViewItem item2 = new ListViewItem( new string[] 
            {"Programming Windows with C#", 
            "Petzold, Charles", 
            "2001"} );
        ListViewItem item3 = new ListViewItem( new string[] 
            {"Coding Techniques for Microsoft Visual Basic .NET", 
            "Connell, John", 
            "2001"} );
        ListViewItem item4 = new ListViewItem( new string[] 
            {"C# for Java Developers", 
            "Jones, Allen & Freeman, Adam", 
            "2002"} );
        ListViewItem item5 = new ListViewItem( new string[] 
            {"Microsoft .NET XML Web Services Step by Step", 
            "Jones, Allen & Freeman, Adam", 
            "2002"} );
        myListView.Items.AddRange(
            new ListViewItem[] {item0, item1, item2, item3, item4, item5});

        if (isRunningXPOrLater)
        {
            // Create the groupsTable array and populate it with one 
            // hash table for each column.
            groupTables = new Hashtable[myListView.Columns.Count];
            for (int column = 0; column < myListView.Columns.Count; column++)
            {
                // Create a hash table containing all the groups 
                // needed for a single column.
                groupTables[column] = CreateGroupsTable(column);
            }

            // Start with the groups created for the Title column.
            SetGroups(0);
        }

        // Initialize the form.
        this.Controls.Add(myListView);
        this.Size = new System.Drawing.Size(550, 330);
        this.Text = "ListView Groups Example";
    }

    [STAThread]
    static void Main() 
    {
        Application.EnableVisualStyles();
        Application.Run(new ListViewGroupsExample());
    }

    // Groups the items using the groups created for the clicked 
    // column.
    private void myListView_ColumnClick(
        object sender, ColumnClickEventArgs e)
    {
        // Set the sort order to ascending when changing
        // column groups; otherwise, reverse the sort order.
        if ( myListView.Sorting == SortOrder.Descending || 
            ( isRunningXPOrLater && (e.Column != groupColumn) ) )
        {
            myListView.Sorting = SortOrder.Ascending;
        }
        else 
        {
            myListView.Sorting = SortOrder.Descending;
        }
        groupColumn = e.Column;

        // Set the groups to those created for the clicked column.
        if (isRunningXPOrLater)
        {
            SetGroups(e.Column);
        }
    }

    // Sets myListView to the groups created for the specified column.
    private void SetGroups(int column)
    {
        // Remove the current groups.
        myListView.Groups.Clear();

        // Retrieve the hash table corresponding to the column.
        Hashtable groups = (Hashtable)groupTables[column];

        // Copy the groups for the column to an array.
        ListViewGroup[] groupsArray = new ListViewGroup[groups.Count];
        groups.Values.CopyTo(groupsArray, 0);

        // Sort the groups and add them to myListView.
        Array.Sort(groupsArray, new ListViewGroupSorter(myListView.Sorting));
        myListView.Groups.AddRange(groupsArray);

        // Iterate through the items in myListView, assigning each 
        // one to the appropriate group.
        foreach (ListViewItem item in myListView.Items)
        {
            // Retrieve the subitem text corresponding to the column.
            string subItemText = item.SubItems[column].Text;

            // For the Title column, use only the first letter.
            if (column == 0) 
            {
                subItemText = subItemText.Substring(0, 1);
            }

            // Assign the item to the matching group.
            item.Group = (ListViewGroup)groups[subItemText];
        }
    }

    // Creates a Hashtable object with one entry for each unique
    // subitem value (or initial letter for the parent item)
    // in the specified column.
    private Hashtable CreateGroupsTable(int column)
    {
        // Create a Hashtable object.
        Hashtable groups = new Hashtable();

        // Iterate through the items in myListView.
        foreach (ListViewItem item in myListView.Items)
        {
            // Retrieve the text value for the column.
            string subItemText = item.SubItems[column].Text;

            // Use the initial letter instead if it is the first column.
            if (column == 0) 
            {
                subItemText = subItemText.Substring(0, 1);
            }

            // If the groups table does not already contain a group
            // for the subItemText value, add a new group using the 
            // subItemText value for the group header and Hashtable key.
            if (!groups.Contains(subItemText))
            {
                groups.Add( subItemText, new ListViewGroup(subItemText, 
                    HorizontalAlignment.Left) );
            }
        }

        // Return the Hashtable object.
        return groups;
    }

    // Sorts ListViewGroup objects by header value.
    private class ListViewGroupSorter : IComparer
    {
        private SortOrder order;

        // Stores the sort order.
        public ListViewGroupSorter(SortOrder theOrder) 
        { 
            order = theOrder;
        }

        // Compares the groups by header value, using the saved sort
        // order to return the correct value.
        public int Compare(object x, object y)
        {
            int result = String.Compare(
                ((ListViewGroup)x).Header,
                ((ListViewGroup)y).Header
            );
            if (order == SortOrder.Ascending)
            {
                return result;
            }
            else 
            {
                return -result;
            }
        }
    }

}


.NET Framework

Unterstützt in: 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Windows 7, Windows Vista SP1 oder höher, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core wird nicht unterstützt), Windows Server 2008 R2 (Server Core wird mit SP1 oder höher unterstützt), Windows Server 2003 SP2

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft