Entity Framework中的連接管理

EF框架對數據庫的連接提供了一系列的默認行為，通常情況下不需要我們太多的關注。但是，這種封裝，降低了靈活性，有時我們需要對數據庫連接加以控制。

EF提供了兩種方案控制數據庫連接：

• 傳遞到Context的連接；
• Database.Connnection.Open()；

下面詳解。

傳遞到Context的連接

EF6之前版本

有兩個接受Connection的構造方法：

public DbContext(DbConnection existingConnection, bool contextOwnsConnection) 
public DbContext(DbConnection existingConnection, DbCompiledModel model, bool contextOwnsConnection)

使用上面兩個方法的時候需要注意的限制：
1、如果使用上面任意一個方法，傳遞了一個已經打開的連接，則會在首次使用EF操作數據庫時拋出一個InvalidOperationException異常，表示不能重復打開一個鏈接；

2、contextOwnsConnection參數指示在DbContext對象Dispose時候是否Dispose底層的數據庫連接。無論參數是否設置，在DbContext.Dispose()時都會關閉底層的Connection。所以，如果你有超過一個DbContext使用同一連接，其中任何一個DbContext對象Dispose時都會關閉該連接（類似的，如果你將ADO.NET 和DbContext對象混合使用，在DbContect對象Dispose時也會關閉連接）。

可以通過傳遞一個關閉的連接，在創建的上下文中僅打開一次連接，且僅執行代碼繞過上面第一條限制。如下：

using System.Collections.Generic; 
using System.Data.Common; 
using System.Data.Entity; 
using System.Data.Entity.Infrastructure; 
using System.Data.EntityClient; 
using System.Linq; 
 
namespace ConnectionManagementExamples 
{ 
    class ConnectionManagementExampleEF5 
    {         
        public static void TwoDbContextsOneConnection() 
        { 
            using (var context1 = new BloggingContext()) 
            { 
                var conn = 
                    ((EntityConnection)  
                        ((IObjectContextAdapter)context1).ObjectContext.Connection)  
                            .StoreConnection; 
 
                using (var context2 = new BloggingContext(conn, contextOwnsConnection: false)) 
                { 
                    context2.Database.ExecuteSqlCommand( 
                        @"UPDATE Blogs SET Rating = 5" + 
                        " WHERE Name LIKE '%Entity Framework%'"); 
 
                    var query = context1.Posts.Where(p => p.Blog.Rating > 5); 
                    foreach (var post in query) 
                    { 
                        post.Title += "[Cool Blog]"; 
                    } 
                    context1.SaveChanges(); 
                } 
            } 
        } 
    } 
}

第二個限制僅僅意味着你要確保確實要關閉連接后再調用DbContext.Dispose()。

EF6版本及更新版本

EF6和將來的版本的DbContext有兩個與以往版本相同重載的構造方法，但是不在要求傳遞一個關閉的連接了。所以下面代碼在EF6及以后版本是正確的：

using System.Collections.Generic; 
using System.Data.Entity; 
using System.Data.SqlClient; 
using System.Linq; 
using System.Transactions; 
 
namespace ConnectionManagementExamples 
{ 
    class ConnectionManagementExample 
    { 
        public static void PassingAnOpenConnection() 
        { 
            using (var conn = new SqlConnection("{connectionString}")) 
            { 
                conn.Open(); 
 
                var sqlCommand = new SqlCommand(); 
                sqlCommand.Connection = conn; 
                sqlCommand.CommandText = 
                    @"UPDATE Blogs SET Rating = 5" + 
                     " WHERE Name LIKE '%Entity Framework%'"; 
                sqlCommand.ExecuteNonQuery(); 
 
                using (var context = new BloggingContext(conn, contextOwnsConnection: false)) 
                { 
                    var query = context.Posts.Where(p => p.Blog.Rating > 5); 
                    foreach (var post in query) 
                    { 
                        post.Title += "[Cool Blog]"; 
                    } 
                    context.SaveChanges(); 
                } 
 
                var sqlCommand2 = new SqlCommand(); 
                sqlCommand2.Connection = conn; 
                sqlCommand2.CommandText = 
                    @"UPDATE Blogs SET Rating = 7" + 
                     " WHERE Name LIKE '%Entity Framework Rocks%'"; 
                sqlCommand2.ExecuteNonQuery(); 
            } 
        } 
    } 
}

      還有，現在contextOwnsConnection參數決定是否要在DbContext對象Dispose時關閉並Dispose連接對象。因此，上面代碼，在DbContext對象Dispose時，數據庫並未關閉（32行），但在以前的版本在此處會關閉連接。上面代碼會在第40行關閉並釋放。
       當然，如果你仍然可以讓DbContext對象控制連接，把contextOwnsConnection設置為true，或者使用另一個構造方法。

Database.Connnection.Open()

EF6以前的版本

EF5及之前版本ObjectionContext.Connection.State狀態更新存在BUG，該值不能正確反映底層連接的狀態。例如執行下面代碼，獲取的狀態為Closed，即使其底層確實為Open：

((IObjectContextAdapter)context).ObjectContext.Connection.State

      另外，如果你通過調用Database.Connection.Open()打開數據庫連接，數據庫連接將一直打開，直到執行下次執行一個查詢或者任何請求連接的操作（例如SaveChanges）。但是在此之后底層連接將會被關閉。那么Context將會因任意的數據庫操作而重新打開連接並在之后重新關閉：

using System; 
using System.Data; 
using System.Data.Entity; 
using System.Data.Entity.Infrastructure; 
using System.Data.EntityClient; 
 
namespace ConnectionManagementExamples 
{ 
    public class DatabaseOpenConnectionBehaviorEF5 
    { 
        public static void DatabaseOpenConnectionBehavior() 
        { 
            using (var context = new BloggingContext()) 
            { 
                // At this point the underlying store connection is closed 
 
                context.Database.Connection.Open(); 
 
                // Now the underlying store connection is open  
                // (though ObjectContext.Connection.State will report closed) 
 
                var blog = new Blog { /* Blog’s properties */ }; 
                context.Blogs.Add(blog); 
                 
                // The underlying store connection is still open  
 
                context.SaveChanges(); 
 
                // After SaveChanges() the underlying store connection is closed  
                // Each SaveChanges() / query etc now opens and immediately closes 
                // the underlying store connection 
 
                blog = new Blog { /* Blog’s properties */ }; 
                context.Blogs.Add(blog); 
                context.SaveChanges(); 
            } 
        } 
    } 
}

 

EF6及將來版本

       在EF6和將來的版本中，框架采用的方案是如果代碼通過context.Database.Connection.Open()打開一個數據庫連接，有理由相信代碼想要自己控制連接的打開和關閉，框架將不再自動關閉連接。

       注意：這一特性可能造成數據庫連接長時間打開，所以要特別留意，防止連接未及時關閉。

       EF6中修復了ObjectContext.Connection.State狀態更新的BUG。

using System; 
using System.Data; 
using System.Data.Entity; 
using System.Data.Entity.Core.EntityClient; 
using System.Data.Entity.Infrastructure; 
 
namespace ConnectionManagementExamples 
{ 
    internal class DatabaseOpenConnectionBehaviorEF6 
    { 
        public static void DatabaseOpenConnectionBehavior() 
        { 
            using (var context = new BloggingContext()) 
            { 
                // At this point the underlying store connection is closed 
 
                context.Database.Connection.Open(); 
 
                // Now the underlying store connection is open and the 
                // ObjectContext.Connection.State correctly reports open too 
                 
                var blog = new Blog { /* Blog’s properties */ }; 
                context.Blogs.Add(blog); 
                context.SaveChanges(); 
 
                // The underlying store connection remains open for the next operation  
                    
                blog = new Blog { /* Blog’s properties */ }; 
                context.Blogs.Add(blog); 
                context.SaveChanges(); 
 
                // The underlying store connection is still open 
  
           } // The context is disposed – so now the underlying store connection is closed 
        } 
    } 
}