();<\/p>\nRun the app again and click the Add Car button. You will see the new records appear appropriately.<\/p>\n
Implementing a Dirty Flag
private bool _isChanged; public bool IsChanged {
You need to set the IsChanged property to true in the OnPropertyChanged() method. You also need to make sure you aren\u2019t setting IsChanged to true when IsChanged is updated, or you will hit a stack overflow exception! Update the OnPropertyChanged() method to the following (which uses the nameof method discussed earlier):<\/p>\n
protected virtual void OnPropertyChanged( [CallerMemberName] string propertyName = "")
Open MainWindow.xaml and add an additional RowDefinition to the DetailsGrid. Add the following to the end of the Grid, which contains a Label and a CheckBox, bound to the IsChanged property, as follows:<\/p>\n
If you were to run the app now, you would see that every single record shows up as changed, even though you haven\u2019t changed anything! This is because object creation sets property values, and setting any values calls OnPropertyChanged(). This sets the object\u2019s IsChanged property. To correct this, set the
_cars.Add(
Run the app again, select a vehicle, and click the Change Color button. You will see the check box get selected along with the updated color.<\/p>\n
Updating the Source Through UI Interaction
Table 29-1. UpdateSourceTrigger Values<\/p>\n
Member Meaning in Life
The default source trigger for a TextBox is the LostFocus event. Change this to PropertyChanged by updating the binding for the Color TextBox to the following XAML:<\/p>\n
Now, when you run the app and start typing into the Color text box, the check box is immediately selected. You might ask why the default is set to LostFocus for TextBox controls. Any validation (covered in a moment) for a model fires in conjunction with the UpdateSourceTrigger. For a TextBox, this would then potentially cause errors continually flashing until the user entered the correct values. For example, if the validation rules don\u2019t allow less than five characters in a TextBox, the error would show on each keystroke until the user got five or more entered. In those cases, it\u2019s best to wait for the user to tab out of the TextBox (after completing the change to the text) to update the source.<\/p>\n
Wrapping Up Notifications and Observables
WPF Validations
Validation occurs when a data binding attempts to update the data source. In addition to built-in validations, such as exceptions in a property\u2019s setter, you can create custom validation rules. If any validation rule (built-in or custom) fails, the Validation class, discussed shortly, comes into play.<\/p>\n
\u25a0Note For each of the sections in this chapter, you can continue working in the same project from the previous section, or you can create a copy of the project for each new section. In the repo for this chapter, each section is a different project.<\/p>\n
Updating the Sample for the Validation Examples
The Validation Class
Table 29-2. Key Members of the Validation Class<\/p>\n
Member Meaning in Life
Validation Options
Notify on Exceptions
To test this, run the app, select a record from the ComboBox, and clear out the Id value. Since the Id property is defined as an int (not a nullable int), a numeric value is required. When you tab out of the Id field, an empty string is sent to the Id property by the binding framework, and since an empty string can\u2019t be converted to an int, an exception is thrown in the setter. Normally, an unhandled exception would generate a message box to the user, but in this case, nothing like that happened. If you look in the Debug portion of the Output window, you will see the following:<\/p>\n
System.Windows.Data Error: 7 : ConvertBack cannot convert value '' (type 'String'). BindingExpression:Path=Id; DataItem='Car' (HashCode=52579650); target element is 'TextBox' (Name=''); target property is 'Text' (type 'String') FormatException:'System. FormatException: Input string was not in a correct format.<\/p>\n
Visual display of the exception is a thin red box around the control, as shown in Figure 29-2.<\/p>\n
Figure 29-2. The default error template<\/p>\n
The red box is the ErrorTemplate property of the Validation object and acts as an adorner for the bound control. While the default error adorner shows that there is indeed an error, there isn\u2019t any indication as to what is wrong. The good news is that the ErrorTemplate is completely customizable, as you will see later in this chapter.<\/p>\n
IDataErrorInfo
The IDataErrorInfo interface, shown here, contains two properties: an indexer and a string property named Error. Note that the WPF binding engine doesn\u2019t use the Error property.<\/p>\n
public interface IDataErrorInfo
You will be adding the Car partial class shortly, but first you need to update the Car.cs class and mark it as partial. Next, add another file to the Models directory named CarPartial.cs. Rename this class Car, make sure the class is marked as partial, and add the IDataErrorInfo interface. Finally, implement the API for the interface. The initial code is listed here:<\/p>\n
public partial class Car : IDataErrorInfo
For a bound control to opt in to the IDataErrorInfo interface, it must add ValidatesOnDataErrors to the binding expression. Update the binding expression for the Make text box to the following (and update the rest of the binding statements in the same way):<\/p>\n
Once this update is made to the binding statements, the indexer on the model gets called each time the
public string this[string columnName]
internal string CheckMakeAndColor()
Run the app, select the Red Rider vehicle (the Ford), and change the Make to ModelT. Once you tab out of the field, the red error decorator appears. Now select Kit (which is a Chevy) from the drop-down and
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = "")
\/\/PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); PropertyChanged?.Invoke(this,
Now, when you run the same test, you see that both the Make and Color text boxes are adorned with the error template when one of them is updated. So, why not always raise the event in this manner? It\u2019s largely a matter of performance. It\u2019s possible that refreshing every property on an object could hamper performance. Of course, there\u2019s no way to know without testing, and your mileage may (and probably will) vary.
INotifyDataErrorInfo
public interface INotifyDataErrorInfo ErrorsChanged;The HasErrors property is used by the binding engine to determine whether there are any errors on any of the instance\u2019s properties. If the GetErrors() method is called with a null or empty string for the propertyName parameter, it returns all errors that exist in the instance. If a propertyName is passed into the method, only
Implement the Supporting Code
public partial class Car: INotifyDataErrorInfo, IDataErrorInfo
public bool HasErrors { get; } public event ErrorsChanged;Next, add a Dictionary<string,List> that will hold any errors grouped by property name, as shown here:<\/p>\nprivate readonly Dictionary<string,List> _errors>();<\/p>\nThe HasErrors property should return true if there are any errors in the dictionary. This is easily accomplished like this:<\/p>\n
public bool HasErrors => _errors.Any();<\/p>\n
Next, create a helper method to raise the ErrorsChanged event (just like raising the PropertyChanged
private void OnErrorsChanged(string propertyName)
As mentioned earlier, the GetErrors() method should return any and all errors in the dictionary if the parameter is empty or null. If a propertyName value is passed in, it will return any errors found for that property. If the parameter doesn\u2019t match (or there aren\u2019t any errors for a property), then the method will return null.<\/p>\n
public IEnumerable GetErrors(string propertyName)
The final set of helpers will add one or more errors for a property or clear all of the errors for a property (or all properties). Any time the dictionary changes, remember to call the OnErrorsChanged() helper method.<\/p>\n
private void AddError(string propertyName, string error) { error }); errors)<\/p>\n{()); changed = true;Now the question is \u201chow is this code activated?\u201d The binding engine listens for the ErrorsChanged
Use INotifyDataErrorInfo for Validations
public string Make
_make = value;
The main issue with this approach is you have to combine validation logic with property setters, making the code harder to read and support.<\/p>\n
Combine IDataErrorInfo with INotifyDataErrorInfo for Validations
public string this[string columnName]
break;
Run the app, select Chevy, and change the color to Pink. In addition to the red adorners around the Make and Model text boxes, you will also see a red box adorner around the entire grid that holds the Car details fields (shown in Figure 29-3).<\/p>\n
Figure 29-3. The updated error adorner<\/p>\n
This is another advantage of using INotifyDataErrorInfo. In addition to the controls in error, the control defining the data context also gets adorned with the error template.<\/p>\n
Show All Errors
Add a DataTemplate to the ListBox, and in the DataTemplate, add a ListBox that is bound to the ErrorContent property. The data context for each ListBoxItem in this case is a ValidationError object, so you don\u2019t need to set the data context, just the path. Set the binding path to ErrorContent, like this:<\/p>\n
Run the app, select Chevy, and set the color to Pink. You will see the errors displayed in Figure 29-4.<\/p>\n
Figure 29-4. Showing the errors collection<\/p>\n
This just scratches the surface of what you can do with validations and with displaying the errors generated, but it should have you well on your way to developing informative UIs that improve the user experience.<\/p>\n
Move the Support Code to a Base Class
using System;
namespace Validations.Models
Move all of the code from CarPartial.cs that relates to INofityDataErrorInfo into the new base class.
public partial class Car : BaseEntity, IDataErrorInfo
Now, any additional model classes you create will inherit all of the INotifyDataErrorInfo plumbing code.<\/p>\n
Leverage Data Annotations with WPF
Add Data Annotations to the Model
Check for Data Annotation\u2013Based Validation Errors
using System.ComponentModel;
Next, create a new method named GetErrorsFromAnnotations(). This method is generic, takes a string property name and a value of type T as the parameters, and returns a string array. Make sure the method is marked as protected. The signature is listed here:<\/p>\n
protected string[] GetErrorsFromAnnotations( string propertyName, T value)In the method, create a List variable that will hold the results of validation checks and create a ValidationContext scoped to the property name passed into the method. When you have those two items in place, call Validate.TryValidateProperty, which returns a bool. If everything passes (in regard to data annotation validations), it returns true. If not, it returns false and populates the List with the errors. The complete code is shown here:<\/p>\nprotected string[] GetErrorsFromAnnotations(<\/p>\nstring propertyName, T value)();Now you can update the indexer method in CarPartial.cs to check for any errors based on data annotations. If any errors are found, add them to the errors collection supporting INotifyDataErrorInfo. This enables us to clean up the error handling. In the start of the indexer method, clear the errors for the column.
public string this[string columnName]
Run the app, select one of the vehicles, and add text for the color that is longer than 50 characters. When you cross the 50-character threshold, the StringLength data annotation creates a validation error, and it is reported to the user, as shown in Figure 29-5.<\/p>\n
Figure 29-5. Validating the required data annotation<\/p>\n
Customizing the ErrorTemplate