3

我不太确定我的正确方法Dispose是什么ObjectContext。这是我的设置方式：

public abstract class DataManagerBase<T> where T:ObjectContext
{
    protected T _context = null;

    public string Message { get; set; }

    public DataManagerBase(T context)
    {
       _context = context;
    }
}

要在其他课程中使用它，我正在做类似的事情：

public class Test : DataManagerBase<DataEntities>
{
     public Test(DataEntities context) 
        : base(context){}

     public void InsertRecord(Person p)
     {
         if(_context != null)
         {
             try
             {
                 //Do insert logic
             }
             catch(Exception ex)
             {

             }
         }
    }

}

我有其他使用相同的方法_context，所以我没有使用using语句，所以如果_context抛出异常，我是否应该检查 is not null 然后处理它？基本上我想确保 _context 在我完成后被处理，无论是否有异常。将一个添加finally到每个try/catch是不正确的？

将此方法添加到我的 DataManagerBase 类中，然后在其他类中调用它就可以了：

 public void DisposeContext()
 {
        if (_context != null)
        {
            _context.Dispose();
        }
 }
4

4 回答 4

5

经验法则是：不要处置不是您创建的对象。所以你不应该在你一开始就提供的任何类中处理你的上下文。

但是，您应该在实际创建此特定实例的类中调用context.Dispose()。当你这样做时 - 不应该有其他对象使用它。您要做的是避免您遇到的设计问题，而不是修复它。那是错误的，恕我直言。当你忘记在某处放置另一个空检查时，这会在某个时候咬你。

使用您提供的代码，示例可能如下所示：

void SomeMethodInOuterScope()
{
    var context = new DataEntities();

    var test = new Test(context);

    try
    {
        test.InsertRecord(new Person());
        ...............
    }
    catch(Exception ex)
    {
        ....
    }
    finally
    {
        context.Dispose();
    }
}

这是另一个示例（当上下文不是本地时）

class SomeClassInOuterScope : IDisposable
{
    private DataEntities _context;

    public SomeClassInOuterScope()
    {
        _context = new DataEntities();
    }

    public void Test()
    {
        var test = new Test(_context);
        test.InsertRecord(new Person());
        ...............
    }

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

void SomeMethodInOuterOuterScope()
{
    var someclass = new SomeClassInOuterScope();

    try
    {
        someclass.Test();
        ...............
    }
    catch(Exception ex)
    {
        ....
    }
    finally
    {
        someclass.Dispose();
    }
}
于 2013-06-27T14:04:39.350 回答
3

最好是在一个地方创建和删除它。像

using(var context = factory.CreateContext())
{
    // use your context
}
于 2013-06-27T14:07:39.807 回答
0

你能不能Dispose在你的抽象类上添加一个方法。也许实现 IDisposable。

让调用代码的提供者使用一个using块。

所以在抽象类上：

 public void Dispose()
 {
        if (_context != null)
        {
            _context.Dispose();
        }
 }

调用代码：

using(var db = new Test())
{
... 
}

这样做的缺点是您依赖调用代码来管理您的上下文的一次性。

于 2013-06-27T14:12:35.080 回答
0

尽管可能需要处理上下文，但这并不是绝对必要的。垃圾收集器最终将处理它，并且实体框架使用 ado.net 连接池，因此它不会真正持有连接。

这样做并不是最有效的，但它不会导致任何泄漏，除非你的类本身有泄漏。每当您的 Test 类超出范围时，上下文最终将由 gc 处理。

如果您一遍又一遍地创建大量这些对象，您真的只会担心，情况可能并非如此。

我并不是说这是一个好的做法，但如果这是某种类型的错误修复，或者是临时的事情.. 可能没有必要。

于 2013-06-27T14:23:20.357 回答