How to Programmatically Set Cell Values in DataGridView and Update Bound Objects

Overview of DataGridView Data Binding Mechanism

In C# WinForms application development, the DataGridView control serves as a core component for displaying and editing tabular data. When DataGridView is bound to a data source, the displayed data actually originates from underlying data object collections. This data binding mechanism enables the interface to automatically respond to data changes, but also requires developers to follow specific data update patterns.

Common Issues with Direct Cell Value Modification

Many developers initially approach DataGridView by attempting to directly modify cell Value properties to update data:

SetValueFromSerial(decimal newValue)
{
    dataGridView.CurrentCell.Value = newValue;
}

Or using string format:

dataGridView.CurrentCell.Value = newValue.ToString();

While this approach seems intuitive, it actually presents significant problems. When DataGridView is in data-bound mode, directly modifying cell Value properties does not trigger updates to underlying data objects. This results in inconsistent interface display versus actual data state, where users might see stale data while the actual data objects remain unchanged.

Correct Data Update Methodology

To properly update DataGridView data and synchronize with bound objects, developers should access underlying data objects through the DataBoundItem property:

MyObject obj = (MyObject)dataGridView.CurrentRow.DataBoundItem;
obj.MyProperty = newValue;

The core advantage of this method lies in directly manipulating the data object itself, rather than attempting to bypass the data binding mechanism. Through DataBoundItem, developers obtain the complete data object instance corresponding to the current row and directly modify its property values.

Importance of INotifyPropertyChanged Interface

To ensure data changes automatically reflect in the DataGridView interface, bound objects must implement the INotifyPropertyChanged interface:

public class MyObject : INotifyPropertyChanged
{
    private decimal _myProperty;
    
    public decimal MyProperty
    {
        get { return _myProperty; }
        set
        {
            _myProperty = value;
            OnPropertyChanged(nameof(MyProperty));
        }
    }
    
    public event PropertyChangedEventHandler PropertyChanged;
    
    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

When property values change, the PropertyChanged event is triggered, and DataGridView automatically updates corresponding cell displays upon detecting this event. This mechanism ensures real-time synchronization between data and interface.

Complete Implementation Example

The following complete example demonstrates how to receive data from a serial port and update DataGridView:

public partial class MainForm : Form
{
    private BindingList<MyObject> dataSource;
    
    public MainForm()
    {
        InitializeComponent();
        InitializeDataGridView();
    }
    
    private void InitializeDataGridView()
    {
        dataSource = new BindingList<MyObject>
        {
            new MyObject { MyProperty = 0 },
            new MyObject { MyProperty = 0 }
        };
        
        dataGridView.DataSource = dataSource;
        dataGridView.Columns["MyProperty"].HeaderText = "Measurement Value";
    }
    
    public void SetValueFromSerial(decimal newValue)
    {
        if (dataGridView.CurrentRow != null && dataGridView.CurrentRow.DataBoundItem is MyObject obj)
        {
            obj.MyProperty = newValue;
        }
    }
}

Limitations of Alternative Methods

Some developers might attempt to directly access cells through indexing:

dataGridView1[1, 1].Value = "tes";

While this method can modify cell display content, it similarly fails to update underlying bound objects. In data-bound scenarios, this direct cell manipulation approach should be avoided as it compromises data consistency.

Best Practices Summary

When developing DataGridView applications, following these best practices can prevent common data synchronization issues:

• Always access and modify bound objects through DataBoundItem
• Ensure bound objects implement INotifyPropertyChanged interface
• Use data-binding compatible collections like BindingList or ObservableCollection
• Avoid direct manipulation of DataGridViewCell Value properties
• Validate current row and bound object availability before modifying data

By understanding DataGridView's data binding mechanism and correctly utilizing relevant APIs, developers can build desktop applications with accurate data synchronization and responsive interfaces.