Question

We have Generics Property

 public class BE
    {
        private List<Admin_Fee> _Admin_Fee = new List<Admin_Fee>();
        [StringLengthValidator(3,
        MessageTemplate = "Fund City Can't be more than 3 Chars")]  
        public MyProperty<string> FUND_CITY { get; set; }

        public MyProperty<int> SomeOtherProperty { get; set; }

        public List<MyPropertyBase> MyDataPoints { get; set; }

    }

I want to put StingLengthValidator using VAB on Generic Property, and getting error that :

Value is not expected type

Can some one help?

Answer 1

The reason why you are getting an error is fairly straight forward: you are trying to use a StringLengthValidator against a type that isn’t a string (it is actually MyProperty<string>).

The question is what to do to validate the property? It’s tricky because the design doesn’t really fit well within the Validation Application Block design.

Typically you would just apply an ObjectValidator to validate the MyProperty class but that doesn’t really fit in this case since it looks like you aim to use MyProperty to hold various values each with different rules so you can’t really apply validator attributes to MyProperty.

I think you can achieve what you want with custom validators. I’m thinking you can wrap existing validators inside your custom validator.

Here I’m assuming MyProperty looks something like:

public class MyProperty<T>
{
    public T Value { get; set; }
}

Then you can create a custom validator MyPropertyValidator:

public class MyPropertyValidatorAttribute : ValidatorAttribute
{
    Microsoft.Practices.EnterpriseLibrary.Validation.Validator validator;

    public MyPropertyValidatorAttribute(Type validator, params object[] validatorArgs)
    {
        this.validator = Activator.CreateInstance(validator, validatorArgs) 
            as Microsoft.Practices.EnterpriseLibrary.Validation.Validator;    
    }

    protected override Microsoft.Practices.EnterpriseLibrary.Validation.Validator DoCreateValidator(Type targetType)
    {
        return new MyPropertyValidator(validator);
    }
}

public class MyPropertyValidator : Microsoft.Practices.EnterpriseLibrary.Validation.Validator
{
    Microsoft.Practices.EnterpriseLibrary.Validation.Validator validator;

    public MyPropertyValidator(Microsoft.Practices.EnterpriseLibrary.Validation.Validator validator)
        : this(validator.MessageTemplate, validator.Tag)
    {
        this.validator = validator;
    }

    public MyPropertyValidator(string message, string tag) : base(message, tag)
    {
    }

    protected override string DefaultMessageTemplate
    {
        get { return ""; }
    }

    public override void DoValidate(object objectToValidate, object currentTarget, string key, ValidationResults validationResults)
    {
        var val = objectToValidate;

        Type t = objectToValidate.GetType();
        var propInfo = t.GetProperty("Value");

        if (propInfo != null)
        {
            val = propInfo.GetValue(objectToValidate, null);
        }

        validator.DoValidate(val, currentTarget, key, validationResults);
    }
}

Then you could annotate your class like so:

public class BE
{
    [MyPropertyValidator( 
        typeof(StringLengthValidator), 
        0, RangeBoundaryType.Ignore,
        3, RangeBoundaryType.Inclusive,
        "Fund City Can't be more than 3 Chars",
        false)]
    public MyProperty<string> FUND_CITY { get; set; }

    [MyPropertyValidator(
        typeof(RangeValidator),
        0, RangeBoundaryType.Inclusive,
        10, RangeBoundaryType.Inclusive,
        "Must be between 0 and 10", 
        false)]
       public MyProperty<int> SomeOtherProperty { get; set; }
}

I haven’t tested it extensively but it seems to work. It does have a few drawbacks:

• It’s inflexible. For example it doesn’t support composite validators or other more complicated scenarios. You could maybe implement all those cases but it would get messy.
• My implementation is using reflection which would be better to avoid.
• Potential boxing of value types