The code below shows the actual implementation of the
BaseSingleDataField class, which handles some of the basic functionality when
interacting with a single and simple interface data field. First, the
control's interface is created in the InitializeCell method. This method makes
the determination based on the current cell type, whether in read-only mode or
in edit/insert mode. Take a look below.
public override void InitializeCell(DataControlFieldCell cell,
DataControlCellType cellType, DataControlRowState rowState, int rowIndex)
base.InitializeCell(cell, cellType, rowState, rowIndex);
Control control = null;
if (cellType == DataControlCellType.DataCell)
control = cell;
control = cell.Controls;
if (control != null && this.Visible)
control.DataBinding += new EventHandler(control_DataBinding);
At the beginning of this method is a reference to a control
variable. If in read-only mode, this variable then snags the reference to the
table cell (which the value is entered directly into the cell). If in edit or
insert mode, the SetupEditControl method creates a control that will represent
the edit/insert interface for the underlying data item.
At the end, if a control reference was successfully created
and this field is visible, the control creates an event handler for data binding.
The purpose of tapping into this event is to perform the binding to the actual
control. If in read-only mode, the sender control reference will be the table
cell; otherwise, it will match the edited control returned from
void control_DataBinding(object sender, EventArgs e)
if (sender is TableCell)
TableCell cell = sender as TableCell;
cell.Text = this.GetReadOnlyValue(this.GetDataItemValue
Note that this method uses certain primitive base class
methods, notably the GetReadOnlyValue, GetDataItemValue, and the
GetDataItemFieldName methods. You can find these in the code sample attached. The
next method extracts the values back out of the interface controls, and adds it
to the dictionary.
In the GridView and DetailsView controls, a dictionary
contains the field names and their corresponding values. When updating, both
the old and new values are tracked, and insertions only track the new values.
These dictionaries store the values that the data source control can utilize. Below
is the method to get the value from the editing control and add it to the
public override void ExtractValuesFromCell(IOrderedDictionary dictionary,
DataControlFieldCell cell, DataControlRowState rowState, bool includeReadOnly)
base.ExtractValuesFromCell(dictionary, cell, rowState, includeReadOnly);
string value = null;
if (cell.Controls.Count > 0)
value = this.GetEditControlValue(cell);
string dataField = this.GetDataItemFieldName();
dictionary[dataField] = value;
If you look at the code sample, the code to add/insert the
item in the dictionary has been extracted to an AddDictionaryEntry method.