Práticas recomendadas para colocação em escala do controle DataGridView dos Windows Forms

  • Artigo

O DataGridView controle é projetado para fornecer escalabilidade máxima. Se você precisa exibir grandes quantidades de dados, siga as diretrizes descritas neste tópico para evitar o consumo de grandes quantidades de memória ou prejudicar a capacidade de resposta da UI (interface do usuário). Este tópico discute os seguintes problemas:

  • Usando estilos de célula com eficiência

  • Usando menus de atalho com eficiência

  • Usando o redimensionamento automático com eficiência

  • Usando as coleções de células, linhas e colunas selecionadas com eficiência

  • Usando linhas compartilhadas

  • Impedindo as linhas de se tornarem não compartilhadas

Se você tiver necessidades de desempenho especiais, implemente o modo virtual e forneça suas próprias operações de gerenciamento de dados. Para obter mais informações, consulte Modos de exibição dos dados no controle DataGridView dos Windows Forms.

Usando Estilos de Célula com Eficiência

Cada célula, linha e coluna pode ter suas próprias informações de estilo. As informações de estilo são armazenadas em DataGridViewCellStyle objetos. Criar objetos de estilo de célula para muitos elementos individuais DataGridView pode ser ineficiente, especialmente ao trabalhar com grandes quantidades de dados. Para evitar um impacto no desempenho, use as seguintes diretrizes:

Usando Menus de Atalho com Eficiência

Cada célula, linha e coluna pode ter seu próprio menu de atalho. Os menus de DataGridView atalho no controle são representados por ContextMenuStrip controles. Assim como acontece com objetos de estilo de célula, a criação de menus de atalho para muitos elementos individuais DataGridView afetará negativamente o desempenho. Para evitar essa penalidade, use as seguintes diretrizes:

  • Evite criar menus de atalho para células e linhas individuais. Isso inclui o modelo de linha, que é clonado juntamente com o menu de atalho quando novas linhas são adicionadas ao controle. Para obter escalabilidade máxima, use apenas a propriedade do controle para especificar um único menu de ContextMenuStrip atalho para todo o controle.

  • Se você precisar de vários menus de atalho para várias linhas ou células, manipule os CellContextMenuStripNeeded eventos ou RowContextMenuStripNeeded . Esses eventos permitem gerenciar os objetos do menu de atalho por conta própria, possibilitando ajustar o desempenho.

Usando o Redimensionamento Automático com Eficiência

Cabeçalhos, colunas e linhas podem ser redimensionados automaticamente como alterações de conteúdo da célula para que todo o conteúdo das células seja exibido sem recorte. Alterar os modos de dimensionamento também pode redimensionar linhas, colunas e cabeçalhos. Para determinar o tamanho correto, o controle deve examinar o DataGridView valor de cada célula que ele deve acomodar. Ao trabalhar com grandes conjuntos de dados, essa análise poderá afetar negativamente o desempenho do controle quando o redimensionamento automático ocorrer. Para evitar penalidades de desempenho, use as seguintes diretrizes:

Para obter mais informações, consulte Sizing Options in the Windows Forms DataGridView Control (Opções de dimensionamento no controle DataGridView dos Windows Forms).

Usando as Coleções de Células, Linhas e Colunas Selecionadas com Eficiência

A SelectedCells coleção não funciona de forma eficiente com grandes seleções. As SelectedRows coleções e também podem ser ineficientes, embora em menor grau porque há muito menos linhas do que células em um controle típico DataGridView e SelectedColumns muito menos colunas do que linhas. Para evitar penalidades de desempenho ao trabalhar com essas coleções, use as seguintes diretrizes:

Usando Linhas Compartilhadas

O uso eficiente de memória é obtido no controle por meio de DataGridView linhas compartilhadas. As linhas compartilharão o máximo possível de informações sobre sua aparência e comportamento compartilhando instâncias da DataGridViewRow classe.

Embora o compartilhamento de instâncias de linha poupe memória, as linhas podem facilmente se tornar não compartilhadas. Por exemplo, sempre que um usuário interage diretamente com uma célula, sua linha se torna não compartilhada. Como isso não pode ser evitado, as diretrizes neste tópico são úteis somente ao trabalhar com grandes quantidades de dados e somente quando os usuários forem interagir com uma parte relativamente pequena dos dados sempre que o programa for executado.

Uma linha não pode ser compartilhada em um controle não acoplado DataGridView se qualquer uma de suas células contiver valores. Quando o controle é vinculado a uma fonte de dados externa ou quando você implementa o DataGridView modo virtual e fornece sua própria fonte de dados, os valores de célula são armazenados fora do controle em vez de em objetos de célula, permitindo que as linhas sejam compartilhadas.

Um objeto de linha poderá ser compartilhado apenas se o estado de todas as suas células puder ser determinado por meio do estado da linha e dos estados das colunas que contêm as células. Se você alterar o estado de uma célula para que ela não possa mais ser deduzida por meio do estado de sua linha e coluna, a linha não poderá ser compartilhada.

Por exemplo, uma linha não pode ser compartilhada em nenhuma das seguintes situações:

No modo acoplado ou no modo virtual, você pode fornecer dicas de ferramentas e menus de atalho para células individuais manipulando os CellToolTipTextNeeded eventos e CellContextMenuStripNeeded .

O DataGridView controle tentará usar automaticamente linhas compartilhadas sempre que linhas forem adicionadas ao DataGridViewRowCollection. Use as diretrizes a seguir para garantir que as linhas sejam compartilhadas:

Para determinar se uma linha é compartilhada, use o método para recuperar o DataGridViewRowCollection.SharedRow objeto de linha e, em seguida, verifique a propriedade do Index objeto. As linhas compartilhadas sempre têm um Index valor de propriedade de –1.

Impedindo as Linhas de se Tornarem Não Compartilhadas

As linhas compartilhadas podem se tornar não compartilhadas como resultado da ação de usuário ou de código. Para evitar um impacto no desempenho, evite fazer com que as linhas se tornem não compartilhadas. Durante o desenvolvimento do aplicativo, você pode manipular o RowUnshared evento para determinar quando as linhas não são compartilhadas. Isso é útil ao depurar problemas de compartilhamento de linhas.

Para impedir que as linhas se tornem não compartilhadas, use as seguintes diretrizes:

  • Evite indexar a Rows coleção ou iterá-la com um foreach loop. Normalmente não será necessário acessar as linhas diretamente. DataGridView Os métodos que operam em linhas usam argumentos de índice de linha em vez de instâncias de linha. Além disso, os manipuladores de eventos relacionados à linha recebem objetos de argumento de evento com propriedades de linha que você pode usar para manipular linhas sem fazer com que elas se tornem não compartilhadas.

  • Se você precisar acessar um objeto de linha, use o método e passe o DataGridViewRowCollection.SharedRow índice real da linha. Observe, entretanto, que modificar um objeto de linha compartilhada recuperado por esse método modificará todas as linhas que compartilham esse objeto. A linha para novos registros não é compartilhada com outras linhas, no entanto, ela não será afetada quando você modificar qualquer outra linha. Observe também que diferentes linhas representadas por uma linha compartilhada podem ter menus de atalho diferentes. Para recuperar o menu de atalho correto de uma instância de linha compartilhada, use o método e passe o GetContextMenuStrip índice real da linha. Se você acessar a propriedade da ContextMenuStrip linha compartilhada, ela usará o índice de linha compartilhada de -1 e não recuperará o menu de atalho correto.

  • Evite indexar a DataGridViewRow.Cells coleção. Acessar uma célula diretamente fará com que sua linha pai não seja compartilhada, instanciando um novo DataGridViewRowarquivo . Manipuladores de eventos relacionados à célula recebem objetos de argumento de evento com propriedades de célula que você pode usar para manipular células sem fazer com que as linhas se tornem não compartilhadas. Você também pode usar a propriedade para recuperar os índices de linha e coluna da célula atual sem acessar a CurrentCellAddress célula diretamente.

  • Evite modos de seleção com base em célula. Esses modos fazem com que as linhas se tornem não compartilhadas. Em vez disso, defina a DataGridView.SelectionMode propriedade como DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.

  • Não manipule os DataGridViewRowCollection.CollectionChanged eventos ou DataGridView.RowStateChanged . Esses eventos fazem com que as linhas se tornem não compartilhadas. Além disso, não chame os DataGridViewRowCollection.OnCollectionChanged métodos ou DataGridView.OnRowStateChanged que geram esses eventos.

  • Não acesse a DataGridView.SelectedCells coleção quando o valor da DataGridView.SelectionMode propriedade for FullColumnSelect, , ColumnHeaderSelectFullRowSelectou RowHeaderSelect. Isso faz com que todas as linhas selecionadas se tornem não compartilhadas.

  • Não chame o DataGridView.AreAllCellsSelected método. Esse método pode fazer com que as linhas se tornem não compartilhadas.

  • Não chame o método quando o DataGridView.SelectAll valor da DataGridView.SelectionMode propriedade for CellSelect. Isso faz com que todas as linhas se tornem não compartilhadas.

  • Não defina a propriedade ou de uma célula como quando a ReadOnly propriedade correspondente em sua coluna estiver definida como falsetrue.Selected Isso faz com que todas as linhas se tornem não compartilhadas.

  • Não acesse a DataGridViewRowCollection.List propriedade. Isso faz com que todas as linhas se tornem não compartilhadas.

  • Não chame a Sort(IComparer) sobrecarga do Sort método. Classificar com um comparador personalizado faz com que todas as linhas se tornem não compartilhadas.

Confira também