As práticas recomendadas para escala o controle DataGridView do Windows Forms

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 que é clonada a partir do 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, defina a 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 definir diretamente de propriedades do tipo DataGridViewCellStyle em colunas, linhas e células individuais. 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 a CellFormatting manipulador de eventos. Para um exemplo, consulte Como: personalizar a formatação de dados no controle do Windows Forms DataGridView.

• 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.

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 muitas DataGridView elementos afetará negativamente o 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, que é clonado juntamente com 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 todo o controle.

• 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 você mesmo, permitindo que você ajustar o desempenho.

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 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 do DataGridViewAutoSizeRowsMode, DataGridViewAutoSizeColumnsMode, e DataGridViewAutoSizeColumnMode enumerações.

  • Para cabeçalhos de linha, use o AutoSizeToDisplayedHeaders ou AutoSizeToFirstHeader campo do 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..

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 muitos menos colunas que linhas e controle. 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. Entretanto, 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 selecionadas. 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 as coleções de linha e coluna selecionadas.

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

Uso eficiente de memória é alcançado na DataGridView controle por meio de linhas compartilhadas. Linhas irão compartilhar o máximo possível de informações sobre sua aparência e comportamento 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, a sua linha fica não compartilhada. Porque isso não pode 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 de dados cada vez que o programa é executado.

Uma linha não pode ser compartilhada em um não acoplado DataGridView controlar se qualquer uma das suas células contiverem valores. Quando o DataGridView controle está vinculado a uma fonte de dados externos ou quando você implementa modo virtual e fornece sua própria fonte de dados, os valores de célula são armazenados fora do controle, em vez de 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 o conjunto de propriedades.

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

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 à 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 da Insert método da 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 da 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 da 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 o objeto Index propriedade. Linhas compartilhadas sempre tem um Index valor da propriedade de – 1.

Linhas compartilhadas podem se tornar não compartilhadas como resultado de uma ação do usuário ou 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 tornam-se não compartilhadas. 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 dele com um foreach loop. Você não normalmente precisarão acessar linhas diretamente. DataGridView métodos que operam em linhas levar argumentos de índice de linha em vez de instâncias de linha. Além disso, os manipuladores para eventos relacionados a linha exibida 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 a índice real da linha. Observe, Entretanto, modificando um objeto de linha compartilhada recuperado através 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, para que ele não será afetado 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 a índice real da 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 em 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 tratam o DataGridViewRowCollection.CollectionChanged ou DataGridView.RowStateChanged eventos. Esses eventos causam linhas para se tornar não compartilhado. Além disso, não chame o DataGridViewRowCollection.OnCollectionChanged ou DataGridView.OnRowStateChanged os métodos que elevar esses eventos.

• Do not access the DataGridView.SelectedCells collection when the DataGridView.SelectionMode property value is FullColumnSelect, ColumnHeaderSelect, FullRowSelect, or 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.

Tarefas

Referência

Conceitos

Outros recursos