ListViewGroupCollection Classe

Definição

Namespace:

System.Windows.Forms

Assembly:

System.Windows.Forms.dll

Origem:

ListViewGroupCollection.cs

Representa a coleção de grupos em um controle ListView.

[System.ComponentModel.ListBindable(false)]
public class ListViewGroupCollection : System.Collections.IList

Herança

Object

ListViewGroupCollection

Atributos

ListBindableAttribute

Implementações

ICollection IEnumerable IList

Exemplos

O exemplo a seguir demonstra como usar o ListView recurso de agrupamento para organizar itens por valor subitem na exibição de detalhes. Essa forma de agrupamento é semelhante ao agrupamento usado no Windows Explorer. No exemplo, os grupos são criados dinamicamente. Para cada coluna de subitem, um grupo é criado para cada valor de subitem exclusivo. Para a coluna de item pai, um grupo é criado para cada letra inicial exclusiva. Clicar no cabeçalho de uma coluna classifica os itens nos grupos criados para essa coluna. Clicar no mesmo cabeçalho de coluna novamente inverte a ordem dos grupos.

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

Comentários

Use a ListView.Groups propriedade para obter o associado a ListViewGroupCollection um ListView controle . Essa coleção contém os ListViewGroup objetos que representam os grupos mostrados no controle quando a ListView.View propriedade é definida como um valor diferente de View.List. Todos os itens que não são atribuídos a um grupo serão exibidos no grupo padrão, que tem o rótulo de cabeçalho "DefaultGroup{0}". O grupo padrão não está contido na ListView.Groups coleção e não pode ser alterado. É útil principalmente na depuração para garantir que todos os itens tenham sido adicionados corretamente aos grupos. Se não houver grupos na ListView.Groups coleção, o recurso de agrupamento será desabilitado.

Use o Add método para adicionar um único grupo à coleção. Use o Insert método para adicionar um grupo a um índice específico dentro da coleção. Para remover um grupo, use o Remove método . Use o RemoveAt método para remover o grupo em um índice específico.

Não é possível adicionar um ListViewGroup à coleção mais de uma vez. Para reposicionar um grupo dentro da coleção, ele deve primeiro ser removido da coleção e, em seguida, inserido no local desejado. Use o Contains método para determinar se um grupo específico já está na coleção. Para recuperar o índice de um grupo dentro da coleção, use o IndexOf método . Você pode obter ou definir o grupo em um índice específico com o Item[] indexador.

Use o AddRange método para adicionar vários grupos à coleção. Você pode adicionar vários grupos como uma matriz de grupos ou como um ListViewGroupCollection que você recupera por meio da ListView.Groups propriedade de outro ListView controle. Use o Clear método para remover todos os grupos da coleção.

Observação

Os Removemétodos , RemoveAte Clear removem grupos da coleção, mas não removem nenhum item do ListView controle. Se não houver grupos na ListView.Groups coleção, o recurso de agrupamento será desabilitado e todos os itens no controle serão exibidos normalmente.

Os AddRange métodos e Clear são úteis quando você deseja fornecer várias maneiras de agrupar os itens em um ListView controle . Para fazer isso, crie várias matrizes de grupo. Para alterar o agrupamento, primeiro use o Clear método para remover todos os grupos da coleção e, em seguida, use o AddRange método para adicionar a próxima matriz de grupos a ser exibida.

Use o CopyTo método para copiar os grupos em uma coleção para uma matriz compatível começando em um índice especificado. Isso é útil, por exemplo, quando você deseja classificar os grupos na coleção usando o Array.Sort método . Para fazer isso, copie os grupos em uma matriz compatível e, em seguida, classifique a matriz. Em seguida, use o Clear método para remover todos os grupos da coleção e, em seguida, use o AddRange método para adicionar a matriz classificada de volta à coleção.

Use a Count propriedade para determinar quantos grupos estão na coleção. Para iterar pela coleção, use o IEnumerator retornado do GetEnumerator método .

Observação

O recurso de agrupamento está disponível somente no Windows XP e na família Windows Server 2003 quando seu aplicativo chama o Application.EnableVisualStyles método . Em sistemas operacionais anteriores, qualquer código relacionado a grupos será ignorado e os grupos não serão exibidos. Como resultado, qualquer código que dependa do recurso de agrupamento pode não funcionar corretamente. Talvez você queira incluir um teste que determine se o recurso de agrupamento está disponível e fornecer funcionalidade alternativa quando ele não estiver disponível. Por exemplo, talvez você queira fornecer classificação alternativa ao executar em sistemas operacionais que não dão suporte à classificação por grupo.

O recurso de marca de inserção é fornecido pela mesma biblioteca que fornece o recurso de temas do sistema operacional. Para marcar para a disponibilidade dessa biblioteca, chame a sobrecarga do FeatureSupport.IsPresent(Object) método e passe o OSFeature.Themes valor.

Propriedades

Count	Obtém o número de grupos na coleção.
Item[Int32]	Obtém ou define o ListViewGroup no índice especificado na coleção.
Item[String]	Obtém ou define o ListViewGroup com o valor da propriedade Name especificado.

Métodos

Add(ListViewGroup)	Adiciona o ListViewGroup especificado à coleção.
Add(String, String)	Adiciona um novo ListViewGroup à coleção usando os valores especificados para inicializar as propriedades Name e Header.
AddRange(ListViewGroup[])	Adiciona uma matriz de grupos à coleção.
AddRange(ListViewGroupCollection)	Adiciona os grupos em um ListViewGroupCollection existente à coleção.
Clear()	Remove todos os grupos da coleção.
Contains(ListViewGroup)	Determina se o grupo especificado está localizado na coleção.
CopyTo(Array, Int32)	Copia os grupos na coleção para uma Array unidimensional compatível, começando no índice especificado da matriz de destino.
GetEnumerator()	Retorna um enumerador usado para iterar por meio da coleção.
IndexOf(ListViewGroup)	Retorna o índice do ListViewGroup especificado na coleção.
Insert(Int32, ListViewGroup)	Insere o ListViewGroup especificado na coleção no índice especificado.
Remove(ListViewGroup)	Remove o ListViewGroup especificado da coleção.
RemoveAt(Int32)	Remove o ListViewGroup no índice especificado da coleção.

Implantações explícitas de interface

ICollection.IsSynchronized	Obtém um valor que indica se o acesso à coleção é sincronizado (thread-safe).
ICollection.SyncRoot	Obtém um objeto que pode ser usado para sincronizar o acesso à coleção.
IList.Add(Object)	Adiciona um novo ListViewGroup ao ListViewGroupCollection.
IList.Contains(Object)	Determina se o valor especificado está localizado na coleção.
IList.IndexOf(Object)	Retorna o índice na coleção do valor especificado.
IList.Insert(Int32, Object)	Insere um ListViewGroup no ListViewGroupCollection.
IList.IsFixedSize	Obtém um valor que indica se a coleção tem um tamanho fixo.
IList.IsReadOnly	Obtém um valor que indica se a coleção é somente leitura.
IList.Item[Int32]	Obtém ou define o ListViewGroup no índice especificado na coleção.
IList.Remove(Object)	Remove o ListViewGroup do ListViewGroupCollection.

Métodos de Extensão

Aplica-se a

Confira também

• ListView
• ListViewGroup