Wpf Editable Datagrid And Validation Complete Guide

Last Update:2025-06-23T00:00:00 .NET School AI Teacher - SELECT ANY TEXT TO EXPLANATION. 8 mins read Difficulty-Level: beginner

Understanding the Core Concepts of WPF Editable DataGrid and Validation

WPF Editable DataGrid and Validation

Windows Presentation Foundation (WPF) provides robust data manipulation capabilities through its DataGrid control, enabling developers to display and edit tabular data efficiently. One of the key features is editable cells, which allow users to modify values directly within the grid. Combining this functionality with validation ensures that data integrity is maintained, preventing errors or unwanted input.

Creating an Editable DataGrid

Introduction to DataGrid in WPF

The DataGrid control in WPF is specifically designed to host data in rows and columns. It supports data binding, editing, sorting, grouping, styling, and custom behaviors seamlessly.
Editable Cells

By default, DataGrid cells are read-only. To enable editing, set the IsReadOnly property of the DataGrid to False. Moreover, individual columns can be configured to be read-only if necessary by setting their IsReadOnly properties separately.
```
<DataGrid x:Name="MyDataGrid" IsReadOnly="False">
    
</DataGrid>
```

Binding Data Source

Typically, DataGrid is bound to a collection of objects, such as ObservableCollection<T>, where T is a business object representing each row. Ensure your business objects implement INotifyPropertyChanged to notify the UI about changes.

public class Product : INotifyPropertyChanged
{
    private string name;
    public string Name
    {
        get => name;
        set
        {
            if (name != value)
            {
                name = value;
                OnPropertyChanged(nameof(Name));
            }
        }
    }

    // Other properties...

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

MyDataGrid.ItemsSource = new ObservableCollection<Product>();

Configuring Columns

Define the columns within the DataGrid either automatically (based on the data source's properties) or manually. Manual configuration allows you to customize appearance, behavior, and data type of each column using DataGridColumn types like DataGridTextColumn, DataGridComboBoxColumn, and others.
```
<DataGrid.Columns>
    <DataGridTextColumn Header="Product Name" Binding="{Binding Name}" Width="*" />
    <DataGridTextColumn Header="Price" Binding="{Binding Price}" Width="100" />
</DataGrid.Columns>
```

Implementing Validation in DataGrid

Validation is vital for ensuring that user inputs conform to expected formats or rules, enhancing the quality and reliability of data processed within applications.

Adding Validation Logic

Introduce validation logic within your business objects through interfaces IDataErrorInfo or INotifyDataErrorInfo. These interfaces provide mechanisms for evaluating validation rules and returning error messages.

Using IDataErrorInfo

public class Product : INotifyPropertyChanged, IDataErrorInfo
{
    // Properties...

    public string Error => null;  // Optional overall error message

    public string this[string columnName]
    {
        get
        {
            string result = null;

            switch (columnName)
            {
                case nameof(Name):
                    if (string.IsNullOrEmpty(name))
                    {
                        result = "The product name cannot be empty.";
                    }
                    break;
                case nameof(Price):
                    if (!decimal.TryParse(price.ToString(), out decimal _))
                    {
                        result = "Invalid price format.";
                    }
                    else if (price <= 0)
                    {
                        result = "Price must be greater than zero.";
                    }
                    break;
                // Additional cases...
            }

            return result;
        }
    }

    // PropertyChanged implementation...
}

Using INotifyDataErrorInfo

public class Product : INotifyPropertyChanged, INotifyDataErrorInfo
{
    // Properties...

    private readonly Dictionary<string, List<string>> _errors = new Dictionary<string, List<string>>();

    public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

    public bool HasErrors => _errors.Any();

    public string GetError(string propertyName)
    {
        return _errors.ContainsKey(propertyName) ? string.Join(", ", _errors[propertyName]) : null;
    }

    private void AddError(string propertyName, string errorMessage)
    {
        if (!_errors.ContainsKey(propertyName))
        {
            _errors[propertyName] = new List<string>();
        }

        _errors[propertyName].Add(errorMessage);
        OnErrorsChanged(propertyName);
    }

    private void RemoveError(string propertyName)
    {
        if (_errors.Contains(propertyName))
        {
            _errors.Remove(propertyName);
            OnErrorsChanged(propertyName);
        }
    }

    protected virtual void ValidateProperty(string propertyName)
    {
        RemoveError(propertyName);

        switch (propertyName)
        {
            case nameof(Name):
                if (string.IsNullOrEmpty(name)) AddError(nameof(Name), "The product name cannot be empty.");
                break;
            case nameof(Price):
                if (!decimal.TryParse(price.ToString(), out decimal _) || price <= 0) AddError(nameof(Price), "Invalid price format.");
                break;
            // Additional cases...
        }
    }

    protected virtual void OnErrorsChanged(string propertyName)
    {
        ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
    }

    // PropertyChanged implementation...
}

Updating Validation

Whenever a property value changes, update the validation state. This requires invoking the appropriate method(s) from your validation logic within the OnPropertyChanged event handler.
```
protected override void OnPropertyChanged(string propertyName)
{
    base.OnPropertyChanged(propertyName);
    ValidateProperty(propertyName);  // Invoke validation check
}
```

Visual Feedback

Customize how validation errors appear in UI elements. For DataGrid, you can modify default styles applied to fields with errors using Style.Triggers. This facilitates immediate feedback, guiding users towards correct input.

<Style TargetType="TextBox">
    <Style.Triggers>
        <Trigger Property="Validation.HasError" Value="true">
            <Setter Property="ToolTip"
                    Value="{Binding RelativeSource={RelativeSource Self},
                                  Path=(Validation.Errors)[0].ErrorContent}" />
            <Setter Property="Background" Value="Pink" />
        </Trigger>
    </Style.Triggers>
</Style>

Handling Validation Errors

Decide how to manage validation errors. Options include displaying tooltips, changing background colors, preventing form submission, etc. This strategy depends on your specific application requirements.

Validation Rule Example via Markup Extension

Alternatively, apply validation directly at the XAML level using validation rules defined as markup extensions. This method decouples the UI from the business logic but still requires implementing proper interfaces in underlying data models.

public class StringLengthValidationRule : ValidationRule
{
    public int Min { get; set; }
    public int Max { get; set; }

    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        if (value == null || !(value is string strValue))
        {
            return new ValidationResult(false, "Input is not a valid string.");
        }

        if (strValue.Length < Min || strValue.Length > Max)
        {
            return new ValidationResult(false, $"Input length must be between {Min} and {Max} characters.");
        }

        return ValidationResult.ValidResult;
    }
}

<Window.Resources>
    <local:StringLengthValidationRule x:Key="StringLengthRule" Min="3" Max="20" />
</Window.Resources>

<DataGridTextColumn Header="Product Name" Binding="{Binding Name}">
    <DataGridTextColumn.ElementStyle>
        <Style TargetType="TextBlock">
            <Setter Property="Foreground" Value="Black" />
            <Style.Triggers>
                <Trigger Property="Validation.HasError" Value="true">
                    <Setter Property="ToolTip"
                            Value="{Binding RelativeSource={RelativeSource Self},
                                          Path=(Validation.Errors)[0].ErrorContent}" />
                    <Setter Property="Foreground" Value="Red" />
                </Trigger>
            </Style.Triggers>
        </Style>
    </DataGridTextColumn.ElementStyle>
    <DataGridTextColumn.EditingElementStyle>
        <Style TargetType="TextBox">
            <Setter Property="Foreground" Value="Black" />
            <Style.Triggers>
                <Trigger Property="Validation.HasError" Value="true">
                    <Setter Property="ToolTip"
                            Value="{Binding RelativeSource={RelativeSource Self},
                                          Path=(Validation.Errors)[0].ErrorContent}" />
                    <Setter Property="Foreground" Value="Red" />
                </Trigger>
                <Trigger Property="Validation.HasError" Value="false">
                    <Setter Property="Background" Value="Transparent" />
                </Trigger>
            </Style.Triggers>
            <Setter Property="Validation.ErrorTemplate">
                <Setter.Value>
                    <ControlTemplate>
                        <Border BorderBrush="Red" BorderThickness="1">
                            <AdornedElementPlaceholder />
                        </Border>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>
    </DataGridTextColumn.EditingElementStyle>
    <DataGridTextColumn.Binding>
        <Binding Path="Name" UpdateSourceTrigger="PropertyChanged">
            <Binding.ValidationRules>
                <local:StringLengthValidationRule Min="3" Max="20" />
            </Binding.ValidationRules>
        </Binding>
    </DataGridTextColumn.Binding>
</DataGridTextColumn>

Custom Validation in Code-Behind

Implement additional or more intricate validation procedures in the code-behind. Listen to events such as CellEditEnding, RowEditEnding, or LostFocus to execute validation logic and update UI accordingly.

private void MyDataGrid_RowEditEnding(object sender, DataGridRowEditEndingEventArgs e)
{
    var product = e.Row.DataContext as Product;
    if (product != null && product.HasErrors)
    {
        e.Cancel = true;  // Optionally cancel editing operation
    }
}

Committing Changes Safely

After validating user inputs, ensure all valid modifications are committed properly to your data source without altering invalid data unintentionally. Handle exceptions and revert changes in case of validation failures.
Best Practices
- Decouple UI from Business Logic: Preferably, place validation rules within business objects rather than UI controls to maintain clean separation between presentation-tier and data/business-tier concerns.
- Use Asynchronous Validation: Employ asynchronous validation techniques for computationally intensive rules, improving application responsiveness while still enforcing correctness.
- Customize Error Messages: Provide clear and descriptive error messages to help users understand what constitutes a valid input and how to correct invalid entries.
Additional Enhancements
- Multi-Level Validation: Apply multiple validation rules to different properties simultaneously for comprehensive checks.
- Dynamic Validation: Modify validation criteria based on runtime conditions, adapting input requirements dynamically.
- Integration with Commands: Tie validation results into command executions, allowing commands to act based on whether all bound data passes validation tests.

Understanding these components and strategies will empower you to create dynamic, responsive, and fault-tolerant DataGrid implementations in WPF, significantly improving user experiences while safeguarding application data integrity.

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement WPF Editable DataGrid and Validation

Step 1: Set Up Your Project

Open Visual Studio.
Create a New WPF Application:
- Go to File > New > Project.
- Select WPF App (.NET Core) or WPF Application (.NET Framework) depending on your preference.
- Name your project (e.g., EditableDataGridExample) and click Create.

Step 2: Design the MainWindow

Open the MainWindow.xaml file and design the UI. Add a DataGrid to your window.

<Window x:Class="EditableDataGridExample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Editable DataGrid Example" Height="450" Width="800">
    <Grid>
        <DataGrid x:Name="EditableDataGrid" AutoGenerateColumns="False" Margin="10"
                  CanUserAddRows="True" CanUserDeleteRows="True"
                  ItemsSource="{Binding Customers}" 
                  Validation.ErrorTemplate="{StaticResource validationTemplate}" 
                  EnableRowVirtualization="True" Margin="5">
            <DataGrid.Resources>
                <ControlTemplate x:Key="validationTemplate">
                    <DockPanel LastChildFill="True">
                        <Border BorderBrush="Red" BorderThickness="1" Margin="2">
                            <AdornedElementPlaceholder/>
                        </Border>
                    </DockPanel>
                </ControlTemplate>
            </DataGrid.Resources>
            <DataGrid.Columns>
                <DataGridTextColumn Header="ID" Binding="{Binding ID}" IsReadOnly="True"/>
                <DataGridTextColumn Header="First Name" Binding="{Binding FirstName, ValidatesOnDataErrors=True, UpdateSourceTrigger=PropertyChanged, NotifyOnValidationError=True}"/>
                <DataGridTextColumn Header="Last Name" Binding="{Binding LastName, ValidatesOnDataErrors=True, UpdateSourceTrigger=PropertyChanged, NotifyOnValidationError=True}"/>
                <DataGridTextColumn Header="Age" Binding="{Binding Age, ValidatesOnDataErrors=True, UpdateSourceTrigger=PropertyChanged, NotifyOnValidationError=True}"/>
                <DataGridTextColumn Header="Email" Binding="{Binding Email, ValidatesOnDataErrors=True, UpdateSourceTrigger=PropertyChanged, NotifyOnValidationError=True}"/>
            </DataGrid.Columns>
        </DataGrid>
    </Grid>
</Window>

Step 3: Add the ViewModel

Add a new class called MainWindowViewModel.cs for the view model. This class will contain the data source and handle validation.

using System.Collections.ObjectModel;
using System.ComponentModel;

namespace EditableDataGridExample
{
    public class MainWindowViewModel : INotifyPropertyChanged
    {
        private ObservableCollection<Customer> _customers;

        public ObservableCollection<Customer> Customers
        {
            get { return _customers; }
            set
            {
                if (_customers != value)
                {
                    _customers = value;
                    OnPropertyChanged(nameof(Customers));
                }
            }
        }

        public MainWindowViewModel()
        {
            Customers = new ObservableCollection<Customer>()
            {
                new Customer { ID = 1, FirstName = "John", LastName = "Doe", Age = 28, Email = "john.doe@example.com" },
                new Customer { ID = 2, FirstName = "Jane", LastName = "Smith", Age = 34, Email = "jane.smith@example.com" }
            };
        }

        #region INotifyPropertyChanged Implementation
        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        #endregion
    }
}

Step 4: Create the Customer Class

Add another class called Customer.cs. Make sure this class implements the IDataErrorInfo interface for validation.

using System.ComponentModel;
using System.Data.Common;

namespace EditableDataGridExample
{
    public class Customer : IDataErrorInfo, INotifyPropertyChanged
    {
        private static int autoGeneratedID;

        public Customer()
        {
            ID = ++autoGeneratedID;
        }

        public int ID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public int Age { get; set; }
        public string Email { get; set; }

        public string Error => "";

        public string this[string columnName]
        {
            get
            {
                switch (columnName)
                {
                    case nameof(FirstName):
                        if (string.IsNullOrEmpty(FirstName))
                            return "First name cannot be empty.";
                        break;

                    case nameof(LastName):
                        if (string.IsNullOrEmpty(LastName))
                            return "Last name cannot be empty.";
                        break;

                    case nameof(Age):
                        if (Age <= 0)
                            return "Age should be more than 0.";
                        break;

                    case nameof(Email):
                        if (!IsValidEmail(Email))
                            return "Invalid email address.";
                        break;

                    default:
                        break;
                }
                return null;
            }
        }

        private static bool IsValidEmail(string email)
        {
            try
            {
                var addr = new System.Net.Mail.MailAddress(email);
                return addr.Address == email;
            }
            catch
            {
                return false;
            }
        }

        #region INotifyPropertyChanged Implementation
        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        protected bool SetProperty<T>(ref T storage, T value, string propertyName = null)
        {
            if (Equals(storage, value))
                return false;

            storage = value;
            OnPropertyChanged(propertyName);
            return true;
        }
        #endregion

        public override string ToString()
        {
            return $"{FirstName} {LastName}";
        }
    }
}

Step 5: Update the MainWindow.xaml.cs Code-Behind

Set the data context of the MainWindow to the MainWindowViewModel.

using System.Windows;

namespace EditableDataGridExample
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            DataContext = new MainWindowViewModel();
        }
    }
}

Step 6: Ensure INotifyPropertyChanged Is Triggered

Modify your property setters in the Customer class to raise the PropertyChanged event.

private string _firstName;
public string FirstName
{
    get { return _firstName; }
    set
    {
        if (SetProperty(ref _firstName, value))
        {
            // Raise PropertyChanged to trigger validation
            OnPropertyChanged(nameof(FirstName));
        }
    }
}

private string _lastName;
public string LastName
{
    get { return _lastName; }
    set
    {
        if (SetProperty(ref _lastName, value))
        {
            OnPropertyChanged(nameof(LastName));
        }
    }
}

private int _age;
public int Age
{
    get { return _age; }
    set
    {
        if (SetProperty(ref _age, value))
        {
            OnPropertyChanged(nameof(Age));
        }
    }
}

private string _email;
public string Email
{
    get { return _email; }
    set
    {
        if (SetProperty(ref _email, value))
        {
            OnPropertyChanged(nameof(Email));
        }
    }
}

Step 7: Run the Application

Compile and run your application. You should see a DataGrid that allows you to edit customer details. When you leave the field with invalid data, a red border will appear around it indicating a validation error.

Summary

This example demonstrates how to create an editable DataGrid in WPF with basic validation using the IDataErrorInfo interface. The steps include setting up the project, designing the UI, creating a view model, setting up the Customer class with validation, and updating the code-behind to bind the DataGrid to the view model.

Top 10 Interview Questions & Answers on WPF Editable DataGrid and Validation

1. How do I make a WPF DataGrid editable?

To make a WPF DataGrid editable, you need to set the IsReadOnly property to False. By default, IsReadOnly is False, so if your DataGrid is not editable, it may be due to other factors, such as the bound objects being immutable or the columns being set to read-only.

<DataGrid x:Name="MyDataGrid" IsReadOnly="False" AutoGenerateColumns="False" ItemsSource="{Binding Path=MyItems}">
    <DataGrid.Columns>
        <!-- Define Columns -->
        <DataGridTextColumn Header="Name" Binding="{Binding Path=Name}" />
        <DataGridTextColumn Header="Age" Binding="{Binding Path=Age}" />
    </DataGrid.Columns>
</DataGrid>

2. How can I validate a field in a WPF DataGrid?

Validation in WPF can be achieved using Data Annotations on the underlying data model. Here’s an example using INotifyDataErrorInfo or Data Annotations such as [Required] and [Range].

First, ensure your class implements INotifyPropertyChanged, and then add validation rules:

public class Person : INotifyPropertyChanged
{
    private string _name;
    private int _age;

    [Required(ErrorMessage = "Name is required.")]
    [StringLength(50, ErrorMessage = "Name cannot exceed 50 characters.")]
    public string Name
    {
        get { return _name; }
        set
        {
            _name = value;
            OnPropertyChanged(nameof(Name));
        }
    }

    [Range(0, 120, ErrorMessage = "Age must be between 0 and 120.")]
    public int Age
    {
        get { return _age; }
        set
        {
            _age = value;
            OnPropertyChanged(nameof(Age));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

3. How can I display validation errors in the DataGrid?

To display validation errors, ensure your data model implements INotifyDataErrorInfo. Below is an example demonstrating this:

public class Person : INotifyPropertyChanged, INotifyDataErrorInfo
{
    private Dictionary<string, List<string>> _errorsByPropertyName = new Dictionary<string, List<string>>();    
    public string Name { get; set; }
    public int Age { get; set; }

    public bool HasErrors => _errorsByPropertyName.Any();

    public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

    public IEnumerable GetErrors(string propertyName)
    {
        return _errorsByPropertyName.ContainsKey(propertyName) ? _errorsByPropertyName[propertyName] : null;
    }

    protected void SetErrors(string propertyName, IEnumerable<string> errors)
    {
        _errorsByPropertyName[propertyName] = errors.ToList();

        ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
    }

    protected void OnErrorsChanged(string propertyName)
    {
        ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
    }
}

4. How do I handle data validation exceptions when saving changes?

When you are saving changes from the DataGrid, you need to check for validation errors before proceeding.

private void SaveButton_Click(object sender, RoutedEventArgs e)
{
    var dataGrid = MyDataGrid;
    foreach (var item in dataGrid.Items)
    {
        var validationContext = new ValidationContext(item, null, null);
        var validationResults = new List<ValidationResult>();

        if (!Validator.TryValidateObject(item, validationContext, validationResults, true))
        {
            MessageBox.Show(string.Join(Environment.NewLine, validationResults.Select(x => x.ErrorMessage)));
            return;
        }
    }

    // Your save logic here
}

5. How do I enable cell-level validation in WPF DataGrid?

To enable cell-level validation, you can handle the CellEditEnding event and perform validation manually based on the edited cell.

private void MyDataGrid_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
{
    if (e.EditingElement is TextBox textBox)
    {
        var person = e.Row.Item as Person;
        if (person != null)
        {
            if (e.Column.Header.ToString() == "Name")
            {
                person.Name = textBox.Text;
            }
            else if (e.Column.Header.ToString() == "Age")
            {
                int age;
                if (int.TryParse(textBox.Text, out age))
                {
                    person.Age = age;
                }
            }
            else
            {
                MessageBox.Show("Invalid input!");
            }
        }
    }
}

6. How to bind validation errors to the DataGrid cells in WPF?

If you want to bind validation errors to cells, you can use an ErrorTemplate in your DataGrid column styles.

<DataGrid x:Name="MyDataGrid" IsReadOnly="False" AutoGenerateColumns="False" ItemsSource="{Binding Path=MyItems}">
    <DataGrid.CellStyle>
        <Style TargetType="DataGridCell">
            <Style.Triggers>
                <Trigger Property="Validation.HasError" Value="true">
                    <Setter Property="ToolTip"
                            Value="{Binding RelativeSource={RelativeSource Self}, Path=(Validation.Errors)[0].ErrorContent}" />
                </Trigger>
            </Style.Triggers>
        </Style>
    </DataGrid.CellStyle>
    <DataGrid.Columns>
        <DataGridTextColumn Header="Name" Binding="{Binding Path=Name, ValidatesOnDataErrors=True, UpdateSourceTrigger=PropertyChanged}" />
        <DataGridTextColumn Header="Age" Binding="{Binding Path=Age, ValidatesOnDataErrors=True, UpdateSourceTrigger=PropertyChanged}" />
    </DataGrid.Columns>
</DataGrid>

7. How to enable row-level validation in a WPF DataGrid?

For row-level validation, implement validation rules that check the row's integrity as a whole.

public class Person : INotifyPropertyChanged, IDataErrorInfo
{
    public string Name { get; set; }
    public int Age { get; set; }

    public string Error => null;

    public string this[string columnName]
    {
        get
        {
            if (columnName == "Name" && string.IsNullOrEmpty(Name))
            {
                return "Name is required.";
            }
            if (columnName == "Age" && (Age < 0 || Age > 120))
            {
                return "Age must be between 0 and 120.";
            }
            if (columnName == "Row")
            {
                if (string.IsNullOrEmpty(Name) || Age < 0 || Age > 120)
                {
                    return "Row contains invalid data.";
                }
            }
            return null;
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Row"));
    }
}

8. How to handle lost focus or data commit in WPF DataGrid?

You can handle the UnloadingRow or LostFocus events to perform actions such as committing changes or saving data when the user leaves a row.

<DataGrid x:Name="MyDataGrid" UnloadingRow="MyDataGrid_UnloadingRow" LostFocus="MyDataGrid_LostFocus" />

private void MyDataGrid_UnloadingRow(object sender, DataGridRowEventArgs e)
{
    // Commit changes or validate row data
}

private void MyDataGrid_LostFocus(object sender, RoutedEventArgs e)
{
    // Commit changes or validate row data
}

9. How to use `IDataErrorInfo` for custom validation in a WPF DataGrid?

IDataErrorInfo provides a simple mechanism to hook up validation to your data model.

public class Person : INotifyPropertyChanged, IDataErrorInfo
{
    public string Name { get; set; }
    public int Age { get; set; }

    public string Error => null;

    public string this[string columnName]
    {
        get
        {
            if (columnName == "Name" && string.IsNullOrEmpty(Name))
            {
                return "Name is required.";
            }
            if (columnName == "Age" && (Age < 0 || Age > 120))
            {
                return "Age must be between 0 and 120.";
            }
            return null;
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

10. How to implement asynchronous validation in a WPF DataGrid?

Asynchronous validation can be implemented using IValidatableObject. However, WPF does not natively support async validation, so you might need to use a different pattern or a third-party library to achieve true asynchronous validation.

Here’s a basic implementation of IValidatableObject: