Esporta (0) Stampa
Espandi tutto

Classe ListViewGroup

Rappresenta un gruppo di elementi visualizzati all'interno di un controllo ListView.

Spazio dei nomi: System.Windows.Forms
Assembly: System.Windows.Forms (in system.windows.forms.dll)

[SerializableAttribute] 
[TypeConverterAttribute(typeof(ListViewGroupConverter))] 
public sealed class ListViewGroup : ISerializable
/** @attribute SerializableAttribute() */ 
/** @attribute TypeConverterAttribute(System.Windows.Forms.ListViewGroupConverter) */ 
public final class ListViewGroup implements ISerializable
SerializableAttribute 
TypeConverterAttribute(System.Windows.Forms.ListViewGroupConverter) 
public final class ListViewGroup implements ISerializable
Non applicabile.

La funzionalità di raggruppamento ListView consente di creare gruppi visivi di elementi ListView correlati logicamente. Ogni gruppo è costituito da un'intestazione basata su testo seguita da una linea orizzontale e dagli elementi assegnati a tale gruppo. Il testo dell'intestazione può essere allineato a sinistra, a destra o al centro del controllo. I gruppi assegnati a un controllo ListView vengono visualizzati ogni volta che la proprietà ListView.View viene impostata su un valore diverso da View.List.

I gruppi ListView hanno lo scopo di aiutare gli utenti a trovare gli elementi che stanno cercando separando gli elementi in categorie utili. È possibile creare tutte le categorie necessarie. Una tipica modalità di raggruppamento degli elementi è quella basata sul loro ordinamento. Gli elementi, ad esempio, possono essere raggruppati in base alla lettera iniziale del nome dell'elemento quando sono ordinati alfabeticamente, oppure per elementi secondari quali il tipo o la data quando l'elenco viene ordinato facendo clic su un'intestazione di colonna nella visualizzazione Dettagli. In Windows Explorer viene utilizzato questo tipo di raggruppamento.

Per utilizzare la funzionalità di raggruppamento, aggiungere uno o più oggetti ListViewGroup all'insieme ListView.Groups di un controllo ListView. Impostare il testo dell'intestazione del gruppo e l'allineamento dell'intestazione nel costruttore ListViewGroup oppure impostarli utilizzando le proprietà Header e HeaderAlignment.

È possibile assegnare un elemento al gruppo specificando il gruppo nel costruttore ListViewItem, impostando la proprietà ListViewItem.Group oppure aggiungendolo direttamente all'insieme Items di un gruppo. Tutti gli elementi devono essere assegnati ai gruppi prima di essere visualizzati. Gli elementi che non vengono assegnati a un gruppo saranno visualizzati nel gruppo predefinito, identificabile dall'etichetta di intestazione "DefaultGroup{0}". Il gruppo predefinito non è contenuto nell'insieme ListView.Groups e non può essere alterato. È utile principalmente nelle operazioni di debug per assicurare che tutti gli elementi siano stati aggiunti correttamente ai gruppi.

Un elemento può essere presente in un solo gruppo alla volta. È possibile cambiare il gruppo di appartenenza di un elemento impostando la proprietà ListViewItem.Group in fase di esecuzione o aggiungendolo all'insieme Items di un altro gruppo, rimuovendolo quindi automaticamente dal gruppo precedente.

NotaNota:

La funzionalità del segno di inserimento è disattivata quando si utilizzano i gruppi. Con la funzionalità di raggruppamento, infatti, gli elementi vengono ordinati per appartenenza al gruppo, mentre la funzionalità del segno di inserimento viene utilizzata per riposizionare gli elementi tramite trascinamento in un controllo ListView nel quale non sono ancora ordinati.

NotaNota:

I gruppi ListView sono disponibili soltanto in Windows XP e nella famiglia Windows Server 2003 quando il metodo Application.EnableVisualStyles viene chiamato dall'applicazione. Nei sistemi operativi precedenti, il codice che fa riferimento ai gruppi verrà ignorato e i gruppi non saranno visualizzati. Di conseguenza il codice che dipende dalla funzionalità di raggruppamento potrebbe non funzionare correttamente. È opportuno includere un test per stabilire se la funzionalità di raggruppamento è disponibile e, in caso contrario, fornire una funzionalità alternativa. Se si utilizzano sistemi operativi che non supportano l'ordinamento per gruppo è opportuno, ad esempio, fornire un ordinamento alternativo.

La funzionalità del segno di inserimento è disponibile nella stessa libreria che fornisce le funzionalità dei temi del sistema operativo. Per controllare la disponibilità di tale libreria, chiamare l'overload del metodo FeatureSupport.IsPresent(Object) e passare il valore di OSFeature.Themes.

Nell'esempio di codice riportato di seguito viene illustrato come utilizzare la funzionalità di raggruppamento ListView per organizzare gli elementi per valore di elemento secondario nella visualizzazione Dettagli. Questa forma di raggruppamento è analoga al raggruppamento utilizzato in Esplora risorse. Nell'esempio, i gruppi vengono creati dinamicamente. Per ogni colonna di elementi secondari, viene creato un gruppo per ogni valore di elemento secondario univoco. Per la colonna dell'elemento padre, viene creato un gruppo per ogni lettera iniziale univoca. La selezione dell'intestazione di una colonna consente di ordinare gli elementi nei gruppi creati per tale colonna. Una successiva selezione della stessa intestazione di colonna inverte l'ordine dei gruppi.

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

}

import System.*;
import System.Collections.*;
import System.Windows.Forms.*;

public class ListViewGroupsExample extends Form
{
    private ListView myListView;
    private boolean isRunningXPOrLater = false;

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

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

    public ListViewGroupsExample()
    {
        // Initialize myListView.
        myListView = new ListView();
        myListView.set_Dock(DockStyle.Fill);
        myListView.set_View(View.Details);
        myListView.set_Sorting(SortOrder.Ascending);
        // Create and initialize column headers for myListView.
        ColumnHeader columnHeader0 = new ColumnHeader();
        columnHeader0.set_Text("Title");
        columnHeader0.set_Width(-1);
        ColumnHeader columnHeader1 = new ColumnHeader();
        columnHeader1.set_Text("Author");
        columnHeader1.set_Width(-1);
        ColumnHeader columnHeader2 = new ColumnHeader();
        columnHeader2.set_Text("Year");
        columnHeader2.set_Width(-1);
        // Add the column headers to myListView.
        myListView.get_Columns().AddRange(new ColumnHeader[] { 
            columnHeader0, columnHeader1, columnHeader2 });
        // Add a handler for the ColumnClick event.
        myListView.add_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.get_Items().AddRange(new ListViewItem[] { 
            item0, item1, item2, item3, item4, item5 });
        // Determine whether Windows XP or a later 
        // operating system is present.
        if (System.Environment.get_OSVersion().get_Version().get_Major() > 5 
            || (System.Environment.get_OSVersion().get_Version().get_Major() 
            == 5 && System.Environment.get_OSVersion().get_Version().get_Minor() 
            >= 1)) {
            isRunningXPOrLater = true;
        }

        if (isRunningXPOrLater) {
            // Create the groupsTable array and populate it with one 
            // hash table for each column.
            groupTables = new Hashtable[myListView.get_Columns().get_Count()];
            for (int column = 0; column < myListView.get_Columns().get_Count(); 
                column++) {
                // Create a hash table containing all the groups 
                // needed for a single column.
                groupTables.set_Item(column, CreateGroupsTable(column));
            }
            // Start with the groups created for the Title column.
            SetGroups(0);
        }
        // Initialize the form.
        this.get_Controls().Add(myListView);
        this.set_Size(new System.Drawing.Size(550, 330));
        this.set_Text("ListView Groups Example");
    } //ListViewGroupsExample

    /** @attribute STAThread()
     */
    public static void main(String[] args)
    {
        Application.Run(new ListViewGroupsExample());
    } //main

    // 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.get_Sorting().Equals(SortOrder.Descending) 
            || (isRunningXPOrLater && e.get_Column() != groupColumn)) {
            myListView.set_Sorting(SortOrder.Ascending);
        }
        else {
            myListView.set_Sorting(SortOrder.Descending);
        }
        groupColumn = e.get_Column();
        // Set the groups to those created for the clicked column.
        if (isRunningXPOrLater)
        {
            SetGroups(e.get_Column());
        }
    } //myListView_ColumnClick

    // Sets myListView to the groups created for the specified column.
    private void SetGroups(int column)
    {
        // Remove the current groups.
        myListView.get_Groups().Clear();
        // Retrieve the hash table corresponding to the column.
        Hashtable groups = (Hashtable)groupTables.get_Item(column);
        // Iterate through the items in myListView, assigning each 
        // one to the appropriate group.
        for (int iCtr = 0; iCtr < myListView.get_Items().get_Count(); iCtr++) {
            ListViewItem item = myListView.get_Items().get_Item(iCtr);
            // Retrieve the subitem text corresponding to the column.
            String subItemText = item.get_SubItems().get_Item(column).get_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.set_Group((ListViewGroup)(groups.get_Item(subItemText)));
        }
        // Copy the groups for the column to an array.
        ListViewGroup groupsArray[] = new ListViewGroup[groups.get_Count()];
        groups.get_Values().CopyTo(groupsArray, 0);
        // Sort the groups and add them to myListView.
        Array.Sort(groupsArray, new ListViewGroupSorter(
            myListView.get_Sorting()));
        myListView.get_Groups().AddRange(groupsArray);
    } //SetGroups

    // 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.
        for (int iCtr = 0; iCtr < myListView.get_Items().get_Count(); iCtr++) {
            ListViewItem item = myListView.get_Items().get_Item(iCtr);
            // Retrieve the text value for the column.
            String subItemText = item.get_SubItems().get_Item(column).get_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;
    } //CreateGroupsTable

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

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

        // 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).get_Header(), 
                ((ListViewGroup)y).get_Header());
            if (order.Equals(SortOrder.Ascending)) {
                return result;
            }
            else {
                return -result;
            }
        } //Compare
    } //ListViewGroupSorter
} //ListViewGroupsExample 

System.Object
  System.Windows.Forms.ListViewGroup

I membri statici pubblici (Shared in Visual Basic) di questo tipo sono validi per le operazioni multithreading. I membri di istanza non sono garantiti come thread safe.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile per Pocket PC, Windows Mobile per Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 è supportato in Windows Vista, Microsoft Windows XP SP2 e Windows Server 2003 SP1.

.NET Framework

Supportato in:

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2015 Microsoft