0

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

在实践中，我会撒谎以了解以下“模式”中的哪一个具有较少的缺点：

1) 从这里获取代码 

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）以这种方式（从这里获取代码）

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

}

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

4

1 回答 1

0

不要使 DbContext 成为静态的。DbContext 不是线程安全的，将其设为静态可以轻松地从多个线程中使用——尤其是在我们可能导致难以调试/解决错误甚至可能导致数据损坏的场景中。此外，让上下文长时间保持活动状态并不是一个好主意——它会跟踪越来越多的实体，因此会逐渐变得越来越慢。它还将阻止 GC 收集正在跟踪但未使用的对象。另一个例子要好得多。DbContext 本身就是一种 UnitOfWork。我不确定我是否会从这里的存储库模式开始。

于 2013-09-24T04:02:28.607 回答