Question

在谷歌搜索一段时间后，我想知道哪个是DBContext（EntityFramework或Linq-to-Sql）的最佳实践。

在实践中，我会撒谎知道以下哪种“模式”缺点：

1）从Here

获取代码

public class ContextFactory
{
    [ThreadStatic]
    private static DBDataContext context;
     //Get connectionString from web.config
    private static readonly string connString = ConfigurationManager.ConnectionStrings["ConnectionString1"].ConnectionString; 

    public static DBDataContext Context()
    {
        if (context == null)
            context = new DBDataContext(connString);
        return context;
    }

    public static void FlushContext()
    {
        context = new DBSkillDataContext(connString);
    } 
}

这样我每次初始化Controller时都会使用FlushContext。

2）以这种方式（从Here获取代码）

public class UnitOfWork : IUnitOfWork, IDisposable
   {
    DBContext context= null;
    IUserRepository userRepo = null;
    IAccountRepository accountRepo = null; 

    public UnitOfWork()
    {
        context= new DBContext();
        userRepo= new UserRepository(context);
        accountRepo= new accountRepo(context); 
    }

    public IUserRepository userRepo 
    {
        get
        {
            return userRepo;
        }
    }

    public IAccountRepository accountRepo 
    {
        get
        {
            return accountRepo;
        }
    } 

    public void Dispose()
    {
        // If this function is being called the user wants to release the
        // resources. lets call the Dispose which will do this for us.
        Dispose(true);

        // Now since we have done the cleanup already there is nothing left
        // for the Finalizer to do. So lets tell the GC not to call it later.
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing == true)
        {
            //someone want the deterministic release of all resources
            //Let us release all the managed resources
            context= null;
        }
    }

    ~UnitOfWork()
    {
        // The object went out of scope and finalized is called
        // Lets call dispose in to release unmanaged resources 
        // the managed resources will anyways be released when GC 
        // runs the next time.
        Dispose(false);
    }
} 

public abstract class AController : Controller
{
    private IUnitOfWork IUnitOfWork;

    protected IUnitOfWork UnitOfWork_
    {
        get { return IUnitOfWork; }
    }

    public AController(IUnitOfWork uow)
    {
        this.IUnitOfWork = uow; 
    }
}

public class UserController : AController
{
    // use our DbContext unit of work in case the page runs
    public UserController()
        : this(new UnitOfWork())
    {

    }

    // We will directly call this from the test projects
    public UserController(UnitOfWork unitOfWork)
        : base (unitOfWork)
    {

    }

    public ActionResult Index()
    {
        List<User> users= UnitOfWork_.usersRepo.GetUsers();

        return View(users);
    }

}

所以我要问的是，上面哪一个是最佳实践？

Answer 1

不要让DbContext静态。 DbContext不是线程安全的，并且使其静态使得它易于从多个线程使用 - 特别是在我们的场景中，这可能导致难以调试/解决错误甚至数据损坏。另外，在长时间内保持上下文活动并不是一个好主意 - 它会跟踪越来越多的实体，因此会逐渐变得越来越慢。它还会阻止GC收集正在跟踪但未使用的对象。另一个例子要好得多。 DbContext本身就是一种UnitOfWork。我不确定我是否会从这里的Reposiory模式开始。我宁愿直接使用DbContext，当它们从我的代码中出现时转移到使用模式，并且只有在使用模式有好处时（注意模式需要更多需要理解和维护的代码）。

ASP DBContext最佳实践

1 个答案: