Есть ли способ реализации условия выбора в LINQ DataContext

Question

Я работаю в проекте MVC3, и я использую LINQ to SQL. У меня есть схема базы данных, которая использует поле, чтобы указать, активна ли запись или удалена (поле имеет логическое имя «Активный»). Теперь предположим, что есть две связанные таблицы, такие как State и City, где City ссылается на State. Допустим, у меня есть метод, который возвращает список состояний:

public ActionResult ListStates()
{
   return View(_repository.ListStates());
}

Теперь я реализовал метод репозитория для возврата всех состояний и мог бы реализовать его следующим образом:

public class Repository
{
   public IQueryable<State> ListStates()
   {
      return dataContext.States.Where(p => p.Active == true)
   }
}

По мнению, я могу быть уверен, что использую только активные состояния. Но чтобы быть уверенным, что я использую только активные города, мне нужно отфильтровать его в представлении, что делает представление более уродливым, или реализовать собственную модель представления. Оба случая действительны, но они требуют много работы. Я видел, что в контексте данных есть методы, в которых мы можем реализовать определенные операции до того, как объект будет вставлен / обновлен в базе данных, например:

public partial class DatabaseDataContext
{
   partial void InsertState(State instance)
   {
      instance.Active = true;
      this.ExecuteDynamicInsert(instance);
   }
}

Вышеуказанный метод выполняется всякий раз, когда происходит вставка объекта State. У меня вопрос, есть ли способ реализовать условие только в одном месте для объекта, например, возвращать только активные записи всякий раз, когда выполняется выбор?

Answer 1

Если я правильно понял, вы пытаетесь устранить необходимость указания .Where (p => p.Active == true) в методах ваших репозиториев, и вы хотите определить его только один раз .

Я не уверен, что вы можете достичь этого, не создавая обертку контекста данных, потому что для каждого запроса вам нужно объединить два логических выражения: выражение, полученное из репозитория, и p => p.Active == правда .

Самое простое решение будет следующим:

/// <summary>
/// A generic class that provides CRUD operations againts a certain database
/// </summary>
/// <typeparam name="Context">The Database context</typeparam>
/// <typeparam name="T">The table object</typeparam>
public class DataContextWrapper<Context> where Context : DataContext, new()
{
    Context DataContext;


    /// <summary>
    /// The name of the connection string variable in web.config
    /// </summary>
    string ConnectionString
    {
        get
        {
            return "Connection String";
        }
    }

    /// <summary>
    /// Class constructor that instantiates a new DataContext object and associates the connection string
    /// </summary>
    public DataContextWrapper()
    {
        DataContext = new Context();
        DataContext.Connection.ConnectionString = ConnectionString;
    }


    protected IEnumerable<T> GetItems<T>([Optional] Expression<Func<T, bool>> query) where T : class, new()
    {
        //get the entity type
        Type entity = typeof(T);
        //get all properties
        PropertyInfo[] properties = entity.GetProperties();

        Expression<Func<T, bool>> isRowActive = null;
        //we are interested in entities that have Active property ==> to distinguish active rows
        PropertyInfo property = entity.GetProperties().Where(prop => prop.Name == "Active").SingleOrDefault();

        //if the entity has the property
        if (property != null)
        {
            //Create a ParameterExpression from
            //if the query is specified then we need to use a single ParameterExpression for the whole final expression
            ParameterExpression para = (query == null) ? Expression.Parameter(entity, property.Name) : query.Parameters[0];

            var len = Expression.PropertyOrField(para, property.Name);
            var body = Expression.Equal(len, Expression.Constant(true));
            isRowActive = Expression.Lambda<Func<T, bool>>(body, para);
        }

        if (query != null)
        {
            //combine two expressions
            var combined = Expression.AndAlso(isRowActive.Body, query.Body);
            var lambda = Expression.Lambda<Func<T, bool>>(combined, query.Parameters[0]);
            return DataContext.GetTable<T>().Where(lambda);
        }
        else if (isRowActive != null)
        {
            return DataContext.GetTable<T>().Where(isRowActive);
        }
        else
        {
            return DataContext.GetTable<T>();
        }

    }

}

И тогда вы можете создать свои репозитории, как это:

/// <summary>
/// States Repository
/// </summary>
public class StatesRepository : DataContextWrapper<DEMODataContext>
{
    /// <summary>
    /// Get all active states
    /// </summary>
    /// <returns>All active states</returns>
    public IEnumerable<State> GetStates()
    {
        return base.GetItems<State>();
    }

    /// <summary>
    /// Get all active states
    /// </summary>
    /// <param name="pattern">State pattern</param>
    /// <returns>All active states tha contain the given pattern</returns>
    public IEnumerable<State> GetStates(string pattern)
    {
        return base.GetItems<State>(s=>s.Description.Contains(pattern));
    }

}

Использование:

StatesRepository repo = new StatesRepository();
var activeStates = repo.GetStates();

и

var filtered = repo.GetStates("Al");

Надеюсь, это поможет;)

Answer 2

Вы ищете динамическую библиотеку linq:

http://weblogs.asp.net/scottgu/archive/2008/01/07/dynamic-linq-part-1-using-the-linq-dynamic-query-library.aspx

Я использовал это раньше, чтобы вставить Where IsActive = true во все операторы выбора ранее.