How to create a generic UniqueValidationAttribute attribute in C # and DataAnnotation?

Question

I am trying to create UniqueAttributeusingSystem.ComponentModel.DataAnnotations.ValidationAttribute

I want this to be common, as I could pass the Linq DataContext, table name, field, and check if the input value is unique or not.

Here is a snippet of non-compiled code that I'm stuck right now:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.DataAnnotations;
using System.Data.Linq;
using System.ComponentModel;

namespace LinkDev.Innovation.Miscellaneous.Validation.Attributes
{
    public class UniqueAttribute : ValidationAttribute
    {
        public string Field { get; set; }

        public override bool IsValid(object value)
        {
            string str = (string)value;
            if (String.IsNullOrEmpty(str))
                return true;

            // this is where I'm stuck
            return (!Table.Where(entity => entity.Field.Equals(str)).Any());           
        }
    }
}

I should use this in my model as follows:

[Required]
[StringLength(10)]
[Unique(new DataContext(),"Groups","name")]
public string name { get; set; }

Edit: Please note that according to this: Why does C # prohibit common attribute types? I cannot use a generic type with an attribute.

So my new approach here is to use Reflection / Expression trees to create a Lambda expression tree on the fly.

Answer 1

, : http://forums.asp.net/t/1512348.aspx , .

:

[Required]
[StringLength(10)]
[Unique(typeof(ContactsManagerDataContext),typeof(Group),"name",ErrorMessage="Group already exists")]
public string name { get; set; }

:

public class UniqueAttribute : ValidationAttribute
{
    public Type DataContextType { get; private set; }
    public Type EntityType { get; private set; }
    public string PropertyName { get; private set; }

    public UniqueAttribute(Type dataContextType, Type entityType, string propertyName)
    {
        DataContextType = dataContextType;
        EntityType = entityType;
        PropertyName = propertyName;
    }

    public override bool IsValid(object value)
    {
        string str = (string) value;
        if (String.IsNullOrWhiteSpace(str))
            return true;

        // Cleanup the string
        str = str.Trim();

        // Construct the data context
        ConstructorInfo constructor = DataContextType.GetConstructor(new Type[0]);
        DataContext dataContext = (DataContext)constructor.Invoke(new object[0]);

        // Get the table
        ITable table = dataContext.GetTable(EntityType);

        // Get the property
        PropertyInfo propertyInfo = EntityType.GetProperty(PropertyName);

        // Expression: "entity"
        ParameterExpression parameter = Expression.Parameter(EntityType, "entity");

        // Expression: "entity.PropertyName"
        MemberExpression property = Expression.MakeMemberAccess(parameter, propertyInfo);

        // Expression: "value"
        object convertedValue = Convert.ChangeType(value, propertyInfo.PropertyType);
        ConstantExpression rhs = Expression.Constant(convertedValue);

        // Expression: "entity.PropertyName == value"
        BinaryExpression equal = Expression.Equal(property, rhs);

        // Expression: "entity => entity.PropertyName == value"
        LambdaExpression lambda = Expression.Lambda(equal, parameter);

        // Instantiate the count method with the right TSource (our entity type)
        MethodInfo countMethod = QueryableCountMethod.MakeGenericMethod(EntityType);

        // Execute Count() and say "you're valid if you have none matching"
        int count = (int)countMethod.Invoke(null, new object[] { table, lambda });
        return count == 0;
    }

    // Gets Queryable.Count<TSource>(IQueryable<TSource>, Expression<Func<TSource, bool>>)
    private static MethodInfo QueryableCountMethod = typeof(Queryable).GetMethods().First(m => m.Name == "Count" && m.GetParameters().Length == 2);
}

, , DLL , , UniqueAttribute /.

Answer 2

... DI..: D

public class UniqueAttribute : ValidationAttribute
{
    public UniqueAttribute(Type dataContextType, Type entityType, string propertyName)
    {
        DataContextType = dataContextType;
        EntityType = entityType;
        PropertyName = propertyName;
    }


    public Type DataContextType { get; private set; }


    public Type EntityType { get; private set; }


    public string PropertyName { get; private set; }


    public override bool IsValid(object value)
    {
        // Construct the data context
        //ConstructorInfo constructor = DataContextType.GetConstructor(new Type[0]);
        //DataContext dataContext = (DataContext)constructor.Invoke(new object[0]);
        var repository = DependencyResolver.Current.GetService(DataContextType);
        var data = repository.GetType().InvokeMember("GetAll", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public, null, repository, null);

        // Get the table
        //ITable table = dataContext.GetTable(EntityType);


        // Get the property
        PropertyInfo propertyInfo = EntityType.GetProperty(PropertyName);


        // Our ultimate goal is an expression of:
        //   "entity => entity.PropertyName == value"


        // Expression: "value"
        object convertedValue = Convert.ChangeType(value, propertyInfo.PropertyType);
        var rhs = Expression.Constant(convertedValue);


        // Expression: "entity"
        var parameter = Expression.Parameter(EntityType, "entity");


        // Expression: "entity.PropertyName"
        var property = Expression.MakeMemberAccess(parameter, propertyInfo);


        // Expression: "entity.PropertyName == value"
        var equal = Expression.Equal(property, rhs);


        // Expression: "entity => entity.PropertyName == value"
        var lambda = Expression.Lambda(equal, parameter).Compile();

        // Instantiate the count method with the right TSource (our entity type)
        MethodInfo countMethod = QueryableCountMethod.MakeGenericMethod(EntityType);

        // Execute Count() and say "you're valid if you have none matching"
        int count = (int)countMethod.Invoke(null, new object[] { data, lambda });
        return count == 0;
    }


    // Gets Queryable.Count<TSource>(IQueryable<TSource>, Expression<Func<TSource, bool>>)
    //private static MethodInfo QueryableCountMethod = typeof(Enumerable).GetMethods().First(m => m.Name == "Count" && m.GetParameters().Length == 2);
    private static MethodInfo QueryableCountMethod = typeof(System.Linq.Enumerable).GetMethods().Single(
        method => method.Name == "Count" && method.IsStatic && method.GetParameters().Length == 2);
}

Answer 3

, , , .

, . , :

[Unique(new DataContext(),"Groups","name")]

. , omitt new DataContext() - , .

Answer 4

as @LBushkin mentioned, Attributescompile-time constants are needed.

I would change your class:

public class UniqueAttribute : ValidationAttribute

at

public class UniqueAttribute<T> : ValidationAttribute  
where T : DataContext{

    protected T Context { get; private set; }

  ...    

    }

and use it like:

[Required]
[StringLength(10)]
[Unique<DataContext>("Groups","name")]
public string name { get; set; }

This will help you add a DataContext if necessary instead of instantiating each time.

NTN

Edit: since an attribute cannot accept a common parameter, this could be another potential code:

public class UniqueAttribute : ValidationAttribute{

    public UniqueAttribute(Type dataContext, ...){
        if(dataContext.IsSubClassOf(typeof(DataContext))){
            var objDataContext = Activator.CreateInstance(dataContext);
        }
    }

}

and use it like:

[Required]
[StringLength(10)]
[Unique(typeof(DataContext), "Groups","name")]
public string name { get; set; }

Hth this time :)