Validate on button click?

I was wondering if there's an easy way to validate an entity on a button click rather than setting up the verification engine to update as every property is changed (ala: Manager.VerifierEngine.DefaultVerifierOptions.ErrorNotificationMode = VerifierErrorNotificationMode.ThrowException).

If I have XAML like this:
<TextBox  Text="{Binding Employee.FirstName, Mode=Default, ValidatesOnExceptions=True}"/>

<Button Content="Validate" Command="{Binding BtnValidateClick}"/>

and in my viewmodel, I have a property and method:
public static Employee Employee { get; set; }

public ICommand BtnValidateClick { get; set; }  // this gets set to OnBtnValidateClick in the vm constructor
public void OnBtnValidateClick(object parameter)
{
  var result = Manager.VerifierEngine.Execute(Employee).Where(r => r.IsError || r.IsWarning);
}

What can I do with the result to tell the entity to go throw errors on all the properties with failed verifiers?   I'm thinking there's something simple I'm missing here.

Thanks!

This is for WPF

Edited by mikewishart - 27-Jul-2010 at 11:01am

Thanks Greg.  I came up with two ways to do it in an injected base class.

In the interest of helping any other developers with the same question, here's one way.  (It's not fun finding forum posts with "I figured it out," but no answer as to how.)  This way clears the error until Verify() is called again.  Bindings need to include ValidatesOnDataErrors=true.

public abstract partial class EntityBase : IDataErrorInfo
{
  private Dictionary<string, string> _errorList;
  private Dictionary<string, string> ErrorList
  {
    get { return _errorList ?? (_errorList = new Dictionary<string, string>()); }
  }
  private bool _isVerifying;

  /// <summary>
  /// Verify the specific entity, setting errors on properties not passing validation.
  /// </summary>
  /// <returns>
  /// True if the entity passes validation.  False if there are errors.
  /// </returns>
  public bool Verify()
  {
    ErrorList.Clear();

    var verifiers = verifierEngine.Execute(this)
      .Where(v => (v.ResultCode == VerifierResultCode.Error) || (v.ResultCode == VerifierResultCode.OkWarning))
      .ToList();

    _isVerifying = true;
    try
    {
      foreach (var verifierResult in verifiers)
      {
        var triggers = verifierResult.Verifier.TriggerLinks;
        foreach (var propertyName in triggers.Select(trigger => trigger.TriggerItem.MemberName))
        {
          if (ErrorList.ContainsKey(propertyName))
            ErrorList[propertyName] += Environment.NewLine + verifierResult.Message;
          else
            ErrorList.Add(propertyName, verifierResult.Message);

          if (GetType().GetProperty(propertyName) != null)
            EntityAspect.ForcePropertyChanged(new PropertyChangedEventArgs(propertyName));
        }
      }
    }
    finally
    {
      _isVerifying = false;
    }

    return verifiers.Count == 0;
  }

  /// <summary>
  /// Hide the error whenever the property is changed until Verify() is called again.
  /// </summary>
  protected override void OnPropertyChanged(PropertyChangedEventArgs e)
  {
    base.OnPropertyChanged(e);
    if (_isVerifying) return;

    if (string.IsNullOrEmpty(e.PropertyName)) return;

    if (ErrorList.ContainsKey(e.PropertyName))
      ErrorList.Remove(e.PropertyName);
  }

  public new string this[string propertyName]
  {
    get { return ErrorList.ContainsKey(propertyName) ? ErrorList[propertyName] : null; }
  }

  public string Error { get { throw new NotImplementedException(); } }
}


Edited by mikewishart - 03-Aug-2010 at 5:52am

Mike,

Mike,