Passing state of WPF ValidationRule to View Model

Question

I am stuck in a seemingly common requirement. I have a WPF Prism (for MVVM) application. My model implements the IDataErrorInfo for validation. The IDataErrorInfo works great for non-numeric properties. However, for numeric properties, if the user enters invalid characters (which are not numeric), then the data doesn't even reach the model because wpf cannot convert it to numeric type.

So, I had to use WPF ValidationRule to provide user some meaningful message for invalid numeric entries. All the buttons in the view are bound to DelegateCommand of prism (in view model) and the enabling/disabling of buttons is done in View Model itself.

Now if a wpf ValidationRule fail for some TextBox, how do I pass this information to View Model so that it can appropriately disable buttons in the view ?

Answer 1

You must specify custome user control depending bind type property. For example if your property is int type you must place control that not allow diferent value except intenger type.

The logic you may put in PreviewTextInput="NumberValidationTextBox".

private void NumberValidationTextBox(object sender, TextCompositionEventArgs e)
    { 
        Regex regex = new Regex("[^0-9]+");
        e.Handled = regex.IsMatch(e.Text);
    }

just insert your logic or place custome control and you are done.

Defently must implement mvvm validation too.

Answer 2

I have the same problem with you, but I solve in another way, I use the Triggers to disable the button when the input is invalid. Meanwhile, the textbox binding should use ValidatesOnExceptions=true

<Style TargetType="{x:Type Button}">
<Style.Triggers>
    <DataTrigger Binding="{Binding ElementName=tbInput1, Path=(Validation.HasError)}" Value="True">
        <Setter Property="IsEnabled" Value="False"></Setter>
    </DataTrigger>

    <DataTrigger Binding="{Binding ElementName=tbInput2, Path=(Validation.HasError)}" Value="True">
        <Setter Property="IsEnabled" Value="False"></Setter>
    </DataTrigger>
</Style.Triggers>

Answer 3

1. Implement IDataErrorInfo in your model or Viewmodel depending logic of binding property. You may implement in both classes.

2. Implement this too in your base validation class. Here validation will trigger when binding IDataErrorInfo does not work.

   public virtual bool HasError
   {
       get { return _hasError; } 
       set
       {
           // if (value.Equals(_hasError)) return;
           _hasError = value;
           RaisePropertyChanged(() => HasError);
       }
   }
   

3. Next, add global class

   public class ProtocolSettingsLayout
   {
       public static readonly DependencyProperty MVVMHasErrorProperty = DependencyProperty.RegisterAttached("MVVMHasError", typeof(bool), typeof(ProtocolSettingsLayout), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, null, CoerceMVVMHasError));
   
       public static bool GetMVVMHasError(DependencyObject d)
       {
           return (bool)d.GetValue(MVVMHasErrorProperty);
       }
   
       public static void SetMVVMHasError(DependencyObject d, bool value)
       {
           d.SetValue(MVVMHasErrorProperty, value);
       }
   
       private static object CoerceMVVMHasError(DependencyObject d, Object baseValue)
       {
           bool ret = (bool)baseValue;
   
           if (BindingOperations.IsDataBound(d, MVVMHasErrorProperty))
           {
               if (GetHasErrorDescriptor(d) == null)
               {
                   DependencyPropertyDescriptor desc = DependencyPropertyDescriptor.FromProperty(Validation.HasErrorProperty, d.GetType());
                   desc.AddValueChanged(d, OnHasErrorChanged);
                   SetHasErrorDescriptor(d, desc);
                   ret = System.Windows.Controls.Validation.GetHasError(d);
               }
           }
           else
           {
               if (GetHasErrorDescriptor(d) != null)
               {
                   DependencyPropertyDescriptor desc = GetHasErrorDescriptor(d);
                   desc.RemoveValueChanged(d, OnHasErrorChanged);
                   SetHasErrorDescriptor(d, null);
               }
           }
           return ret;
       }
   
       private static readonly DependencyProperty HasErrorDescriptorProperty = DependencyProperty.RegisterAttached("HasErrorDescriptor",
                                                                               typeof(DependencyPropertyDescriptor),
                                                                               typeof(ProtocolSettingsLayout));
   
       private static DependencyPropertyDescriptor GetHasErrorDescriptor(DependencyObject d)
       {
           var ret = d.GetValue(HasErrorDescriptorProperty);
           return ret as DependencyPropertyDescriptor;
       }
   
       private static void OnHasErrorChanged(object sender, EventArgs e)
       {
           DependencyObject d = sender as DependencyObject;
   
           if (d != null)
           {
               d.SetValue(MVVMHasErrorProperty, d.GetValue(Validation.HasErrorProperty));
           }
       }
   
       private static void SetHasErrorDescriptor(DependencyObject d, DependencyPropertyDescriptor value)
       {
           var ret = d.GetValue(HasErrorDescriptorProperty);
           d.SetValue(HasErrorDescriptorProperty, value);
       }
   }
   

4. xaml

   <TextBox  PreviewTextInput="NumValidationTextBox" Text="{Binding ESec, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=true, NotifyOnValidationError=true, ValidatesOnExceptions=True, NotifyOnSourceUpdated=True, NotifyOnTargetUpdated=True, TargetNullValue='0', FallbackValue='0' }" Validation.ErrorTemplate="{StaticResource validationTemplate}" viewmodels:ProtocolSettingsLayout.MVVMHasError="{Binding Path=HasError}" />    
   

Answer 4

If you provide a custom ValidationRule implementation you can store the value it received, as well as storing the last result. PseudoCode:

public class IsInteger : ValidationRule
{
  private int parsedValue;

  public IsInteger() { }

  public string LastValue{ get; private set; }

  public bool LastParseSuccesfull{ get; private set; }

  public int ParsedValue{ get{ return parsedValue; } }

  public override ValidationResult Validate( object value, CultureInfo cultureInfo )
  {
    LastValue = (string) value;
    LastParseSuccesfull = Int32.TryParse( LastValue, cultureInfo, ref parsedValue );
    return new ValidationResult( LastParseSuccesfull, LastParseSuccesfull ? "not a valid number" : null );
  }
}

Answer 5

Nirvan

The simplest way to solve this particular issue is to use a numeric textbox, which prevents the user from entering an invalid value (you can either do this via a Third Party Vendor, or find an open source solution, such as a class derived from Textbox that suppresses non numeric input).

The second way to handle this in MVVM without doing the above, is to define another field in you ViewModel which is a string, and bind that field to your textbox. Then, in the setter of your string field you can set the Integer, and assign a value to your numeric field:

Here is a rough example: (NOTE I did not test it, but it should give you the idea)

// original field
private int _age;
int Age 
{
   get { return _age; }
   set { 
     _age = value; 
     RaisePropertyChanged("Age");
   }
}


private string _ageStr;
string AgeStr
{
   get { return _ageStr; }
   set { 
     _ageStr = value; 
     RaisePropertyChanged("AgeStr");
     if (!String.IsNullOrEmpty(AgeStr) && IsNumeric(AgeStr) )
         Age = intVal;
    }
} 

private bool IsNumeric(string numStr)
{
   int intVal;
   return int.TryParse(AgeStr, out intVal);
}

#region IDataErrorInfo Members

    public string this[string columnName]
    {
        get
        {

            if (columnName == "AgeStr" && !IsNumeric(AgeStr)
               return "Age must be numeric";
        }
    }

    #endregion

Answer 6

Someone's solved it here (unfortunately its in VB) by creating a dependency property HasError in the VM which seems to be bound to the Validation.HasError. I don't completely understand it yet but it may help you:

http://wpfglue.wordpress.com/2009/12/03/forwarding-the-result-of-wpf-validation-in-mvvm/