ListViewGroupCollection Classe

Definizione

Rappresenta la raccolta dei gruppi all'interno di un controllo ListView.

[System.ComponentModel.ListBindable(false)]
public class ListViewGroupCollection : System.Collections.IList
Ereditarietà
ListViewGroupCollection
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrato come utilizzare la ListView funzionalità di raggruppamento per organizzare gli elementi in base al valore dell'elemento secondario nella visualizzazione dei dettagli. Questa forma di raggruppamento è simile al raggruppamento usato in Esplora risorse. Nell'esempio i gruppi vengono creati in modo dinamico. Per ogni colonna dell'elemento secondario viene creato un gruppo per ogni valore di sottoelemento univoco. Per la colonna elemento padre viene creato un gruppo per ogni lettera iniziale univoca. Facendo clic sull'intestazione di una colonna, gli elementi vengono ordinati nei gruppi creati per tale colonna. Facendo di nuovo clic sulla stessa intestazione di colonna, l'ordine dei gruppi viene invertito.

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;
            }
        }
    }
}

Commenti

Utilizzare la ListView.Groups proprietà per ottenere l'oggetto ListViewGroupCollection associato a un ListView controllo . Questo insieme contiene gli ListViewGroup oggetti che rappresentano i gruppi visualizzati nel controllo quando la ListView.View proprietà è impostata su un valore diverso da View.List. Tutti gli elementi non assegnati a un gruppo verranno visualizzati nel gruppo predefinito, con l'etichetta di intestazione "DefaultGroup{0}". Il gruppo predefinito non è contenuto nell'insieme ListView.Groups e non può essere modificato. È utile principalmente nel debug per assicurarsi che tutti gli elementi siano stati aggiunti correttamente ai gruppi. Se nella raccolta non sono presenti gruppi ListView.Groups , la funzionalità di raggruppamento è disabilitata.

Utilizzare il Add metodo per aggiungere un singolo gruppo alla raccolta. Utilizzare il Insert metodo per aggiungere un gruppo in corrispondenza di un particolare indice all'interno dell'insieme. Per rimuovere un gruppo, usare il Remove metodo . Utilizzare il RemoveAt metodo per rimuovere il gruppo in corrispondenza di un determinato indice.

Non è possibile aggiungere un ListViewGroup oggetto alla raccolta più volte. Per riposizionare un gruppo all'interno della raccolta, è necessario prima rimuoverlo dalla raccolta e quindi inserirlo nella posizione desiderata. Utilizzare il Contains metodo per determinare se un determinato gruppo è già presente nella raccolta. Per recuperare l'indice di un gruppo all'interno della raccolta, utilizzare il IndexOf metodo . È possibile ottenere o impostare il gruppo in corrispondenza di un determinato indice con l'indicizzatore Item[] .

Utilizzare il AddRange metodo per aggiungere più gruppi alla raccolta. È possibile aggiungere più gruppi come matrice di gruppi o come oggetto ListViewGroupCollection recuperato tramite la ListView.Groups proprietà di un altro ListView controllo. Utilizzare il Clear metodo per rimuovere tutti i gruppi dalla raccolta.

Nota

I Removemetodi , RemoveAte Clear rimuovono i gruppi dalla raccolta, ma non rimuovono elementi dal ListView controllo . Se nella raccolta non sono presenti gruppi ListView.Groups , la funzionalità di raggruppamento è disabilitata e tutti gli elementi del controllo vengono visualizzati normalmente.

I AddRange metodi e Clear sono utili quando si desidera fornire più modi per raggruppare gli elementi in un ListView controllo . A tale scopo, creare più matrici di gruppi. Per modificare il raggruppamento, usare prima di tutto il Clear metodo per rimuovere tutti i gruppi dalla raccolta, quindi usare il AddRange metodo per aggiungere la matrice successiva di gruppi da visualizzare.

Utilizzare il CopyTo metodo per copiare i gruppi in una raccolta in una matrice compatibile a partire da un indice specificato. Ciò è utile, ad esempio, quando si desidera ordinare i gruppi nella raccolta usando il Array.Sort metodo . A tale scopo, copiare i gruppi in una matrice compatibile, quindi ordinare la matrice. Usare quindi il Clear metodo per rimuovere tutti i gruppi dalla raccolta, quindi usare il AddRange metodo per aggiungere nuovamente la matrice ordinata alla raccolta.

Utilizzare la Count proprietà per determinare il numero di gruppi presenti nell'insieme. Per scorrere la raccolta, utilizzare l'oggetto IEnumerator restituito dal GetEnumerator metodo .

Nota

La funzionalità di raggruppamento è disponibile solo in Windows XP e nella famiglia Windows Server 2003 quando l'applicazione chiama il Application.EnableVisualStyles metodo . Nei sistemi operativi precedenti, qualsiasi codice relativo ai gruppi verrà ignorato e i gruppi non verranno visualizzati. Di conseguenza, qualsiasi codice che dipende dalla funzionalità di raggruppamento potrebbe non funzionare correttamente. È possibile includere un test che determina se la funzionalità di raggruppamento è disponibile e fornire funzionalità alternative quando non è disponibile. Ad esempio, è possibile fornire un ordinamento alternativo quando si esegue nei sistemi operativi che non supportano l'ordinamento in base al gruppo.

La funzionalità del contrassegno di inserimento viene fornita dalla stessa libreria che fornisce la funzionalità temi del sistema operativo. Per verificare la disponibilità di questa libreria, chiamare l'overload del FeatureSupport.IsPresent(Object) metodo e passare il OSFeature.Themes valore .

Proprietà

Count

Ottiene il numero di gruppi nell'insieme.

Item[Int32]

Ottiene o imposta il gruppo ListViewGroup in corrispondenza dell'indice specificato all'interno dell'insieme.

Item[String]

Ottiene o imposta l'oggetto ListViewGroup con il valore della proprietà Name specificato.

Metodi

Add(ListViewGroup)

Aggiunge l'oggetto ListViewGroup specificato alla raccolta.

Add(String, String)

Aggiunge un nuovo oggetto ListViewGroup alla raccolta usando i valori specificati per inizializzare le proprietà Name e Header.

AddRange(ListViewGroup[])

Aggiunge una matrice di gruppi all'insieme.

AddRange(ListViewGroupCollection)

Aggiunge i gruppi di un oggetto ListViewGroupCollection esistente all'insieme.

Clear()

Rimuove tutti i gruppi dall'insieme.

Contains(ListViewGroup)

Consente di determinare se il gruppo specificato è contenuto nell'insieme.

CopyTo(Array, Int32)

Copia i gruppi dell'insieme in una matrice compatibile unidimensionale Array, a partire dall'indice specificato della matrice di destinazione.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetEnumerator()

Restituisce un enumeratore che consente di scorrere l'insieme.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
IndexOf(ListViewGroup)

Restituisce l'indice dell'oggetto ListViewGroup specificato all'interno dell'insieme.

Insert(Int32, ListViewGroup)

Inserisce l'oggetto ListViewGroup specificato nell'insieme in corrispondenza dell'indice specificato.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
Remove(ListViewGroup)

Rimuove l'oggetto ListViewGroup specificato dalla raccolta.

RemoveAt(Int32)

Rimuove l'oggetto ListViewGroup in corrispondenza dell'indice specificato all'interno dell'insieme.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Implementazioni dell'interfaccia esplicita

ICollection.IsSynchronized

Ottiene un valore che indica se l'accesso alla raccolta è sincronizzato (thread-safe).

ICollection.SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso alla raccolta.

IList.Add(Object)

Consente di aggiungere un nuovo oggetto ListViewGroup a ListViewGroupCollection.

IList.Contains(Object)

Consente di determinare se il valore specificato è contenuto nell'insieme.

IList.IndexOf(Object)

Restituisce l'indice all'interno dell'insieme del valore specificato.

IList.Insert(Int32, Object)

Inserisce un gruppo ListViewGroup nell'insieme ListViewGroupCollection.

IList.IsFixedSize

Ottiene un valore che indica se la dimensione della raccolta è fissa.

IList.IsReadOnly

Ottiene un valore che indica se la raccolta è di sola lettura.

IList.Item[Int32]

Ottiene o imposta il gruppo ListViewGroup in corrispondenza dell'indice specificato all'interno dell'insieme.

IList.Remove(Object)

Rimuove il gruppo ListViewGroup dall'insieme ListViewGroupCollection.

Metodi di estensione

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.

Si applica a

Prodotto Versioni
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
Windows Desktop 3.0, 3.1, 5, 6, 7, 8, 9

Vedi anche