Question

如果我有以下背景：

public partial class HRMainDataCTX : DbContext
{
    public HRMainDataCTX()
        : base("name=HRMainDataCTX")
    {
    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        throw new UnintentionalCodeFirstException();
    }

  //DbSets
    public virtual int SEARCHEMPLOYEE(Nullable<decimal> p_EMP_NUM, string p_EMP_NAME)
    {
        var p_EMP_NUMParameter = p_EMP_NUM.HasValue ?
            new ObjectParameter("P_EMP_NUM", p_EMP_NUM) :
            new ObjectParameter("P_EMP_NUM", typeof(decimal));

        var p_EMP_NAMEParameter = p_EMP_NAME != null ?
            new ObjectParameter("P_EMP_NAME", p_EMP_NAME) :
            new ObjectParameter("P_EMP_NAME", typeof(string));

        return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction("SEARCHEMPLOYEE", p_EMP_NUMParameter, p_EMP_NAMEParameter);
    }
}

现在我实现这样的工作单位：

public class HRCTX : IDisposable
{
    private readonly HRMainDataCTX _context;

    public HRCTX()
    {
        _context = new HRMainDataCTX();
    }

    public HRCTX(HRMainDataCTX context)
    {
        _context = context;
    }
    public int Save()
    {
        return _context.SaveChanges();
    }

    public HRMainDataCTX Context
    {
        get { return _context; }
    }

    public void Dispose()
    {
        _context.Dispose();
    }
}

我不知道如何在后面的代码中通过UOW访问方法（存储过程）SEARCHEMPLOYEE。

Answer 1

那么，在你的情况下，你只需要为你的HRCTX代理/ UOW类添加另一个“代理方法”，或者 - 由于HRCTX提供对其底层上下文的访问 - 调用它直接在这样的上下文：

HRCTX uow = new HRCTX(someContext);
uow.Context.SEARCHEMPLOYEE(123, "123");

但我还想强调，DbContext已经代表了工作单元模式（与存储库模式see here相结合）。你基本上是为你的上下文创建一个代理 - 据我在这个例子中看到的 - 没有增加任何其他的好处或功能，所以我建议至少考虑直接使用你的HRMainDataCTX并可能获得摆脱HRCTX类。

Answer 2

如果要封装DbContext和业务逻辑，则可能需要实现存储库以及工作单元模式。（As suggested in the AspNet guidelines）

通用方式，您的工作单元可以处理这样的存储库：

public class HRCTX : IDisposable
{
    private readonly HRMainDataCTX _context;
    private Dictionary<Type, object> Repositories { get; set; }


    public HRCTX()
    {
        _context = new HRMainDataCTX();
        this.Repositories = new Dictionary<Type, object>();
    }


    //Get and add a repository to the dictionary if ot does not exist
    public IRepository<TEntity> GetNonGenericRepository<TEntity, TRepository>() where TEntity : class
    {
        if (this.Repositories.Keys.Contains(typeof(TRepository)))
        {
            return this.Repositories[typeof(TRepository)] as IRepository<TEntity>;
        }
        var repoType = typeof(TRepository);
        var constructorInfo = repoType.GetConstructor(new Type[] { typeof(DbContext)});
        IRepository<TEntity> repository = (IRepository<TEntity>) constructorInfo.Invoke(new object[] { this._context});
        this.Repositories.Add(typeof(TRepository), repository);
        return repository;
    }

 public IRepository<TEntity> GetGenericRepository<TEntity>() where TEntity :     class
    {
        if (this.Repositories.Keys.Contains(typeof(TEntity)))
        {
            return this.Repositories[typeof(TEntity)] as IRepository<TEntity>;
        }

        IRepository<TEntity> repository = new Repository<TEntity>(this._context);
        this.Repositories.Add(typeof(TEntity), repository);
        return repository;
    }


}

存储库的接口和基类：

 public interface IRepository<TEntity> where TEntity : class
{
    TEntity Find(Expression<Func<TEntity, bool>> match);
}

public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
{
    protected DbContext Context { get; set; }

    public Repository(DbContext context)
    {
       this.Context = context;
    }
    public TEntity Find(Expression<Func<TEntity, bool>> match)
    {
        return Context.Set<TEntity>().SingleOrDefault(match);
    }
}

现在是您明确封装业务逻辑的部分：

public class EmployeeRepository : Repository<Employee>
{

    public EmployeeRepository(DbContext context) : base(context) {

    }
    public override Employee Find(Expression<Func<TEntity, bool>> match)
    {
        // You can either use the base class method or implement your custom logic
    }

    //This is where you encapsulate your business logic
     public Employee FindSpecific(Nullable<decimal> employeeNum, string employeeName){
         return this.Context.SEARCHEMPLOYEE(employeeNum, employeeName);
     }
}

然后，您可以使用工作单元以域驱动的设计方式访问业务逻辑。

HRCTX unitOfWork= new HRCTX(dbContext);
unitOfWork.GetNonGenericRepository<Employee, EmployeeRepository>().FindSpecific(1337,"1337");

对于您的预期答案似乎太过分了，但我认为如果您不想直接向您公开DbContext / Dal，我需要以这种方式构建您的应用程序。

希望它有所帮助！

Answer 3

此网页准确记录了如何实现目标。

http://www.asp.net/mvc/overview/older-versions/getting-started-with-ef-5-using-mvc-4/implementing-the-repository-and-unit-of-work-patterns-in-an-asp-net-mvc-application

如何通过工作单元访问上下文中的方法？

3 个答案: