Блог

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

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

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

 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);
   }
}
  

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

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

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

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

 /// <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");
  

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

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

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

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