Validation of data in the DataGrid by "columns"

Introduction

In my WPF projects, I mainly use a DataGrid to display data. This control is very convenient, easy to use and also with the release of Visual Studio 2010 is part of the 4th framework.

So, if it is necessary to change the data in the table (DataGrid), I offered the user a modal window in which the data of the object marked in the table was displayed. And the user changed this very object depending on the need. Data validation occurred before the user closes the window. Everything worked smoothly.
')
But once it became necessary to provide the ability for the user to change data directly in the table (as in Excel), without calling the modal window. We must do it.

But when implementing this very action, I ran into one problem: data validation. And if you specifically need to avoid entering the same data into the table. It must be said that the DataGrid contains support for data validation implemented by the ValidationRule object. But the fact is that data validation took place within the limits of the actual object. That is, validation was performed on the “string” DataGrid and not on the “column”. Google could not help. So I had to think a little.

Implementation

So, let's try to validate in the DataGrid by “columns”.

To begin with we will be defined with object which we will be changes. This will be a Person object. But before proceeding with the implementation of this object, create a helper class WPFBase that implements INotifyPropertyChanged to report data changes in the Person object:

public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .

1. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
2. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
3. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
5. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
6. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
7. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
8. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
9. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
10. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
11. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
14. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
15. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
16. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
17. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .
18. public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .

public class WPFBase : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; public void OnPropertyChanged( string PropertyName) { if (PropertyChanged != null ) { this .PropertyChanged( this , new PropertyChangedEventArgs(PropertyName)); } } public void OnPropertyChanged(MethodBase MethodeBase) { this .OnPropertyChanged(MethodeBase.Name.Substring(4)); } }
* This source code was highlighted with Source Code Highlighter .

Now create a Person class that contains two properties: Name and Vorname. And we inherit it from WPFBase:

1. public partial class Person: WPFBase
2. {
3. private string _Name;
4. private string _Vorname;
6. public string Vorname
7. {
8. get { return _Vorname; }
9. set {_Vorname = value ; OnPropertyChanged (MethodInfo.GetCurrentMethod ()); }
10. }
13. public string Name
14. {
15. get { return _Name; }
16. set {_Name = value ; OnPropertyChanged (MethodInfo.GetCurrentMethod ()); }
17. }
20. }

* This source code was highlighted with Source Code Highlighter .

You probably noticed that the Person class is designated as partial. This is done for convenience, since we are implementing a couple more interfaces and for readability we divide the class into three parts.

So, we implement the IDataErrorInfo interface. In object-oriented programming, each object is responsible for itself and for the data it contains. Therefore, let the Person object itself worry about how it is “stuffed”. Let's start:

1. public partial class Person: IDataErrorInfo
2. {
3. public string Error
4. {
5. get
6. {
7. string error;
8. StringBuilder sb = new StringBuilder ();
10. error = this [ "Name" ];
11. if (error! = string .Empty)
12. sb.AppendLine (error);
14. error = this [ "Vorname" ];
15. if (error! = string .Empty)
16. sb.AppendLine (error);
18. if (! string .IsNullOrEmpty (sb.ToString ()))
19. return sb.ToString ();
21. return "" ;
22. }
23. }
25. public string this [ string columnName]
26. {
27. get
28. {
29. switch (columnName)
30. {
31. case "Name" :
32. if ( string .IsNullOrEmpty ( this .Name))
33. Return "Enter the name !!!" ;
34. break ;
35. case "Vorname" :
36. if ( string .IsNullOrEmpty ( this .Vorname))
37. Return "Enter the surname !!!" ;
38. break ;
39. default :
40. break ;
41. }
42. return "" ;
43. }
44. }
45. }

* This source code was highlighted with Source Code Highlighter .

Well, we have ensured that if there is no data in the Name and Vorname properties of the Person object, a message is returned indicating that it is necessary to enter a first or last name.

Well, the final touch: let's implement the IDataEditObject interface. It is necessary so that in case of input of invalid data into the Person object, when the input operation is canceled, the data will return to its original position:

1. public partial class Person: IEditableObject
2. {
3. bool inEdit = false ;
4. Person tempPerson;
6. public void BeginEdit ()
7. {
8. if (inEdit)
9. return ;
11. inEdit = true ;
12. tempPerson = new Person ();
13. tempPerson.Name = this .Name;
14. tempPerson.Vorname = this .Vorname;
15. }
17. public void CancelEdit ()
18. {
19. if (! inEdit)
20. return ;
22. inEdit = false ;
23. this .Name = tempPerson.Name;
24. this .Vorname = tempPerson.Vorname;
25. tempPerson = null ;
26. }
28. public void EndEdit ()
29. {
31. if (! inEdit)
32. return ;
34. inEdit = false ;
35. tempPerson = null ;
36. }
37. }

* This source code was highlighted with Source Code Highlighter .

Create another class ListPerson inheriting from ObservableCollection <Person>. The Personen object will be used as a container for Person objects. Well, for ease of testing, we immediately add to the ListPerson collection several objects:

1. public class ListPerson: ObservableCollection <Person>
2. {
3. public ListPerson ()
4. {
5. this .Add ( new Person ()
6. {
7. Name = "Ivanov" ,
8. Vorname = "Sergey"
9. });
10. this .Add ( new Person ()
11. {
12. Name = "Petrov" ,
13. Vorname = "Andrew"
14. });
15. }
16. }

* This source code was highlighted with Source Code Highlighter .

We add the ListPerson collection to the window resources:

1. < Window.Resources >
2. < dt: ListPerson x: Key = "ListPerson" />
3. </ Windows.Resources >

* This source code was highlighted with Source Code Highlighter .

And we inform our table where the data is located:

1. < DataGrid ItemsSource = "{Binding Source = {StaticResource ListPerson}}" />

* This source code was highlighted with Source Code Highlighter .

Now add the following code to the DataGrid:

1. < DataGrid.RowValidationRules >
2. < DataErrorValidationRule ValidationStep = "UpdatedValue" />
3. </ DataGrid.RowValidationRules >

* This source code was highlighted with Source Code Highlighter .

What does this mean: we added a new rule to the DataGrid rules collection, which reports that after changing the data in the Person object, it is necessary to check whether the object itself does not indicate that the data does not comply with the rules we specified when implementing the IDataErrorInfo interface . If so, the DataGrid will respond to the error.

What we lack is that for which we actually started all this: to prevent the entry of the same data in the table.

To do this, create a new class ValidationRule but with our own criteria for checking the validity of the data. In addition, we will need to create an additional property that refers to the same object container as the DataGrid itself. In order for XAML to bind data to this property, it is necessary to declare it as a DependencyProperty. The problem is that for this the object must be inherited from the DependencyObject class. Our new rule inherits from ValidationRule. Therefore, we simply simply create an additional class ListPersonHelper and inherit it from DependencyObject. Okay, stop talking. Let's look at the code better:

1. class ColumnValidation: ValidationRule
2. {
3. private ListPersonHelper _ListPerson;
5. // This property is auxiliary; it is used to implement DependencyProperty
6. public ListPersonHelper ListPerson
7. {
8. get { return _ListPerson; }
9. set {_ListPerson = value ; }
10. }
13. // Check for valid data
14. public override ValidationResult Validate
15. ( object value , System.Globalization.CultureInfo cultureInfo)
16. {
17. BindingGroup bg = value as BindingGroup;
18. Person person = bg.Items [0] as Person;
20. // If there is an object with the same name or surname in the collection, we report an error!
21. var result = from p in ListPerson.Items
22. where p! = person &&
23. (p.Name == person.Name
24. || p.Vorname == person.Vorname)
25. select p;
26. if (result.Any ())
27. {
28. return new ValidationResult ( false , "First Name or Last Name already in the database" );
29. }
31. return ValidationResult.ValidResult;
32. }
33. }
35. // Helper class for implementing DependencyProperty
36. public class ListPersonHelper: DependencyObject
37. {
38. // You can privatize the data in the XAML property to the Items property, since it is declared as a DependencyProperty
39. public ListPerson Items
40. {
41. get { return (ListPerson) GetValue (ItemsProperty); }
42. set {SetValue (ItemsProperty, value ); }
43. }
45. public static readonly DependencyProperty ItemsProperty =
46. DependencyProperty.Register
47. ( "Items" ,
48. typeof (ListPerson),
49. typeof (ListPersonHelper),
50. new UIPropertyMetadata ( null ));
53. }

* This source code was highlighted with Source Code Highlighter .

We add ListPersonHelper to window resources. The Items property is set to the same data source as the DataGrid. In the table's ValidationRules, add our new ColumnValidation rule. The ListPerson property is pointed to the ListPerson resource. That's all:

1. < Window x: Class = "DPTest.MainWindow"
2. xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3. xmlns: x = "http://schemas.microsoft.com/winfx/2006/xaml"
4. xmlns: dt = "clr-namespace: DPTest"
5. Title = "MainWindow" Height = "437" Width = "684" >
6. < Window.Resources >
7. < dt: ListPerson x: Key = "ListPerson" />
8. < dt: ListPersonHelper x: Key = "ListPersonHelper"
9. Items = "{Binding Source = {StaticResource ListPerson}}" />
10. < ControlTemplate x: Key = "GridError" >
11. < Grid Margin = "0, -2.0, -2"
12. ToolTip = "{Binding RelativeSource = {RelativeSource
    
    FindAncestor, AncestorType = {x: Type DataGridRow}},
    
    Path = (Validation.Errors) [0] .ErrorContent} "
    >
13. < Ellipse StrokeThickness = "0" Fill = "Red"
14. Width = "{TemplateBinding FontSize}"
15. Height = "{TemplateBinding FontSize}" />
16. < TextBlock Text = "!" FontSize = "{TemplateBinding FontSize}"
17. FontWeight = "Bold" Foreground = "White"
18. HorizontalAlignment = "Center" />
19. </ Grid >
20. </ ControlTemplate >
21. </ Window.Resources >
22. < Grid >
23. < DataGrid ItemsSource = "{Binding Source = {StaticResource ListPerson}}"
24. AutoGenerateColumns = "False"
25. RowValidationErrorTemplate = "{StaticResource GridError}" >
26. < DataGrid.Columns >
27. < DataGridTextColumn
28. Binding = "{Binding Path = Vorname}"
29. Header = "Vorname" />
30. < DataGridTextColumn
31. Binding = "{Binding Path = Name}"
32. Header = "Name" />
33. </ DataGrid.Columns >
34. < DataGrid.RowValidationRules >
35. < DataErrorValidationRule
36. ValidationStep = "UpdatedValue" />
37. < dt: ColumnValidation
38. ValidationStep = "UpdatedValue" >
39. < dt: ColumnValidation.ListPerson >
40. < dt: ListPersonHelper
41. Items = "{Binding Source = {StaticResource ListPerson}}" />
42. </ dt: ColumnValidation.ListPerson >
43. </ dt: ColumnValidation >
44. </ DataGrid.RowValidationRules >
45. </ Datagrid >
46. </ Grid >
47. </ Window >

* This source code was highlighted with Source Code Highlighter .

An example can be downloaded here: DataGridColumnValidation.zip (71,37 kb)