1 特性综览(Overview of features)
1.1 样式(Styling)
DataGridView使得定义单元格的基本外观和格式化单元格显示变得简单。You can define appearance and formatting styles for individual cells, for cells in specific columns and rows, or for all cells in the control by setting the properties of the DataGridViewCellStyle objects accessed through various DataGridView control properties. Additionally, you can modify these styles dynamically based on factors such as the cell value by handling the CellFormatting event.
Each cell within the DataGridView control can have its own style, such as text format, background color, foreground color, and font. Typically, however, multiple cells will share particular style characteristics.
Groups of cells that share styles may include all cells within particular rows or columns, all cells that contain particular values, or all cells in the control. Because these groups overlap, each cell may get its styling information from more than one place. For example, you may want every cell in a DataGridView control to use the same font, but only cells in currency columns to use currency format, and only currency cells with negative numbers to use a red foreground color.
1.1.1 The DataGridViewCellStyle Class
The DataGridViewCellStyle class contains the following properties related to visual style:
BackColor and ForeColor, SelectionBackColor and SelectionForeColor, Font
This class also contains the following properties related to formatting:
Format and FormatProvider, NullValue and DataSourceNullValue, WrapMode, Alignment, Padding
1.1.2 Using DataGridViewCellStyle Objects
You can retrieve DataGridViewCellStyle objects from various properties of the DataGridView, DataGridViewColumn, DataGridViewRow, and DataGridViewCell classes and their derived classes. If one of these properties has not yet been set, retrieving its value will create a new DataGridViewCellStyle object. You can also instantiate your own DataGridViewCellStyle objects and assign them to these properties.
You can avoid unnecessary duplication of style information by sharing DataGridViewCellStyle objects among multiple DataGridView elements. Because the styles set at the control, column, and row levels filter down through each level to the cell level, you can also avoid style duplication by setting only those style properties at each level that differ from the levels above. This is described in more detail in the Style Inheritance section that follows.
The following table lists the primary properties that get or set DataGridViewCellStyle objects.
|
Property |
Classes |
Description |
|
DefaultCellStyle |
DataGridView, DataGridViewColumn, DataGridViewRow, and derived classes |
Gets or sets default styles used by all cells in the entire control (including header cells), in a column, or in a row. |
|
RowsDefaultCellStyle |
DataGridView |
Gets or sets default cell styles used by all rows in the control. This does not include header cells. |
|
AlternatingRowsDefaultCellStyle |
DataGridView |
Gets or sets default cell styles used by alternating rows in the control. Used to create a ledger-like effect. |
|
RowHeadersDefaultCellStyle |
DataGridView |
Gets or sets default cell styles used by the control's row headers. Overridden by the current theme if visual styles are enabled. |
|
ColumnHeadersDefaultCellStyle |
DataGridView |
Gets or sets default cell styles used by the control's column headers. Overridden by the current theme if visual styles are enabled. |
|
Style |
DataGridViewCell and derived classes |
Gets or sets styles specified at the cell level. These styles override those inherited from higher levels. |
|
InheritedStyle |
DataGridViewCell, DataGridViewRow, DataGridViewColumn, and derived classes |
Gets all the styles currently applied to the cell, row, or column, including styles inherited from higher levels. |
As mentioned above, getting the value of a style property automatically instantiates a new DataGridViewCellStyle object if the property has not been previously set. To avoid creating these objects unnecessarily, the row and column classes have a HasDefaultCellStyle property that you can check to determine whether the DefaultCellStyle property has been set. Similarly, the cell classes have a HasStyle property that indicates whether the Style property has been set.
Each of the style properties has a corresponding PropertyNameChanged event on the DataGridView control. For row, column, and cell properties, the name of the event begins with "Row", "Column", or "Cell" (for example, RowDefaultCellStyleChanged). Each of these events occurs when the corresponding style property is set to a different DataGridViewCellStyle object. These events do not occur when you retrieve a DataGridViewCellStyle object from a style property and modify its property values. To respond to changes to the cell style objects themselves, handle the CellStyleContentChanged event.
1.1.3 Style Inheritance
Each DataGridViewCell gets its appearance from its InheritedStyle property. The DataGridViewCellStyle object returned by this property inherits its values from a hierarchy of properties of type DataGridViewCellStyle. These properties are listed below in the order in which the InheritedStyle for non-header cells obtains its values.
1. DataGridViewCell.Style
2. DataGridViewRow.DefaultCellStyle
3. AlternatingRowsDefaultCellStyle (only for cells in rows with odd index numbers)
4. RowsDefaultCellStyle
5. DataGridViewColumn.DefaultCellStyle
6. DefaultCellStyle
For row and column header cells, the InheritedStyle property is populated by values from the following list of source properties in the given order.
1. DataGridViewCell.Style
2. ColumnHeadersDefaultCellStyle or RowHeadersDefaultCellStyle
3. DefaultCellStyle
The following diagram illustrates this process.
You can also access the styles inherited by specific rows and columns. The column InheritedStyle property inherits its values from the following properties.
1. DataGridViewColumn.DefaultCellStyle
2. DefaultCellStyle
The row InheritedStyle property inherits its values from the following properties.
1. DataGridViewRow.DefaultCellStyle
2. AlternatingRowsDefaultCellStyle (only for cells in rows with odd index numbers)
3. RowsDefaultCellStyle
4. DefaultCellStyle
For each property in a DataGridViewCellStyle object returned by an InheritedStyle property, the property value is obtained from the first cell style in the appropriate list that has the corresponding property set to a value other than the DataGridViewCellStyle class defaults.
The following table illustrates how the ForeColor property value for an example cell is inherited from its containing column.
|
Property of type DataGridViewCellStyle |
Example ForeColor value for retrieved object |
|
DataGridViewCell.Style |
Color.Empty |
|
DataGridViewRow.DefaultCellStyle |
Color.Red |
|
AlternatingRowsDefaultCellStyle |
Color.Empty |
|
RowsDefaultCellStyle |
Color.Empty |
|
DataGridViewColumn.DefaultCellStyle |
Color.DarkBlue |
|
DefaultCellStyle |
Color.Black |
In this case, the System.Drawing.Color.Red value from the cell's row is the first real value on the list. This becomes the ForeColor property value of the cell's InheritedStyle.
The following diagram illustrates how different DataGridViewCellStyle properties can inherit their values from different places.
By taking advantage of style inheritance, you can provide appropriate styles for the entire control without having to specify the same information in multiple places.
Although header cells participate in style inheritance as described, the objects returned by the ColumnHeadersDefaultCellStyle and RowHeadersDefaultCellStyle properties of the DataGridView control have initial property values that override the property values of the object returned by the DefaultCellStyle property. If you want the properties set for the object returned by the DefaultCellStyle property to apply to row and column headers, you must set the corresponding properties of the objects returned by the ColumnHeadersDefaultCellStyle and RowHeadersDefaultCellStyle properties to the defaults indicated for the DataGridViewCellStyle class.
Note: If visual styles are enabled, the row and column headers (except for the TopLeftHeaderCell) are automatically styled by the current theme, overriding any styles specified by these properties. Set the EnableHeadersVisualStyle property to false if you want headers to not use XP’s visual styles.
The DataGridViewButtonColumn, DataGridViewImageColumn, and DataGridViewCheckBoxColumn types also initialize some values of the object returned by the column DefaultCellStyle property. For more information, see the reference documentation for these types.
1.1.4 Setting Styles Dynamically
To customize the styles of cells with particular values, implement a handler for the CellFormatting event. Handlers for this event receive an argument of the DataGridViewCellFormattingEventArgs type. This object contains properties that let you determine the value of the cell being formatted along with its location in the DataGridView control. This object also contains a CellStyle property that is initialized to the value of the InheritedStyle property of the cell being formatted. You can modify the cell style properties to specify style information appropriate to the cell value and location.
Note: The RowPrePaint and RowPostPaint events also receive a DataGridViewCellStyle object in the event data, but in their case, it is a copy of the row InheritedStyle property for read-only purposes, and changes to it do not affect the control.
You can also dynamically modify the styles of individual cells in response to events such as the CellMouseEnter and CellMouseLeave events. For example, in a handler for the CellMouseEnter event, you could store the current value of the cell background color (retrieved through the cell's Style property), then set it to a new color that will highlight the cell when the mouse hovers over it. In a handler for the CellMouseLeave event, you can then restore the background color to the original value.
Note: Caching the values stored in the cell's Style property is important regardless of whether a particular style value is set. If you temporarily replace a style setting, restoring it to its original "not set" state ensures that the cell will go back to inheriting the style setting from a higher level. If you need to determine the actual style in effect for a cell regardless of whether the style is inherited, use the cell's InheritedStyle property.
1.2 Custom painting
The DataGridView control provides several properties that you can use to adjust the appearance and basic behavior (look and feel) of its cells, rows, and columns. If you have requirements that go beyond the capabilities of the DataGridViewCellStyle class, you can perform custom drawing of the cell or row content. To paint cells and rows yourself, you can handle various DataGridView painting events such as RowPrePaint, CellPainting and RowPostPaint.
1.2.1 Paint Parts
One important part of custom painting is the concept of paint parts. The DataGridViewPainParts enumeration is used to specify what parts a cell paints. Enum values can be combined together to have a cell paint or not paint specific parts. Here are the different parts:
|
PaintPart |
Example ForeColor value for retrieved object |
|
All |
All parts are painted |
|
Background |
The background of the cell is painted using the cell’s background color (1) |
|
Border |
The borders are painted |
|
ContentBackground |
The background part of the cell’s content is painted. (2) |
|
ContentForeground |
The foreground part of the cell’s content is painted (2) |
|
ErrorIcon |
The error icon is painted |
|
Focus |
The focus rectangle for the cell is painted |
|
None |
No parts are painted (1) |
|
SelectionBackground |
The background is painted selected if the cell is selected. |
Notes
1) If a cell does not paint its background then nothing is painted. A row or column performs no painting, so ensure that at least the cell’s background is painted or you perform your own custom background painting; otherwise the rectangle remains invalidated (unpainted).
2) Each cell determines what it paints as content foreground and content background as described by the following list:
|
Cell Type |
Content Foreground |
Content Background |
|
Text box |
Cell text is painted |
Nothing painted |
|
Button |
Cell text is painted |
Button is painted |
|
Combo box |
Cell text is painted |
Combo box is painted |
|
Check box |
Check box is painted |
Nothing painted |
|
Link |
Cell text is painted as a link |
Nothing is painted |
|
Image |
Cell image is painted |
Nothing painted |
|
Column Header |
Column header text |
Sort Glyph is painted |
|
Row Header |
Row header text |
Current row triangle, edit pencil and new row indicator is painted |
1.2.2 Row Pre Paint and Post Paint
You can control the appearance of DataGridView rows by handling one or both of the DataGridView.RowPrePaint and DataGridView.RowPostPaint events. These events are designed so that you can paint only what you want to while letting the DataGridView control paint the rest. For example, if you want to paint a custom background, you can handle the DataGridView.RowPrePaint event and let the individual cells paint their own foreground content. In the RowPrePaint event you can set the PaintParts event args property to easily customize how the cells paint. For example, if you want to keep cells from painting any selection or focus, your RowPrePaint event would set the PaintParts property like so:
e.PaintParts = DataGridViewPaintParts.All &
~(DataGridViewPaintParts.Focus |
DataGridViewPaintParts.SelectionBackground);
Which could also be written as:
e.PaintParts = (DataGridViewPaintParts.Background |
DataGridViewPaintParts.Border |
DataGridViewPaintParts.ContentBackground |
DataGridViewPaintParts.ContentForeground |
DataGridViewPaintParts.ErrorIcon);
Alternately, you can let the cells paint themselves and add custom foreground content in a handler for the DataGridView.RowPostPaint event. You can also disable cell painting and paint everything yourself in a DataGridView.RowPrePaint event handler
1.3 Autosizing
The DataGridView control provides numerous options for customizing the sizing behavior of its columns and rows. Typically, DataGridView cells do not resize based on their contents. Instead, they clip any display value that is larger than the cell. If the content can be displayed as a string, the cell displays it in a ToolTip.
By default, users can drag row, column, and header dividers with the mouse to show more information. Users can also double-click a divider to automatically resize the associated row, column, or header band based on its contents. Columns share the available width of the control by default, so if users can resize the control—for example, if it is docked to a resizable form—they can also change the available display space for all columns.
The DataGridView control provides properties, methods, and events that enable you to customize or disable all of these user-directed behaviors. Additionally, you can programmatically resize rows, columns, and headers to fit their contents, or you can configure them to automatically resize themselves whenever their contents change.
常见问题：
1.3.1 Sizing Options in the Windows Forms DataGridView Control
DataGridView rows, columns, and headers can change size as a result of many different occurrences. The following table shows these occurrences.
|
Occurrence |
Description |
|
User resize |
Users can make size adjustments by dragging or double-clicking row, column, or header dividers. |
|
Control resize |
In column fill mode, column widths change when the control width changes; for example, when the control is docked to its parent form and the user resizes the form. |
|
Cell value change |
In content-based automatic sizing modes, sizes change to fit new display values. |
|
Method call |
Programmatic content-based resizing lets you make opportunistic size adjustments based on cell values at the time of the method call. |
|
Property setting |
You can also set specific height and width values. |
By default, user resizing is enabled, automatic sizing is disabled, and cell values that are wider than their columns are clipped.
The following table shows scenarios that you can use to adjust the default behavior or to use specific sizing options to achieve particular effects.
|
Scenario |
Implementation |
|
Use column fill mode for displaying similarly sized data in a relatively small number of columns that occupy the entire width of the control without displaying the horizontal scroll bar. |
Set the AutoSizeColumnsMode property to Fill. |
|
Use column fill mode with display values of varying sizes. |
Set the AutoSizeColumnsMode property to Fill. Initialize relative column widths by setting the column FillWeight properties or by calling the control AutoResizeColumns method after filling the control with data. |
|
Use column fill mode with values of varying importance. |
Set the AutoSizeColumnsMode property to Fill. Set large MinimumWidth values for columns that must always display some of their data or use a sizing option other than fill mode for specific columns. |
|
Use column fill mode to avoid displaying the control background. |
Set the AutoSizeMode property of the last column to Fill and use other sizing options for the other columns. |
|
Display a fixed-width column, such as an icon or ID column. |
Set AutoSizeMode to None and Resizable to False for the column. Initialize its width by setting the Width property or by calling the control AutoResizeColumn method after filling the control with data. |
|
Adjust sizes automatically whenever cell contents change to avoid clipping and to optimize the use of space. |
Set an automatic sizing property to a value that represents a content-based sizing mode. To avoid a performance penalty when working with large amounts of data, use a sizing mode that calculates displayed rows only. |
|
Adjust sizes to fit values in displayed rows to avoid performance penalties when working with many rows. |
Use the appropriate sizing-mode enumeration values with automatic or programmatic resizing. To adjust sizes to fit values in newly displayed rows while scrolling, call a resizing method in a Scroll event handler. To customize user double-click resizing so that only values in displayed rows determine the new sizes, call a resizing method in a RowDividerDoubleClick or ColumnDividerDoubleClick event handler. |
|
Adjust sizes to fit cell contents only at specific times to avoid performance penalties or to enable user resizing. |
Call a content-based resizing method in an event handler. For example, use the DataBindingComplete event to initialize sizes after binding, and handle the CellValidated or CellValueChanged event to adjust sizes to compensate for user edits or changes in a bound data source. |
|
Adjust row heights for multiline cell contents. |
Ensure that column widths are appropriate for displaying paragraphs of text and use automatic or programmatic content-based row sizing to adjust the heights. Also ensure that cells with multiline content are displayed using a WrapMode cell style value of True. Typically, you will use an automatic column sizing mode to maintain column widths or set them to specific widths before row heights are adjusted. |
1.3.2 Resizing with the Mouse
By default, users can resize rows, columns, and headers that do not use an automatic sizing mode based on cell values. To prevent users from resizing with other modes, such as column fill mode, set one or more of the following DataGridView properties:
· AllowUserToResizeColumns
· AllowUserToResizeRows
· ColumnHeadersHeightSizeMode
· RowHeadersWidthSizeMode
You can also prevent users from resizing individual rows or columns by setting their Resizable properties. By default, the Resizable property value is based on the AllowUserToResizeColumns property value for columns and the AllowUserToResizeRows property value for rows. If you explicitly set Resizable to True or False, however, the specified value overrides the control value is for that row or column. Set Resizable to NotSet to restore the inheritance.
Because NotSet restores the value inheritance, the Resizable property will never return a NotSet value unless the row or column has not been added to a DataGridView control. If you need to determine whether the Resizable property value of a row or column is inherited, examine its State property. If the State value includes the ResizableSet flag, the Resizable property value is not inherited.
1.3.3 Automatic Sizing
There are two kinds of automatic sizing in the DataGridView control: column fill mode and content-based automatic sizing.
Column fill mode causes the visible columns in the control to fill the width of the control's display area. For more information about this mode, see the Column Fill Mode section below.
You can also configure rows, columns, and headers to automatically adjust their sizes to fit their cell contents. In this case, size adjustment occurs whenever cell contents change.
Note: If you maintain cell values in a custom data cache using virtual mode, automatic sizing occurs when the user edits a cell value but does not occur when you alter a cached value outside of a CellValuePushed event handler. In this case, call the UpdateCellValue method to force the control to update the cell display and apply the current automatic sizing modes.
If content-based automatic sizing is enabled for one dimension only—that is, for rows but not columns, or for columns but not rows—and WrapMode is also enabled, size adjustment also occurs whenever the other dimension changes. For example, if rows but not columns are configured for automatic sizing and WrapMode is enabled, users can drag column dividers to change the width of a column and row heights will automatically adjust so that cell contents are still fully displayed.
If you configure both rows and columns for content-based automatic sizing and WrapMode is enabled, the DataGridView control will adjust sizes whenever cell contents changed and will use an ideal cell height-to-width ratio when calculating new sizes.
To configure the sizing mode for headers and rows and for columns that do not override the control value, set one or more of the following DataGridView properties:
· ColumnHeadersHeightSizeMode
· RowHeadersWidthSizeMode
· AutoSizeColumnsMode
· AutoSizeRowsMode
To override the control's column sizing mode for an individual column, set its AutoSizeMode property to a value other than NotSet. The sizing mode for a column is actually determined by its InheritedAutoSizeMode property. The value of this property is based on the column's AutoSizeMode property value unless that value is NotSet, in which case the control's AutoSizeColumnsMode value is inherited.
Use content-based automatic resizing with caution when working with large amounts of data. To avoid performance penalties, use the automatic sizing modes that calculate sizes based only on the displayed rows rather than analyzing every row in the control. For maximum performance, use programmatic resizing instead so that you can resize at specific times, such as immediately after new data is loaded.
Content-based automatic sizing modes do not affect rows, columns, or headers that you have hidden by setting the row or column Visible property or the control RowHeadersVisible or ColumnHeadersVisible properties to false. For example, if a column is hidden after it is automatically sized to fit a large cell value, the hidden column will not change its size if the row containing the large cell value is deleted. Automatic sizing does not occur when visibility changes, so changing the column Visible property back to true will not force it to recalculate its size based on its current contents.
Programmatic content-based resizing affects rows, columns, and headers regardless of their visibility.
1.3.4 Programmatic Resizing
When automatic sizing is disabled, you can programmatically set the exact width or height of rows, columns, or headers through the following properties:
· RowHeadersWidth
· ColumnHeadersHeight
· DataGridViewRow.Height
· DataGridViewColumn.Width
You can also programmatically resize rows, columns, and headers to fit their contents using the following methods:
· AutoResizeColumn
· AutoResizeColumns
· AutoResizeColumnHeadersHeight
· AutoResizeRow
· AutoResizeRows
· AutoResizeRowHeadersWidth
These methods will resize rows, columns, or headers once rather than configuring them for continuous resizing. The new sizes are automatically calculated to display all cell contents without clipping. When you programmatically resize columns that have InheritedAutoSizeMode property values of Fill, however, the calculated content-based widths are used to proportionally adjust the column FillWeight property values, and the actually column widths are then calculated according to these new proportions so that all columns fill the available display area of the control.
Programmatic resizing is useful to avoid performance penalties with continuous resizing. It is also useful to provide initial sizes for user-resizable rows, columns, and headers, and for column fill mode.
You will typically call the programmatic resizing methods at specific times. For example, you might programmatically resize all columns immediately after loading data, or you might programmatically resize a specific row after a particular cell value has been modified.
1.3.5 Customizing Content-based Sizing Behavior
You can customize sizing behaviors when working with derived DataGridView cell, row, and column types by overriding the DataGridViewCell.GetPreferredSize(), DataGridViewRow.GetPreferredHeight(), or DataGridViewColumn.GetPreferredWidth() methods or by calling protected resizing method overloads in a derived DataGridView control. The protected resizing method overloads are designed to work in pairs to achieve an ideal cell height-to-width ratio, avoiding overly wide or tall cells. For example, if you call the AutoResizeRows(DataGridViewAutoSizeRowsMode,Boolean) overload of the AutoResizeRows method and pass in a value of false for the Boolean parameter, the overload will calculate the ideal heights and widths for cells in the row, but it will adjust the row heights only. You must then call the AutoResizeColumns method to adjust the column widths to the calculated ideal.
1.3.6 Content-based Sizing Options
The enumerations used by sizing properties and methods have similar values for content-based sizing. With these values, you can limit which cells are used to calculate the preferred sizes. For all sizing enumerations, values with names that refer to displayed cells limit their calculations to cells in displayed rows. Excluding rows is useful to avoid a performance penalty when you are working with a large quantity of rows. You can also restrict calculations to cell values in header or nonheader cells.
1.4 Selection modes
The DataGridView control provides you with a variety of options for configuring how users can select cells, rows, and columns. For example, you can enable single or multiple selection, selection of whole rows or columns when users click cells, or selection of whole rows or columns only when users click their headers, which enables cell selection as well. If you want to provide your own user interface for selection, you can disable ordinary selection and handle all selection programmatically. Additionally, you can enable users to copy the selected values to the Clipboard.
Sometimes you want your application to perform actions based on user selections within a DataGridView control. Depending on the actions, you may want to restrict the kinds of selection that are possible. For example, suppose your application can print a report for the currently selected record. In this case, you may want to configure the DataGridView control so that clicking anywhere within a row always selects the entire row, and so that only one row at a time can be selected.
You can specify the selections allowed by setting the SelectionMode property to one of the following DataGridViewSelectionMode enumeration values.
|
DataGridViewSelectionMode value |
Description |
|
CellSelect |
单击单元格以选中它，行列标题不能用于选择。 |
|
ColumnHeaderSelect |
单击单元格以选中它，单击列标题选中整列。此时列标题不能用于排序。 |
|
FullColumnSelect |
单击单元格或列标题会选中它们所在的列，此时列标题不能用于排序。 |
|
FullRowSelect |
单击单元格或行标题会选中它们所在的行。 |
|
RowHeaderSelect |
DGV的默认选择模式，单击单元格选中该单元格，单击行标题则选中整行。 |
注意: 在运行时改变选择模式会自动清除当前选择的内容。
By default, users can select multiple rows, columns, or cells by dragging with the mouse, pressing CTRL or SHIFT while selecting to extend or modify a selection, or clicking the top-left header cell to select all cells in the control. To prevent this behavior, set the MultiSelect property to false.
The FullRowSelect and RowHeaderSelect modes allow users to delete rows by selecting them and pressing the DELETE key. Users can delete rows only when the current cell is not in edit mode, the AllowUserToDeleteRows property is set to true, and the underlying data source supports user-driven row deletion. Note that these settings do not prevent programmatic row deletion.
1.4.1 Programmatic Selection
The current selection mode restricts the behavior of programmatic selection as well as user selection. You can change the current selection programmatically by setting the Selected property of any cells, rows, or columns present in the DataGridView control. You can also select all cells in the control through the SelectAll method, depending on the selection mode. To clear the selection, use the ClearSelection method.
If the MultiSelect property is set to true, you can add DataGridView elements to or remove them from the selection by changing the Selected property of the element. Otherwise, setting the Selected property to true for one element automatically removes other elements from the selection.
注意：改变CurrentCell属性的值不会改变当前选择的内容。
通过SelectedCells、SelectedRows和SelectedColumns属性你可以访问当前选中的单元格、行和列。不过当所有单元格都被选中的时候，使用这些属性效率会比较低，为此可首先使用AreAllCellsSelected方法查看是否已选中全部单元格。此外，访问这些属性来查看选中单元格、行和列的数目效率也比较低，此时应该使用GetCellCount、GetRowCount和GetColumnCount方法，传给它们的参数为DataGridViewElementStates.Selected。
