Caliburn.Micro实现INotifyDataErrorInfo

Question

I'm trying to find an elegant solution to implement INotifiyDataErrorInfo with Caliburn.Micro MVVM framework.

I want to limit the amount of code that will be repeated in each VM that needs to implement the validation. I started by writing a class that inherits Screen and implements INotifiyDataErrorInfo . It works correctly and all is fine, until I need validation on a VM that is not a Screen , but a Conductor .

Of course, I could make a class that inherits Conductor and implements INotifyDataErrorInfo but that's quite annoying as I would have to basically make my own version of all "base" classes of Caliburn.Micro.

One solution I had was to keep the Screen base class and create a IValidator interface that I would inject into my VM, something like this:

public interface IValidator<T> where T : INotifyDataErrorInfo
{
    void Validates(T instance);

    IEnumerable GetErrors(string propertyName);
    bool HasErrors { get; }

    void Validate();
    void ValidateProperty<TValue>(TValue value, string propertyName = null);
    void ValidateProperty<TValue, TProperty>(TValue value, Expression<Func<TProperty>> property);
}

It will then used in the VM in this way.

public class CreateCarViewModel : Conductor<CreateCarViewModel>.Collection.OneActive, INotifyDataErrorInfo
{
   private readonly IValidator<CreateCarViewModel> validator;

   public CreateExperimentViewModel(IValidator<CreateCarViewModel> validator)
   {
       this.DisplayName = "Select a car";

       this.validator = validator;
       this.validator.Validates(this);
   }

   [Required]
   public string CarName
   {
       get
       {
           return this.carName;
       }
       set
       {
           if (this.carName != value)
           {
               this.carName = value;

               this.validator.ValidateProperty(value, () => this.CarName);
               this.NotifyOfPropertyChange(() => CarName);
           }
       }
   }

   public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

   public System.Collections.IEnumerable GetErrors(string propertyName)
   {
       return this.validator.GetErrors(propertyName);
   }

   public bool HasErrors
   {
       get { return this.validator.HasErrors; }
   }

   ...

}

This works pretty nicely, as it is very simple to implement the INotifyDataErrorInfo in the VMs, but the issue I have is triggering the ErrorChanged event. It must be triggered by the implementation of the IValidator as he is the one who knows when the errors have changed, and of course he cannot trigger directly.

One idea I have was to have an event in the IValidator and subscribe to it in the VM so that it can trigger its own event, but I find that it makes a lot of code for nothing.

Does anyone have a better idea?

Thanks

Answer 1

I wrote a small plugin for CM to enable fluent builder-style validation. Maybe it will help you. Feel free to use it: https://github.com/AIexandr/Caliburn.Micro.Validation Example of usage:

public class PaymentEditorViewModel() : ValidatingScreen
{
  public PaymentEditorViewModel()
  {
    AddValidationRule(() => PaymentSum).Condition(() => PaymentSum <= 0).Message("Please enter payment sum");
  }

  #region PaymentSum property
  decimal _PaymentSum;
  public decimal PaymentSum
  {
    get
    {
      return _PaymentSum;
    }
    set
    {
      _PaymentSum = value;
      NotifyOfPropertyChange(() => PaymentSum);
    }
  }
  #endregion
}

Answer 2

The wireup code is not excessive is it, if you have the IValidator expose the same event as the VM, eg:

    public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

    public void Validate()
    {
        if (ErrorsChanged != null)
            ErrorsChanged(instance, new DataErrorsChangedEventArgs("someProperty"));
    }

and in the VM:

 validator.ErrorsChanged += (sender, args) => ErrorsChanged(sender, args);

But I guess you already answered your own question without telling us ;)