The ErrorProvider and the Validation Application Block

if you try lesson 7 from the Hands-On lab (http://www.microsoft.com/downloads/details.aspx?FamilyID=2C34A9CB-17CF-4AEC-8DE6-EEACBBB74413&displaylang=en), you will have an example of my scenario.

In this lesson, you have a single ErrorProvider (as only one is required for each form) and 2 ValidationProvider because there are 2 classes that expose validation.

Good lab.

1) City doesn't seem to validate correctly, but I don't understand the error.  Here is the configuration for City validation:

            <validator type="Microsoft.Practices.EnterpriseLibrary.Validation.Validators.AndCompositeValidator, Microsoft.Practices.EnterpriseLibrary.Validation, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
              name="And Composite Validator">
              <validator lowerBound="1" lowerBoundType="Inclusive" upperBound="30"
                upperBoundType="Inclusive" negated="false" messageTemplate=""
                messageTemplateResourceName="" messageTemplateResourceType=""
                tag="" type="Microsoft.Practices.EnterpriseLibrary.Validation.Validators.StringLengthValidator, Microsoft.Practices.EnterpriseLibrary.Validation, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                name="String Length Validator" />
              <validator characterSet="sea" containsCharacter="All" negated="false"
                messageTemplate="" messageTemplateResourceName="" messageTemplateResourceType=""
                tag="" type="Microsoft.Practices.EnterpriseLibrary.Validation.Validators.ContainsCharactersValidator, Microsoft.Practices.EnterpriseLibrary.Validation, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                name="Contains Characters Validator" />
            </validator>

2) Contains Character Validator:
http://msdn.microsoft.com/en-us/library/cc309338.aspx

3) Validation providers are extender providers (PerformValidation, SourcePropertyName, ValidatedProperty)

4) PerformValidation help says, "Indicates whether automatic validation should be performed for this component when the Validating event is fired".  That means that the provider automatically attaches to the Validating event to prevent a control from losing focus, until the entry is valid.  Set to False to disable that effect.

OK, I was wrong about the PerformValidation, because that would mean that it doesn't validate.  Also, I entired 'seattle' (not Seattle), to get a valid city value.

yes the Contains validator seems to be case sensitive.

And as you found, if PerformValidation is set to False, the ErrorProvider is bypassed.

What I would like is to be able to navigate from one field to another without having the validation successful. Currently, if your cursor is in FirstName, you cannot even close the window as long as the validation is not successful. Users will never accept that (at least mine)!

I found the relevant code in the source code.  I don't see anything that you can do to circumvent this action.  How would you like to handle this?  Just integrate with the ErrorProvider, without setting e.Cancel in the OnValidating method?

ValidatedControlItem:

       /// <summary>
        /// Initialize a new instance of the <see cref="ValidatedControlItem"/> class with a <see cref="validationProvider"/> and a <see cref="Control"/>.
        /// </summary>
        /// <param name="validationProvider">The validation provider.</param>
        /// <param name="control">The control to validate.</param>
        public ValidatedControlItem(ValidationProvider validationProvider,
                                    Control control)
        {
            this.validationProvider = validationProvider;
            this.control = control;
            this.control.Validating += OnValidating;
            isValid = true;
            validatedPropertyName = ValidationProvider.DefaultValidatedProperty;
        }
 
 
...
 
       void OnValidating(object source,
                          CancelEventArgs e)
        {
            if (PerformValidation)
            {
                validationProvider.PerformValidation(this);
                e.Cancel = !IsValid;
            }
        }
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

Your idea is good but I cannot make it to work.

Is PerformValidation a module level variable? Just like IsValid and validationProvider and control and validatedPropertyName? Or is this code not generic at a

is ValidatedControlItem a void method?

I think something is missing but we are getting somewhere.

You can find the WinForms validation providers in the Validation.Integration.WinForms project.  The ValidationProvider is an extender provider class that defined PerformValdation.

       /// <summary>
        /// Invokes the validation process for a control.
        /// </summary>
        /// <remarks>
        /// This method allows for programmatic invocation of the validation process. The control needs to be already
        /// configured for validation with the validation provider through the extender properties.
        /// </remarks>
        /// <param name="validatedControlItem">The validated control to validate.</param>
        /// <exception cref="ArgumentNullException">when <paramref name="validatedControlItem"/> is <see langword="null"/>.</exception>
        /// <exception cref="InvalidOperationException">when the <see cref="ValidationProvider.SourceTypeName"/> has not 
        /// been specified or is invalid.</exception>
        /// <exception cref="InvalidOperationException">when the source property name for the control to validate has not 
        /// been specified or is invalid.</exception>
        public void PerformValidation(ValidatedControlItem validatedControlItem)
        {
            if (enabled)
            {
                if (validatedControlItem == null)
                {
                    throw new ArgumentNullException("validatedControlItem");
                }
                Validator validator = validatedControlItem.Validator;
                if (validator != null)
                {
                    ValidationResults validationResults = validator.Validate(validatedControlItem);
                    validatedControlItem.IsValid = validationResults.IsValid;
 
                    if (errorProvider != null)
                    {
                        string errorProviderMessage = null;
 
                        if (!validationResults.IsValid)
                        {
                            errorProviderMessage = FormatErrorMessage(validationResults);
                        }
 
                        errorProvider.SetError(validatedControlItem.Control, errorProviderMessage);
                    }
 
                    if (ValidationPerformed != null)
                    {
                        ValidationPerformed(this, new ValidationPerformedEventArgs(validatedControlItem.Control, validationResults));
                    }
                }
            }
        }
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:

Once again, you have variables/methods declared outside this snippet. Can you provide the complete sample?

I am showing you the code that is in the open-source Validation Application Block.  The source code gets installed when you install the Enterprise Library, so that you can customize your own experience.

Ok now I understand. I thought it was some code you wrote. I will have a look at this if I could shadow the method.

the class is sealed so I cannot inherit from it and only shadows the method that is not working like I would.

I tried commenting out the "e.Cancel = !IsValid;" line but now it gives all kind of configuration errors!

I will continue to work on this tomorrow.

I just found something VERY interesting. I cannot keep it for myself!

Instead of modifying the source code of the library, I just discovered that the form has a property named AutoValidate. It defaults to EnablePreventFocusChange. If you change it to EnableAllowFocusChange, it will allow you to change the focus without having a successful validation.