Question

I have built a base class for my view model(s). Here is some of the code:

public class BaseViewModel<TModel> : DependencyObject, INotifyPropertyChanged, IDisposable, IBaseViewModel<TModel>, IDataErrorInfo
{
        public TModel Model { get; set; }

        public event PropertyChangedEventHandler PropertyChanged;

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

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (this._disposed)
            {
                return;
            }

            if (disposing)
            {
                this.Model = default(TModel);
            }

            this._disposed = true;
        }
}

Okay, so I thought, let’s add some validation to the base class, which led me to the following article: Prism IDataErrorInfo validation with DataAnnotation on ViewModel Entities. So I added the following methods / properties (IDataErrorInfo) to my base class:

string IDataErrorInfo.Error
{
    get { return null; }
}

string IDataErrorInfo.this[string columnName]
{
    get { return ValidateProperty(columnName); }
}

protected virtual string ValidateProperty(string columnName)
{
    // get cached property accessors
    var propertyGetters = GetPropertyGetterLookups(GetType());

    if (propertyGetters.ContainsKey(columnName))
    {
        // read value of given property
        var value = propertyGetters[columnName](this);

        // run validation
        var results = new List<ValidationResult>();
        var vc = new ValidationContext(this, null, null) { MemberName = columnName };
        Validator.TryValidateProperty(value, vc, results);

        // transpose results
        var errors = Array.ConvertAll(results.ToArray(), o => o.ErrorMessage);
        return string.Join(Environment.NewLine, errors);
    }
    return string.Empty;
}

private static Dictionary<string, Func<object, object>> GetPropertyGetterLookups(Type objType)
{
    var key = objType.FullName ?? "";
    if (!PropertyLookupCache.ContainsKey(key))
    {
        var o = objType.GetProperties()
        .Where(p => GetValidations(p).Length != 0)
        .ToDictionary(p => p.Name, CreatePropertyGetter);

        PropertyLookupCache[key] = o;
        return o;
    }
    return (Dictionary<string, Func<object, object>>)PropertyLookupCache[key];
}

private static Func<object, object> CreatePropertyGetter(PropertyInfo propertyInfo)
{
    var instanceParameter = System.Linq.Expressions.Expression.Parameter(typeof(object), "instance");

    var expression = System.Linq.Expressions.Expression.Lambda<Func<object, object>>(
        System.Linq.Expressions.Expression.ConvertChecked(
            System.Linq.Expressions.Expression.MakeMemberAccess(
                System.Linq.Expressions.Expression.ConvertChecked(instanceParameter, propertyInfo.DeclaringType),
                propertyInfo),
            typeof(object)),
        instanceParameter);

    var compiledExpression = expression.Compile();

    return compiledExpression;
}

private static ValidationAttribute[] GetValidations(PropertyInfo property)
{
    return (ValidationAttribute[])property.GetCustomAttributes(typeof(ValidationAttribute), true);
}

Okay, this brings me to the issue. The thing is the validation works perfectly, but lets say I have a property (within my view model called: Person) with a StringLength attribute. The StringLength attribute fires as soon as the application is opened. The user didn’t even have a chance to do anything. The validation fires as soon as the application is started.

public class PersonViewModel : BaseViewModel<BaseProxyWrapper<PosServiceClient>>
{
    private string _password = string.Empty;
    [StringLength(10, MinimumLength = 3, ErrorMessage = "Password must be between 3 and 10 characters long")]
    public string Password
    {
        get { return this._password; }
        set
        {
            if (this._password != value)
            {
                this._password = value;
                this.OnPropertyChanged("Password");
            }
        }
    }
}

I have noticed that this is caused by the IDataErrorInfo.this[string columnName] property, and in turn it calls the ValidateProperty method. But, I have no idea how to fix this?

Answer 1

There could be two issues…

Do you populate yopur Person instance by using the public properties?

e.g.

  new Person { Password = null }

This will fire the property changed notification for Password and will validate it.

Some developers also set the properties in constructors…

public class Person {
   public Person() {
      this.Password = null;
   }
} 

Recommended practise is to use private fields…

public class Person {
   public Person() {
      _password = null;
   }

   public Person(string pwd) {
      _password = pwd;
   }
} 

OR

You can create a flag in our view model base say IsLoaded. Make sure you set it to true only after your UI is loaded (probably in UI.Loaded event). In your IDataErrorInfo.this[string columnName] check if this property is true and only then validate the values. Otherwise return null.

[EDIT]

The following change did the job:

public class PersonViewModel : BaseViewModel<BaseProxyWrapper<PosServiceClient>>
{
    private string _password;
    [StringLength(10, MinimumLength = 3, ErrorMessage = "Password must be between 3 and 10 characters long")]
    public string Password
    {
        get { return this._password; }
        set
        {
            if (this._password != value)
            {
                this._password = value;
                this.OnPropertyChanged("Password");
            }
        }
    }

    public PersonViewModel(BaseProxyWrapper<PosServiceClient> model)
        : base(model)
    {
        this._username = null;
    }
}