Práticas recomendadas para escala o controle DataGridView do Windows Forms

O DataGridView controle foi projetado para fornecer escalabilidade máxima. Se você precisar exibir grandes quantidades de dados, você deve seguir as diretrizes descritas neste tópico para evitar consumindo grandes quantidades de memória ou afetar a capacidade de resposta da interface do usuário (UI). 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 conjuntos de células, linhas e colunas selecionados com eficiência

• Usando linhas compartilhadas

• Impedindo que linhas se tornando descompartilhado.

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

Usando estilos de célula com eficiência

Cada célula, linha e coluna podem ter suas próprias informações de estilo. Informações de estilo são armazenadas em DataGridViewCellStyle objetos. Criando objetos de estilo de célula para muitos indivíduo DataGridView elementos podem ser ineficientes, especialmente quando se trabalha com grandes quantidades de dados. Para evitar um impacto no desempenho, use as seguintes diretrizes:

• Evite definir propriedades de estilo de célula para o indivíduo DataGridViewCell ou DataGridViewRow objetos. Isso inclui o objeto de linha especificado pelo RowTemplate propriedade. Cada nova linha a ser clonada de modelo de linha receberá sua própria cópia do objeto de estilo de célula do modelo. Para obter escalabilidade máxima, definir propriedades de estilo de célula na DataGridView nível. Por exemplo, definir o DataGridView.DefaultCellStyle propriedade em vez de DataGridViewCell.Style propriedade.

• Se algumas células precisam formatação diferente formatação padrão, use o mesmo DataGridViewCellStyle instância entre grupos de células, linhas ou colunas. Evite diretamente configurar propriedades do tipo DataGridViewCellStyle em células individuais, linhas e colunas. Para obter um exemplo de compartilhamento de estilo de célula, consulte Como: Definir estilos de célula padrão para o controle DataGridView do Windows Forms. Você também pode evitar uma penalidade de desempenho ao definir estilos de célula individualmente pelo tratamento de CellFormatting manipulador de eventos. Para um exemplo, consulte Como: Personalizar a formatação de dados no Windows Forms DataGridView Control.

• Ao determinar o estilo de uma célula, use o DataGridViewCell.InheritedStyle propriedade em vez de DataGridViewCell.Style propriedade. Acessando o Style propriedade cria uma nova instância da DataGridViewCellStyle classe se a propriedade já não tiver sido usada. Além disso, esse objeto pode não conter as informações de estilo completo para a célula se alguns estilos são herdados da linha, coluna ou controle. Para obter mais informações sobre herança de estilo de célula, consulte Estilos de célula em que o controle DataGridView do Windows Forms.

Usando Menus de atalho com eficiência

Cada célula, linha e coluna podem ter seu próprio menu de atalho. Menus de atalho do DataGridView 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 o indivíduo muitos DataGridView elementos terão impacto negativo sobre desempenho. Para evitar essa penalidade, use as seguintes diretrizes:

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

• Se você precisar vários menus de atalho para várias linhas ou células, lidar com o CellContextMenuStripNeeded ou RowContextMenuStripNeeded eventos. Esses eventos permitem que você a gerenciar os objetos do menu de atalho sozinho, permitindo que você ajustar o desempenho.

Usando o redimensionamento automático com eficiência

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

• Evite usar o dimensionamento automático em um DataGridView o controle com um grande conjunto de linhas. Se você usar o dimensionamento automático, somente o redimensionamento baseado nas linhas exibidas. Use somente as linhas exibidas no modo virtual, também.

  • Para linhas e colunas, use o DisplayedCells ou DisplayedCellsExceptHeaders campo de DataGridViewAutoSizeRowsMode, DataGridViewAutoSizeColumnsMode, e DataGridViewAutoSizeColumnMode enumerações.

  • Para cabeçalhos de linha, use o AutoSizeToDisplayedHeaders ou AutoSizeToFirstHeader campo de DataGridViewRowHeadersWidthSizeMode enumeração.

• Para máxima escalabilidade, desative o dimensionamento automático e redimensionamento através de programação.

Para obter mais informações, consulte Opções de controle do Windows Forms DataGridView de dimensionamento..

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

O SelectedCells coleção não executa com eficiência com grandes seleções. O SelectedRows e SelectedColumns coleções também podem ser ineficientes, embora em menor grau porque há muitos menos linhas de células em um típico DataGridView controle e muitos menos colunas de linhas. Para evitar penalidades de desempenho ao trabalhar com essas coleções, use as seguintes diretrizes:

• Para determinar se todas as células a DataGridView foram selecionadas antes de acessar o conteúdo da SelectedCells coleção, verifique o valor de retorno a AreAllCellsSelected método. No entanto, observe que esse método pode causar linhas para se tornar não compartilhado. Para mais informações, veja a próxima seção.

• Evite usar o Count propriedade da System.Windows.Forms.DataGridViewSelectedCellCollection para determinar o número de células selecionado. Em vez disso, use o DataGridView.GetCellCount método e passar o DataGridViewElementStates.Selected valor. Da mesma forma, use o DataGridViewRowCollection.GetRowCount e DataGridViewColumnCollection.GetColumnCount métodos para determinar o número de elementos selecionados, em vez de acessar o selecionado linha e coluna coleções.

• Evite os modos de seleção baseada na célula. Em vez disso, defina a DataGridView.SelectionMode propriedade para DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.

Usar linhas de compartilhado

Uso eficiente de memória é alcançado na DataGridView controle através de linhas compartilhadas. Linhas irão compartilhar tantas informações sobre sua aparência e comportamento possível pelo compartilhamento de instâncias da DataGridViewRow classe.

Enquanto compartilhamento linha instâncias salva memória, linhas podem facilmente se tornar não compartilhadas. Por exemplo, sempre que um usuário interage diretamente com uma célula, linha fica não compartilhada. Porque não podem ser evitado, as diretrizes neste tópico são úteis somente quando estiver trabalhando com grandes quantidades de dados e somente quando os usuários irão interagir com uma parte relativamente pequena dos dados de cada vez que o programa é executado.

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

Um objeto de linha só pode ser compartilhado, se o estado de todas as suas células pode ser determinado a partir do estado da linha e os estados das colunas que contêm as células. Se você alterar o estado de uma célula para que ela não pode ser deduzida do estado de sua linha e coluna, a linha não pode ser compartilhada.

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

• A linha contém uma única célula selecionada que não esteja em uma coluna selecionada.

• A linha contiver uma célula com seu ToolTipText ou ContextMenuStrip conjunto de propriedades.

• A linha contém um DataGridViewComboBoxCell com sua Items conjunto de propriedade.

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

O DataGridView controle automaticamente tentará usar linhas compartilhadas sempre que as linhas são adicionadas para o DataGridViewRowCollection. Use as seguintes diretrizes para garantir que as linhas são compartilhadas:

• Evitar a chamada a Add(Object[]) de sobrecarga da Add método e o Insert(Object[]) de sobrecarga do Insert método do DataGridView.Rows coleção. Essas sobrecargas criam automaticamente as linhas não compartilhadas.

• Ter certeza de que a linha especificada na DataGridView.RowTemplate propriedade pode ser compartilhada nos seguintes casos:

  • Ao chamar o Add() ou Add(Int32) sobrecargas da Add método ou a Insert(Int32,Int32) de sobrecarga da Insert método da DataGridView.Rows coleção.

  • Ao aumentar o valor de DataGridView.RowCount propriedade.

  • Ao definir o DataGridView.DataSource propriedade.

• Ter certeza de que a linha indicada pelo indexSource parâmetro pode ser compartilhado ao chamar o AddCopy, AddCopies, InsertCopy, e InsertCopies métodos para o DataGridView.Rows coleção.

• Certifique-se de que a linha ou linhas especificadas podem ser compartilhadas ao chamar o Add(DataGridViewRow) de sobrecarga da Add método, o AddRange método, o Insert(Int32,DataGridViewRow) de sobrecarga da Insert método e o InsertRange método do DataGridView.Rows coleção.

Para determinar se uma linha é compartilhada, use o DataGridViewRowCollection.SharedRow método para recuperar o objeto de linha e, em seguida, verifique se o objeto Index propriedade. Linhas compartilhadas sempre tem um Index valor da propriedade de – 1.

Impedindo que linhas se tornando descompartilhado.

Linhas compartilhadas podem se tornar não compartilhadas, como resultado de uma ação do usuário ou de código. Para evitar um impacto no desempenho, você deve evitar causando linhas para se tornar não compartilhado. Durante o desenvolvimento de aplicativo, você pode manipular o RowUnshared evento para determinar quando linhas são descompartilhadas. Isso é útil ao depurar problemas de compartilhamento de linha.

Para impedir que linhas se tornando descompartilhado, use as seguintes diretrizes:

• Evitar a indexação de Rows coleção ou iterar através dela com um foreach loop. Você não normalmente precisarão acessar linhas diretamente. DataGridViewos métodos que operam em linhas levar 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 fazendo com que eles se tornem não compartilhado.

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

• Evitar a indexação de DataGridViewRow.Cells coleção. Acessando uma célula diretamente fará com que sua linha pai para se tornar não compartilhado, instanciar uma nova DataGridViewRow. Manipuladores de eventos relacionados à célula recebem os objetos de argumento de evento com propriedades da célula que você pode usar para manipular as células sem causar linhas para se tornar não compartilhado. Você também pode usar o CurrentCellAddress propriedade para recuperar os índices de linha e coluna da célula atual sem acessar a célula diretamente.

• Evite os modos de seleção baseada na célula. Esses modos causam linhas para se tornar não compartilhado. Em vez disso, defina a DataGridView.SelectionMode propriedade para DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.

• Não manipulam o DataGridViewRowCollection.CollectionChanged ou DataGridView.RowStateChanged eventos. Esses eventos causam linhas para se tornar não compartilhado. Além disso, não chamar o DataGridViewRowCollection.OnCollectionChanged ou DataGridView.OnRowStateChanged métodos, que disparam esses eventos.

• Não acesse o DataGridView.SelectedCells coleção quando a DataGridView.SelectionMode valor da propriedade é FullColumnSelect, ColumnHeaderSelect, FullRowSelect, ou RowHeaderSelect. Isso faz com que todas as linhas selecionadas para se tornar não compartilhado.

• Não chame o DataGridView.AreAllCellsSelected método. Esse método pode causar linhas para se tornar não compartilhado.

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

• Não defina a ReadOnly ou Selected a propriedade de uma célula para false quando a propriedade correspondente na sua coluna é definida como true. Isso faz com que todas as linhas para se tornar não compartilhado.

• Não acesse o DataGridViewRowCollection.List propriedade. Isso faz com que todas as linhas para se tornar não compartilhado.

• Não chame o Sort(IComparer) de sobrecarga da Sort método. Classificação com um comparador personalizado faz com que todas as linhas para se tornar não compartilhado.

Consulte também

Tarefas

Como: Definir estilos de célula padrão para o controle DataGridView do Windows Forms

Referência

DataGridView

Conceitos

Modo virtual no Windows Forms DataGridView Control

Modos de exibição de dados no controle DataGridView do Windows Forms

Estilos de célula em que o controle DataGridView do Windows Forms

Opções de controle do Windows Forms DataGridView de dimensionamento.

Outros recursos

O controle DataGridView do Windows Forms de ajuste de desempenho