Shulou(Shulou.com)06/01 Report--

In this article Xiaobian detailed introduction of "MVVMLight how to bind in the form verification", the content is detailed, the steps are clear, the details are handled properly, I hope this "MVVMLight how to bind in the form verification" article can help you solve your doubts, the following follow the editor's ideas slowly in-depth, together to learn new knowledge.

Form validation is an important part of MVVM system. In addition to promoting the relationship between Model-View-ViewModel (MVVM) schema loosely coupled logic, data, and UI definitions, binding also provides powerful and flexible support for business data validation schemes.

The data binding mechanism in WPF includes options for verifying the validity of input data when creating editable views.

There are several common form validation mechanisms: the validation type states that Exception validates by setting the ValidatesOnExceptions property on a Binding object, and if an exception is thrown during the source object property setting a modified value, an error is thrown and a validation error is set for that Binding. ValidationRule verification

The Binding class has a property that provides a collection of instances of ValidationRule-derived classes. These ValidationRules need to override a Validate method that is called by Binding each time the data in the bound control changes.

If the Validate method returns an invalid ValidationResult object, a validation error is set for the Binding.

IDataErrorInfo verification

Binding invokes the IDataErrorInfo API exposed from the bound data source object by implementing the IDataErrorInfo interface on the bound data source object and setting the ValidatesOnDataErrors property on the Binding object.

If a non-null or non-empty string is returned from these property calls, a validation error is set for that Binding.

Verify the relational schema of the interaction as shown in the figure:

When we use data binding in WPF to render business data, we usually use the Binding object to provide a data pipeline between the individual properties of the target control and the properties of the data source object.

If you want to make binding validation valid, you first need to do TwoWay data binding. This indicates that in addition to the data that flows from the source attribute to the target attribute for display, the edited data flows from the destination to the source.

This is the essence of great two-way data binding, so it's much easier to do data validation in MVVM.

When data is entered or modified in TwoWay data binding, the following workflow is started:

1. The user inputs or modifies the data through the keyboard, mouse, handwriting pad or other input device, thus changing the bound target information 2 and setting the source attribute value. 3. Trigger the Binding.SourceUpdated event. 4. If the setter on the data source property throws an exception, the exception is caught by Binding and can be used to indicate a validation error. 5. If the IDataErrorInfo interface is implemented, the method of the interface will be called on the data source object to get the error message of the property. 6. Present the validation error indication to the user and trigger the Validation.Error additional event.

The binding target sends a request for data update to the binding source, while the binding source validates the data and gives feedback according to different verification mechanisms.

Let's compare these verification mechanisms with examples below. Before that, let's write an error-triggered style to ensure that the error is triggered directly and clearly to the user.

Let's create a new resource dictionary file, named TextBox.xaml, and the following is the contents of the resource dictionary file. The target type is TextBoxBase-based controls, such as TextBox and RichTextBox.

The code is relatively simple, pay attention to the red content, design a red background white word prompt box, when the source attribute triggers error verification, the error content in the verification object collection is displayed.

Then register globally in App.Xaml to the entire application.

The results are as follows:

The three verification modes 1 and Exception verification are described in detail below:

As described in the instructions, a validation exception is thrown and thrown on the source field model with a binding relationship, and the ExceptionValidationRule property is set on the Xaml object in View in response to catching the exception and displaying it.

View Code:

ViewModel Code:

/ Exception verify / public class ValidateExceptionViewModel:ViewModelBase {public ValidateExceptionViewModel () {} private String userNameEx; / user name (not empty) / public string UserNameEx {get {return userNameEx } set {userNameEx = value; RaisePropertyChanged (() = > UserNameEx); if (string.IsNullOrEmpty (value)) {throw new ApplicationException ("this field cannot be empty!") ;}

The result is shown in the figure:

The information of verification failure is thrown directly, which is undoubtedly the simplest and roughest, and the implementation is also very simple, but it is only verified for a single source attribute, and the reusability is not high.

And in the case of combined validation (such as validating both non-null and other rules), it can lead to overwritten and bloated code in Model.

2. ValidationRule verification:

Extend the validation class we need to write by inheriting the ValidationRule abstract class and rewriting his Validate method. The validation class can be used directly in the properties we need to validate.

View Code:

Rewrite two ValidationRule with the following code:

Public class RequiredRule: ValidationRule {public override ValidationResult Validate (object value, CultureInfo cultureInfo) {if (value = = null) return new ValidationResult (false, "this field cannot be null!") ; if (string.IsNullOrEmpty (value.ToString () return new ValidationResult (false, "this field cannot be an empty string!") ; return new ValidationResult (true, null);} public class EmailRule: ValidationRule {public override ValidationResult Validate (object value, CultureInfo cultureInfo) {Regex emailReg = new Regex ("^\\ s * ([A-Za-z0-9 minutes -] + (\.\\ w+) * @ (\\ w +\.) +\\ w {2jol 5})\\ swatch $") If (! String.IsNullOrEmpty (value.ToString () {if (! emailReg.IsMatch (value.ToString () {return new ValidationResult (false, "inaccurate email address!") Return new ValidationResult (true, null);}

Two classes are created, one to verify that it is empty and one to verify that it conforms to the standard format of the mailbox address.

ViewModel Code:

Public class ValidationRuleViewModel:ViewModelBase {public ValidationRuleViewModel () {} # region attribute private String userName; / user name / public String UserName {get {return userName;} set {userName = value; RaisePropertyChanged (() = > UserName);}} private String userEmail / user email / public String UserEmail {get {return userEmail;} set {userEmail = value;RaisePropertyChanged (() = > UserName);}} # endregion

The results are as follows:

Explanation: relatively speaking, this way is relatively good, independence, reusability are very good, from the loose coupling point of view is also more appropriate.

A series of validation rule classes can be written in advance, and the view coders can use these validation rules directly according to their needs without additional processing on the server side.

However, there are still some shortcomings, poor scalability, and additional expansion if personalized feedback messages are needed. Does not meet the increasingly rich front-end verification requirements.

3. IDataErrorInfo verification:

3.1. implement the IDataErrorInfo interface on the bound data source object

3.2.Setting the ValidatesOnDataErrors property on the Binding object

Binding invokes the IDataErrorInfo API exposed from the bound data source object. If a non-null or non-empty string is returned from these property calls, a validation error is set for that Binding.

View Code:

ViewModel Code:

Public class BindingFormViewModel: ViewModelBase, IDataErrorInfo {public BindingFormViewModel () {} # region attribute private String userName; / username / public String UserName {get {return userName;} set {userName = value;}} private String userPhone / / user phone / public String UserPhone {get {return userPhone;} set {userPhone = value;}} private String userEmail; / user email / public String UserEmail {get {return userEmail } set {userEmail = value;}} # endregion public String Error {get {return null;}} public String this [string columnName] {get {Regex digitalReg = new Regex (@ "^ [-]? [1-9] {8J 11}\ Dao$ | ^ [0] {1} $") Regex emailReg = new Regex ("^\\ s * ([A-Za-z0-9pm -] + (\\.\\ w+) * @ (\\ w+\ w) +\\ w {2pr. 5})\\ s $"); if (columnName = = "UserName" & & String.IsNullOrEmpty (this.UserName)) {return "username cannot be empty" } if (columnName = = "UserPhone" & &! String.IsNullOrEmpty (this.UserPhone)) {if (! digitalReg.IsMatch (this.UserPhone.ToString () {return "the user phone must be an 8-11 digit number!" ;} if (columnName = = "UserEmail" & &! String.IsNullOrEmpty (this.UserEmail)) {if (! emailReg.IsMatch (this.UserEmail.ToString () {return "user email address is incorrect!" ;} return null;}}

After inheriting the IDataErrorInfo interface, you implement two properties of the method: the Error property is used to indicate errors for the entire object, and the indexer is used to indicate errors at a single property level.

Each time the property value changes, the indexer checks to see if any validation error information is returned.

Both work the same way: if a non-null or non-empty string is returned, there is a validation error. Otherwise, the returned string is used to display the error to the user.

The result is shown in the figure:

The advantage of taking advantage of IDataErrorInfo is that it can be used to easily handle cross-coupling attributes. But it also has a big drawback:

The implementation of the indexer usually results in larger switch-case statements (each property name in the object corresponds to a case)

Must switch and match based on a string and return a string indicating an error. Also, the implementation of IDataErrorInfo is not called until the property value is set on the object.

In order to avoid a large number of switch-case, separate the verification logic to improve code reuse, and separate the verification rules and information in each model object, using DataAnnotations is undoubtedly the best solution.

So let's make some improvements:

View code, just like the one above:

VideModel Code:

Using GalaSoft.MvvmLight;using System;using System.Collections.Generic;using System.Linq;using System.ComponentModel;using System.ComponentModel.DataAnnotations;using GalaSoft.MvvmLight.Command;using System.Windows Namespace MVVMLightDemo.ViewModel {[MetadataType (typeof (BindDataAnnotationsViewModel))] public class BindDataAnnotationsViewModel: ViewModelBase, IDataErrorInfo {public BindDataAnnotationsViewModel () {} # region attribute / private Dictionary dataErrors = new Dictionary (); private String userName / user name / [Required] public String UserName {get {return userName;} set {userName = value;}} private String userPhone / user phone / [Required] [Regular_Expression (@ "^ [-]? [1-9] {8 ~ 11}\ $$| ^ [0] {1} $", ErrorMessage = "user phone must be 8-11 digits.")] Public String UserPhone {get {return userPhone;} set {userPhone = value;}} private String userEmail / user email / [Required] [StringLength (100 minimumLengthreading 2)] [Regular_Expression ("^\\ s * ([A-Za-z0-9 steps -] + (\\ w +) * @ (\\ w +\.) +\\ w {2pm 5})\\ s email $", ErrorMessage = "Please fill in the correct email address.")] Public String UserEmail {get {return userEmail;} set {userEmail = value;} # endregion # region Command private RelayCommand validFormCommand / validation form / public RelayCommand ValidFormCommand {get {if (validFormCommand = = null) return new RelayCommand (() = > ExcuteValidForm ()); return validFormCommand;} set {validFormCommand = value }} / validation form / private void ExcuteValidForm () {if (dataErrors.Count = = 0) MessageBox.Show ("validation passed!") ; else MessageBox.Show ("validation failed!") # endregion public string this [string columnName] {get {ValidationContext vc = new ValidationContext (this, null, null); vc.MemberName = columnName; var res = new List (); var result = Validator.TryValidateProperty (this.GetType (). GetProperty (columnName) .GetValue (this, null), vc, res) If (res.Count > 0) {AddDic (dataErrors,vc.MemberName); return string.Join (Environment.NewLine, res.Select (r = > r.ErrorMessage). ToArray ());} RemoveDic (dataErrors,vc.MemberName); return null }} public string Error {get {return null } # region attachment method / remove dictionary / private void RemoveDic (Dictionary dics, String dicKey) {dics.Remove (dicKey) Add dictionary / private void AddDic (Dictionary dics, String dicKey) {if (! dics.ContainsKey (dicKey)) dics.Add (dicKey, ");} # endregion}}

DataAnnotations believes that many people are familiar with it and can use data annotations to customize the user's model data. Remember to reference System.ComponentModel.DataAnnotations.

It contains the following authentication types:

The validation property indicates that CustomValidationAttribute uses a custom method for validation. DataTypeAttribute specifies a specific type of data, such as an e-mail address or phone number. EnumDataTypeAttribute ensures that the value exists in the enumeration. RangeAttribute specifies minimum and maximum constraints. RegularExpressionAttribute uses regular expressions to determine valid values. RequiredAttribute specifies that a value must be provided. StringLengthAttribute specifies the maximum and minimum number of characters. ValidationAttribute is used as the base class for validation properties.

Here we use RequiredAttribute, StringLengthAttribute and RegularExpressionAttribute. If you need to know more about DataAnnotations, please refer to Microsoft's official website:

Https://msdn.microsoft.com/en-us/library/dd901590(VS.95).aspx

After using DataAnnotions, the Model is more concise and the verification is more flexible. Can be superimposed combined verification, in the face of complex verification patterns, you can freely use regularities to verify.

By default, the framework provides the corresponding message content that requires feedback, but you can also customize the error message content: ErrorMessage.

Here we also add a global error collection collector: dataErrors to determine whether the verification is passed or not when submitting the judgment.

Here we further encapsulate the indexer and use reflection technology to read the properties under the current field for verification.

The results are as follows:

Encapsulate the ValidateModelBase class:

The above verification is reasonable, but it is still too cumbersome for developers, who are concerned with the configuration of Model's DataAnnotations rather than how to do validation in this ViewModel, so we further abstract.

Write a ValidateModelBase and put all the work you need to deal with in it. The Model that validates the property is required to inherit the base class. As follows:

ValidateModelBase class, please note the red section:

Public class ValidateModelBase: ObservableObject, IDataErrorInfo {public ValidateModelBase () {} # region attribute / when validation error set / private Dictionary dataErrors = new Dictionary () / whether the verification passed / public Boolean IsValidated {get {if (dataErrors! = null & & dataErrors.Count > 0) {return false;} return true } # endregion public string this [string columnName] {get {ValidationContext vc = new ValidationContext (this, null, null); vc.MemberName = columnName; var res = new List () Var result = Validator.TryValidateProperty (this.GetType (). GetProperty (columnName) .GetValue (this, null), vc, res); if (res.Count > 0) {AddDic (dataErrors, vc.MemberName); return string.Join (Environment.NewLine, res.Select (r = > r.ErrorMessage). ToArray ()) } RemoveDic (dataErrors, vc.MemberName); return null;}} public string Error {get {return null } # region attachment method / remove dictionary / private void RemoveDic (Dictionary dics, String dicKey) {dics.Remove (dicKey) Add dictionary / private void AddDic (Dictionary dics, String dicKey) {if (! dics.ContainsKey (dicKey)) dics.Add (dicKey, ");} # endregion}

Validated model class: inherits ValidateModelBase

[MetadataType (typeof (BindDataAnnotationsViewModel))] public class ValidateUserInfo: ValidateModelBase {# region attribute private String userName; / user name / [Required] public String UserName {get {return userName;} set {userName = value; RaisePropertyChanged (() = > UserName);}} private String userPhone / user phone / [Required] [Regular_Expression (@ "^ [-]? [1-9] {8 ~ 11}\ $$| ^ [0] {1} $", ErrorMessage = "user phone must be 8-11 digits.")] Public String UserPhone {get {return userPhone;} set {userPhone = value; RaisePropertyChanged (() = > UserPhone);}} private String userEmail / user email / [Required] [StringLength (100, MinimumLength = 2)] [Regular_Expression ("^\\ s * ([A-Za-z0-9 minutes -] + (\\.\\ w+) * @ (\\ w+\\) +\\ w {2jin5})\\ s email $", ErrorMessage = "Please fill in the correct email address.")] Public String UserEmail {get {return userEmail;} set {userEmail = value; RaisePropertyChanged (() = > UserEmail);}} # endregion}

The ViewModel code is as follows:

Public class PackagedValidateViewModel:ViewModelBase {public PackagedValidateViewModel () {ValidateUI = new Model.ValidateUserInfo ();} # region global properties private ValidateUserInfo validateUI; / user information / public ValidateUserInfo ValidateUI {get {return validateUI } set {validateUI = value; RaisePropertyChanged (() = > ValidateUI);}} # endregion # region global command private RelayCommand submitCmd; public RelayCommand SubmitCmd {get {if (submitCmd = = null) return new RelayCommand (() = > ExcuteValidForm ()) Return submitCmd;} set {submitCmd = value;} # endregion # region accessory method / private void ExcuteValidForm () {if (ValidateUI.IsValidated) MessageBox.Show ("Verification passed!") ; else MessageBox.Show ("validation failed!") ;} # endregion}

The results are as follows:

After reading this, the article "how to bind MVVMLight to form validation" has been introduced. If you want to master the knowledge points of this article, you still need to practice and use it yourself. If you want to know more about related articles, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.