c# - 使用 Entity Framework 时实现业务逻辑

Question

我是 Entity Framework 的新手，对如何实现业务逻辑感到困惑。

我正在使用 Code First 方法并生成了我的 POCO。我将它们放在一个单独的项目中，因此它们可以在多个项目中使用。

我想知道如何为对象实现业务逻辑，当我尝试将项目保存到数据库时会检查该对象。例如，如果我定义一个规则，除非输入名称，否则无法保存 MyObject，我该怎么做？

示例简单的 POCO

public class MyObject() {
    public String name { get; set; };

    public MyObject() {}
}

显然我有很多对象，每个对象都有不同的业务规则。

我来自 Csla ( http://www.lhotka.net/cslanet/) 业务框架背景，您可以在其中定义一个业务对象，该对象具有一个 Save 方法。在调用 Save 时，框架运行 ValidationRules，从而确定是否需要调用数据库。

我想要这样的东西，使用 Entity Framework 。代码示例会很棒，或者引用阅读 Material 。谢谢

Answer 1

我通常在我的应用程序中构建一个服务层来处理业务逻辑，它与我的数据访问层对话以保留任何数据。

public class JobService : IJobService
{
    private readonly IJobRepository _jobRepository;

    public JobService(IJobRepository jobRepository)
    {
        _jobRepository = jobRepository;
    }

    public IEnumerable<Job> GetAllJobs()
    {
        return _jobRepository.All().OrderBy(x => x.Name);
    }

    public Job GetJobById(Guid Id)
    {
        return _jobRepository.FindBy(x => x.Id == Id);
    }

    public void UpdateJob(Job job, User user)
    {
        job.LastUpdatedDate = DateTime.Now;
        job.LastUpdatedBy = user;

        _jobRepository.Update(job);
    }

    public void DeleteJob(Job job)
    {
        _jobRepository.Delete(job);
    }

    public void SaveJob(Job job, User user)
    {
        job.CreatedDate = DateTime.Now;
        job.CreatedBy = user;

        _jobRepository.Insert(job);
    }
}

您的服务可以像您想要的那样复杂，同时仍然抽象出您的数据访问层。我不会向您的 POCO 类添加任何方法，因为这违背了 POCO 类的目的。服务也是验证业务规则的好地方。尽管我没有提供相关示例，但可以轻松地将验证添加到您的服务方法中。

编辑

我在编写大型应用程序时通常使用的架构需要契约(Contract)来定义数据访问层。我们使用接口(interface)来定义我们的类结构的原因是我们可以以不同的方式实现它们，而不必更改使用这些类的任何代码。例如，您可能使用 EF 实现存储库模式，但后来可能会发现您想要使用 NHibernate。要进行更改，您只需更改存储库的实现，而不是实际使用存储库的代码。

我的存储库合约通常如下所示:

/// <summary>
/// This interface is implemented by all repositories to ensure implementation of fixed methods.
/// </summary>
/// <typeparam name="TEntity">Main Entity type this repository works on</typeparam>
/// <typeparam name="TKey">Primary key type of the entity</typeparam>
public interface IRepository<TKey, TEntity> : IRepository where TEntity : class, IEntity<TKey>
{
    /// <summary>
    /// Inserts a new entity.
    /// </summary>
    /// <param name="entity">Entity to insert</param>
    TEntity Insert(TEntity entity);

    /// <summary>
    /// Inserts multiple entities.
    /// </summary>
    /// <param name="entities">Entities to insert</param>
    IEnumerable<TEntity> Insert(IEnumerable<TEntity> entities);

    /// <summary>
    /// Updates an existing entity.
    /// </summary>
    /// <param name="entity">Entity</param>
    TEntity Update(TEntity entity);

    /// <summary>
    /// Updates or saves an entity
    /// </summary>
    /// <param name="entity">Entity</param>
    TEntity SaveOrUpdate(TEntity entity);

    /// <summary>
    /// Deletes an entity.
    /// </summary>
    /// <param name="id">Id of the entity</param>
    bool Delete(TKey id);

    /// <summary>
    /// Deletes an entity.
    /// </summary>
    /// <param name="entity">Entity to be deleted</param>
    bool Delete(TEntity entity);

    /// <summary>
    /// Deletes an entity.
    /// </summary>
    /// <param name="entities">Entities to be deleted</param>
    bool Delete(IEnumerable<TEntity> entities);

    /// <summary>
    /// Used to get an IQueryable that is used to retrieve entities from entire table.
    /// </summary>
    /// <returns>IQueryable to be used to select entities from database</returns>
    IQueryable<TEntity> All();

    /// <summary>
    /// Gets an entity.
    /// </summary>
    /// <param name="expression">LINQ expression used to evaluate and find an entity</param>
    /// <returns>Entity</returns>
    TEntity FindBy(Expression<Func<TEntity, bool>> expression);

    /// <summary>
    /// Used to get an IQueryable that is used to retrieve entities from evaluated LINQ expression.
    /// </summary>
    /// <param name="expression">LINQ expression used to evaluate and find entities</param>
    /// <returns>IQueryable to be used to select entities from database</returns>
    IQueryable<TEntity> FilterBy(Expression<Func<TEntity, bool>> expression);

    /// <summary>
    /// Gets an entity.
    /// </summary>
    /// <param name="id">Primary key of the entity to get</param>
    /// <returns>Entity</returns>
    TEntity FindBy(TKey id);
}

然后是 IJobRepository:

// We create separate repositories inheriting from IRepository in case we need specific repository methods for that entity
public interface IJobRepository : IRepository<Guid, Job>
{
}

如何实现存储库取决于您，但通常对于 EF，您会向存储库传递一个 DbSet 或 DbContext 并对其执行操作。

您的服务契约(Contract)将取决于您的业务逻辑。您可能只需要从持久存储中读取某些实体。其他的你必须制作服务方法来验证/插入/操作/等。

当您使用控制反转 (IoC) 将这些契约的实现作为构造函数参数注入(inject)时，此设计模式最有效。我通常使用 CaSTLe Windsor，但那里有很多 IoC 依赖注入(inject)框架。