C# 处置不工作，许多死连接

自从更新到EF6后，我就有了一些奇怪的事情，不确定这是否有关系，但过去一直很好

我正在做一组工作，然后将其保存到DB，然后再做另一个，保存另一个

过了一会儿，我通过

sp_who2

检查SQL server，发现我的计算机上有许多死连接

工作是巨大的然后有700个连接， 我必须在循环中手动杀死它们

程序如下：

while (jobDone == false)
{
     var returnData=doOneSetJob();
     myEntity dbconn= new myEntity;

     foreach( var one in retrunData) 
     {

        dbconn.targetTable.add(one );
        try
        {  
            dbconn.savechange();
            /// even i put a dispose() here , still lots of dead connections
        }
        catch
        {
           console.writeline("DB Insertion Fail.");
           dbconn.dispose();
           dbconn= new myEntity();
         }
     }

     dbconn.dispose()
}

---

<>你应该考虑重构你的代码，这样你的连接在你的工作完成后就被清理干净了。例如：

using (var context = new DbContext())
{
        while (!jobDone)
        {
            // Execute job and get data
            var returnData = doOneSetJob();

            // Process job results
            foreach (var one in returnData)
            {
                try
                {
                    context.TargetTable.Add(one);
                    context.SaveChanges();
                }
                catch (Exception ex)
                {
                    // Log the error
                }
            }
        }
}

---

<>代码>使用语句将保证您的上下文被正确清理，即使在您循环结果时发生错误。

< P>您应该考虑重构代码，以便在完成作业后清理连接。例如：

using (var context = new DbContext())
{
        while (!jobDone)
        {
            // Execute job and get data
            var returnData = doOneSetJob();

            // Process job results
            foreach (var one in returnData)
            {
                try
                {
                    context.TargetTable.Add(one);
                    context.SaveChanges();
                }
                catch (Exception ex)
                {
                    // Log the error
                }
            }
        }
}

---

<>代码>使用语句将保证您的上下文被正确清理，即使在您循环结果时发生错误。

< P>您应该考虑重构代码，以便在完成作业后清理连接。例如：

using (var context = new DbContext())
{
        while (!jobDone)
        {
            // Execute job and get data
            var returnData = doOneSetJob();

            // Process job results
            foreach (var one in returnData)
            {
                try
                {
                    context.TargetTable.Add(one);
                    context.SaveChanges();
                }
                catch (Exception ex)
                {
                    // Log the error
                }
            }
        }
}

---

<>代码>使用语句将保证您的上下文被正确清理，即使在您循环结果时发生错误。

< P>您应该考虑重构代码，以便在完成作业后清理连接。例如：

using (var context = new DbContext())
{
        while (!jobDone)
        {
            // Execute job and get data
            var returnData = doOneSetJob();

            // Process job results
            foreach (var one in returnData)
            {
                try
                {
                    context.TargetTable.Add(one);
                    context.SaveChanges();
                }
                catch (Exception ex)
                {
                    // Log the error
                }
            }
        }
}

---

using

语句将保证正确清理您的上下文，即使在循环遍历结果时发生错误。

在这种情况下，您应该使用

using

语句。摘自：

using语句确保即使在调用对象上的方法时发生异常，也会调用Dispose。通过将对象放在try块中，然后在finally块中调用Dispose，可以获得相同的结果；事实上，编译器就是这样翻译using语句的

因此，您的代码看起来更像这样：

using(var dbconn = new DbContext())
{
    while (!jobDone)
    {
        foreach(var one in retrunData)
        {
            try
            {
                targetTable row = new TargetTable();
                dbconn.TargetTable.add(row);

                dbconn.SaveChanges();
            }
            catch (Exception ex)
            {
                Console.WriteLine("DB Insertion Fail.");
            }
        }
    }
}

---

这样，即使您的代码在某个点失败，

上下文、资源和连接也将得到正确处理。
在这种情况下，您应该使用
using
语句。摘自：

using语句确保即使在调用对象上的方法时发生异常，也会调用Dispose。通过将对象放在try块中，然后在finally块中调用Dispose，可以获得相同的结果；事实上，编译器就是这样翻译using语句的

因此，您的代码看起来更像这样：

using(var dbconn = new DbContext())
{
    while (!jobDone)
    {
        foreach(var one in retrunData)
        {
            try
            {
                targetTable row = new TargetTable();
                dbconn.TargetTable.add(row);

                dbconn.SaveChanges();
            }
            catch (Exception ex)
            {
                Console.WriteLine("DB Insertion Fail.");
            }
        }
    }
}

这样，即使您的代码在某个点失败，
上下文、资源和连接也将得到正确处理。
在这种情况下，您应该使用
using
语句。摘自：

using语句确保即使在调用对象上的方法时发生异常，也会调用Dispose。通过将对象放在try块中，然后在finally块中调用Dispose，可以获得相同的结果；事实上，编译器就是这样翻译using语句的

因此，您的代码看起来更像这样：

using(var dbconn = new DbContext())
{
    while (!jobDone)
    {
        foreach(var one in retrunData)
        {
            try
            {
                targetTable row = new TargetTable();
                dbconn.TargetTable.add(row);

                dbconn.SaveChanges();
            }
            catch (Exception ex)
            {
                Console.WriteLine("DB Insertion Fail.");
            }
        }
    }
}

这样，即使您的代码在某个点失败，
上下文、资源和连接也将得到正确处理。
在这种情况下，您应该使用
using
语句。摘自：

using语句确保即使在调用对象上的方法时发生异常，也会调用Dispose。通过将对象放在try块中，然后在finally块中调用Dispose，可以获得相同的结果；事实上，编译器就是这样翻译using语句的

因此，您的代码看起来更像这样：

using(var dbconn = new DbContext())
{
    while (!jobDone)
    {
        foreach(var one in retrunData)
        {
            try
            {
                targetTable row = new TargetTable();
                dbconn.TargetTable.add(row);

                dbconn.SaveChanges();
            }
            catch (Exception ex)
            {
                Console.WriteLine("DB Insertion Fail.");
            }
        }
    }
}

这样，即使您的代码在某个点失败，上下文、资源和连接也会得到正确的处理。
我认为应该是“var dbconn=new DbContext（）”而不是dbi我认为应该是“var dbconn=new DbContext（）”而不是dbi我认为应该是“var dbconn=new DbContext（）”我认为应该是“var dbconn=new DbContext（）”而不是db