wpf mvvm error validation

I have a simple wpf application and I am trying to deactivate the save button if the form has errors.

The Problem is that, although the validation it looks to works perfect, I don't know why but I am getting all the time false from the method which is responsible to check the errors.

Let me make it more clear by providing the code.

This is the code from MainWindow.Xaml.cs

private readonly HashSet<ValidationError> errors = new HashSet<ValidationError>();
    private Lazy<MainWindowViewModel> viewModel;

    public MainWindow() {
        InitializeComponent();
        InitializeValidaton();
    }

    void InitializeValidaton() {
        viewModel = new Lazy<MainWindowViewModel>();
        Validation.AddErrorHandler(this, ErrorChangedHandler)开发者_Python百科;
    }

    private void ErrorChangedHandler(object sender, ValidationErrorEventArgs e) {
        if (e.Action == ValidationErrorEventAction.Added) {
            errors.Add(e.Error);
        } else {
            errors.Remove(e.Error);
        }
        //I set a breakpoint here and it returns the correct value. False if it has errors  and True if not
        viewModel.Value.IsValid = !errors.Any();

    }

This is the command for the button

 public ICommand SaveItem {
        get { return new RelayCommand(SaveItemExecute,CanSaveItem); }
    }
 private bool CanSaveItem() {
        return IsValid;
    }

  //I set up here a breakpoint and it returns the correct value just once.
  //The application looked up on CanSaveItem all the time and except the first time, it returns wrong value
  private bool _isValid;
    public bool IsValid {
        get { return _isValid; }
        set {
            _isValid = value;
            RaisePropertyChanged("IsValid");
  }
    }

Validation Rules

[Required(ErrorMessage = "Please enter Title")]
    [StringLength(100, ErrorMessage = "The maximum length is 100")]
    string Name { get; set; }

I don't know if it makes any sense, but the button I want to deactivate is in a UserControl.

I can't understand why the canExecute method which is in a userControl, triggered more than once. What ever of method if I used, it has the same reaction. I mention the userControl, because if I use the same method(which in part of ICommand) in the mainWindow, it triggered just once

I will appreciate if could anyone help me with this.

Thanks

I would rather post a working example of validation using your model. Adjust this example as you need, and probably you will find difference that produce an incorrect work.

MainWindow.xaml

<StackPanel>
    <TextBox x:Name="ValidatedTextBox" Width="200">
        <TextBox.Text>
            <Binding Path="EnteredText" UpdateSourceTrigger="PropertyChanged" NotifyOnValidationError="True">
                <Binding.ValidationRules>
                    <local:NotEmptyInputRule ValidatesOnTargetUpdated="True" />
                </Binding.ValidationRules>
            </Binding>
        </TextBox.Text>
    </TextBox>
    <Button Content="Save" Width="60" IsEnabled="{Binding IsValid}" />
</StackPanel>

Property EnteredText must exist in the ViewModel:

class MainWindowViewModel : INotifyPropertyChanged
{
    public ICommand SaveItem
    {
        get { return new SimpleCommand(SaveItemExecute, CanSaveItem); }
    }

    public void SaveItemExecute()
    {
        //save
    }

    private bool CanSaveItem()
    {
        return IsValid;
    }

    //I set up here a breakpoint and it returns the correct value just once.
    //The application looked up on CanSaveItem all the time and except the first time, it returns wrong value
    private bool _isValid;
    public bool IsValid
    {
        get { return _isValid; }
        set
        {
            _isValid = value;
            OnPropertyChanged("IsValid");
        }
    }

    public string EnteredText { get; set; }

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        if (this.PropertyChanged != null)
        {
            this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

}

And don't forget to set DataContext in the MainWindow.

    public MainWindow()
    {
        InitializeComponent();
        InitializeValidaton();
        this.DataContext = viewModel.Value;
    }

There are also the Command class and the validation rule.

public class SimpleCommand : ICommand
{
    /// <summary>
    /// Gets or sets the Predicate to execute when the CanExecute of the command gets called
    /// </summary>
    public Predicate<object> CanExecuteDelegate { get; set; }

    /// <summary>
    /// Gets or sets the action to be called when the Execute method of the command gets called
    /// </summary>
    public Action<object> ExecuteDelegate { get; set; }

    public SimpleCommand(Action execute, Func<bool> canExecute)
    {
        this.ExecuteDelegate = _ => execute();
        this.CanExecuteDelegate = _ => canExecute();
    }

    #region ICommand Members

    /// <summary>
    /// Checks if the command Execute method can run
    /// </summary>
    /// <param name="parameter">THe command parameter to be passed</param>
    /// <returns>Returns true if the command can execute. By default true is returned so that if the user of SimpleCommand does not specify a CanExecuteCommand delegate the command still executes.</returns>
    public bool CanExecute(object parameter)
    {
        if (CanExecuteDelegate != null)
            return CanExecuteDelegate(parameter);
        return true;// if there is no can execute default to true
    }

    public event EventHandler CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }

    /// <summary>
    /// Executes the actual command
    /// </summary>
    /// <param name="parameter">THe command parameter to be passed</param>
    public void Execute(object parameter)
    {
        if (ExecuteDelegate != null)
            ExecuteDelegate(parameter);
    }

    #endregion

}  

class NotEmptyInputRule : ValidationRule
{
    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        if (value != null)
        {
            string input = value as string;

            if (input.Length > 0)
                return new ValidationResult(true, null);
        }

        return new ValidationResult(false, "Validation error. Field input required.");
    }
}