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

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

---

我不知道如何SEARCHEMPLOYEE在我的代码后面通过UOW 访问方法(存储过程).

Answer 1

那么,在你的情况下,你只需要为你的HRCTX代理/ UOW类添加另一个"代理方法" ,或者 - 因为HRCTX提供对其底层上下文的访问 - 直接在上下文中调用它,如下所示:

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

但我还想强调,DbContext已经代表了工作单元模式(结合存储库模式,请参见此处).你基本上是在为你的上下文创建一个代理 - 就我在这个例子中看到的那样 - 没有额外的好处或功能,所以我建议你至少考虑直接使用你的HRMainDataCTX并且可能去掉这个HRCTX类.

Answer 2

如果要封装DbContext和业务逻辑,则可能需要实现存储库以及工作单元模式.(正如AspNet指南中所建议的那样)

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

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.

希望能帮助到你 !