線程共享的DbContext與私有的DbContext

作者：張占嶺 2012-08-24 09:24:06

在使用Linq to Sql做為底層ORM時，它為我們提供的數據上下文為DataContext對象，實現上我們通過拖動生成的DBML文件，它們都是繼承自 System.Data.Linq.DataContext類型的，所以DataContext就是LINQ數據對象的基類，有時，我們可以通過這種類的多態性來動態創建DB的實例。

在每個DataContext類中，它有幾個實例的構造方法，用來讓你創建DataContext的實例，如下：

/// <summary>  
         /// 使用默認的連接串創建實現（每拖一次數據庫，就會產生一個連接串）  
         /// </summary>  
         public DataClasses1DataContext() :   
                 base(global::test.Properties.Settings.Default.EEE114ConnectionString, mappingSource)  
         {  
             OnCreated();  
         }  
         /// <summary>  
         /// 使用指定的連接串，可能配置在config文件里  
         /// </summary>  
         /// <param name="connection"></param>  
         public DataClasses1DataContext(string connection) :   
                 base(connection, mappingSource)  
         {  
             OnCreated();  
         }  
         /// <summary>  
         /// 使用使用了IDbConnection接口的對象創建實例  
         /// </summary>  
         /// <param name="connection"></param>  
         public DataClasses1DataContext(System.Data.IDbConnection connection) :   
                 base(connection, mappingSource)  
         {  
             OnCreated();  
         }  
         /// <summary>  
         /// 使用連接串和數據庫的映射文件來建立實例，mappingSource可能是一個XML文件  
         /// </summary>  
         /// <param name="connection"></param>  
         /// <param name="mappingSource"></param>  
         public DataClasses1DataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) :   
                 base(connection, mappingSource)  
         {  
             OnCreated();  
         }

而我們在實現項目開發中，可能用第二種比較多，即

DataClasses1DataContext db=new LINQ.DataClasses1DataContext(System.Configuration.ConfigurationManager.ConnectionStrings["XXB"].ToString())

這樣，在開發環境與生成環境只要配置一個CONFIG文件即可。靈活。

而今天的主題是線程共享的DbContext與私有的DbContext，所以開始書歸正轉了，對于ado.net架構中，我們往往使用一個static全局對象來完成數據訪問工作，而在linq to sql中，如果你建立一個static對象，它會出現很多問題，這在實現開發過程中才可以體會到，所以，今天要說的不是static對象。

一線程共享的DbContext，說清楚一點就是在一個線程內，你的DataContext對象是共享的，是一個對象，不是new出很多個datacontext對象來，這事實上是一種單例模式的體現，這沒有問題，它解決了static對象所產生的問題，而又滿足了多表關聯查詢時出現（不能實現不同數據上下文件的引用，linq to sql和Ef都是這樣的）的問題。

代碼：

datacontext生成工廠：

/// <summary>  
     /// 數據庫建立工廠  
     /// Created By : 張占嶺  
     /// Created Date：2011-10-14  
     /// Modify By:  
     /// Modify Date:  
     /// Modify Reason:  
     /// </summary>  
     internal sealed class DbFactory  
     {  
         #region Fields  
         static System.Timers.Timer sysTimer = new System.Timers.Timer(10000);  
         volatile static Dictionary<Thread, DbContext[]> divDataContext = new Dictionary<Thread, DbContext[]>();  
         #endregion  
   
         #region Constructors  
         /// <summary>  
         /// 類構造方法  
         /// </summary>  
         static DbFactory()  
         {  
             sysTimer.AutoReset = true;  
             sysTimer.Enabled = true;  
             sysTimer.Elapsed += new System.Timers.ElapsedEventHandler(sysTimer_Elapsed);  
             sysTimer.Start();  
         }  
         #endregion  
   
         #region  Static Methods  
   
         /// <summary>  
         /// 訂閱Elapsed事件的方法  
         /// </summary>  
         /// <param name="sender"></param>  
         /// <param name="e"></param>  
         static void sysTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)  
         {  
             List<Thread> list = divDataContext.Keys.Where(item => item.ThreadState == ThreadState.Stopped).ToList();  
             for (int index = 0; index < list.Count; index++)  
             {  
                 for (int refer = 0; refer < divDataContext[list[index]].Length; refer++)  
                     if (divDataContext[list[index]][refer] != null)  
                     {  
                         divDataContext[list[index]][refer].Dispose();  
                         divDataContext[list[index]][refer] = null;  
                     }  
                 divDataContext.Remove(list[index]);  
                 list[index] = null;  
             }  
         }  
         /// <summary>  
         /// 通過工廠的制造模式獲取相應的LINQ數據庫連接對象  
         /// </summary>  
         /// <param name="dbName">數據庫名稱(需要與真實數據庫名稱保持一致)</param>  
         /// <returns>LINQ數據庫連接對象</returns>  
         public static DbContext Intance(string dbName)  
         {  
             return Intance(dbName, Thread.CurrentThread, 1, 0);  
         }  
   
         /// <summary>  
         /// 通過工廠的制造模式獲取相應的LINQ數據庫連接對象  
         /// </summary>  
         /// <param name="dbName"></param>  
         /// <param name="dbCount"></param>  
         /// <param name="dbIndex"></param>  
         /// <returns></returns>  
         public static DbContext Intance(string dbName, int dbCount, int dbIndex)  
         {  
             return Intance(dbName, Thread.CurrentThread, dbCount, dbIndex);  
         }  
   
         /// <summary>  
         /// 通過工廠的制造模式獲取相應的LINQ數據庫連接對象  
         /// </summary>  
         /// <param name="dbName">數據庫名稱(需要與真實數據庫名稱保持一致)</param>  
         /// <param name="thread">當前線程引用的對象</param>  
         /// <param name="dbCount">linq to sql數據庫數量</param>  
         /// <param name="dbIndex">當前索引</param>  
         /// <returns>LINQ對象上下文</returns>  
         public static DbContext Intance(string dbName, Thread thread, int dbCount, int dbIndex)  
         {  
             if (!divDataContext.Keys.Contains(thread))  
             {  
                 divDataContext.Add(thread, new DbContext[dbCount]);  
             }  
             if (divDataContext[thread][dbIndex] == null)  
             {  
                 divDataContext[thread][dbIndex] = new DbContext(dbName);  
             }  
             return divDataContext[thread][dbIndex];  
         }  
   
         /// <summary>  
         /// 通過工廠的制造模式獲取相應的LINQ數據庫連接對象  
         /// </summary>  
         /// <param name="dbName"></param>  
         /// <param name="thread"></param>  
         /// <returns></returns>  
         public static DbContext Intance(string dbName, Thread thread)  
         {  
             return Intance(dbName, thread, 1, 0);  
         }  
         #endregion  
   
     }

具體領域數據對象創建時代碼如下：

/// <summary>  
     /// XXB數據庫基類  
     /// </summary>  
     public class XXB_DataBase : DataBase  
     {  
         private readonly static string _conn;  
         static XXB_DataBase()  
         {  
             if (ConfigurationManager.ConnectionStrings["XXB"] == null)  
                 throw new Exception("請設置XXB配置字符");  
             else 
                 _conn = ConfigurationManager.ConnectionStrings["XXB"].ToString();  
         }  
         public XXB_DataBase()  
             : base(DbFactory.Intance(_conn, 2, 1))  
         { }  
   
     }

二私有的DbContext，它要求你為每個表都建立一個repository對象，用戶對表進行CURD操作，而它們都繼承一個database，在 database里有唯一創建datacontext的入口，這樣在做多表關聯時，使用的是同一個datacontext對象，所以不會出現“不能實現不同數據上下文件的引用”這種問題，但這樣方式感覺很不爽，因為你必須把所有多表關聯的業務邏輯，寫在DAL層，這是很郁悶的，因為一般我們會把它放在BLL層（更有利于業務的組合與重用）。

代碼：

具體領域數據基類：

/// <summary>  
     /// ＸＸＢ數據基類  
     /// </summary>  
     public abstract class XXBBase : DataBase  
     {  
         public XXBBase()  
             : base(new LINQ.DataClasses1DataContext(System.Configuration.ConfigurationManager.ConnectionStrings["XXB"].ToString()))  
         { }  
     }

統一數據基類：

/// <summary>  
     /// 標準數據操作基類  
     /// </summary>  
     public abstract class DataBase : IRepository  
     {  
         /// <summary>  
         /// 數據訪問對象（只對子類可見）  
         /// </summary>  
         protected DataContext DB;  
   
         #region Constructors  
         public DataBase(DataContext db)  
             : this(() => { return db; })  
         { }  
         public DataBase(Func<DataContext> func)  
         {  
             this.DB = func();  
         }  
         #endregion  
   
         #region DBContext SubmitChanges  
         /// <summary>  
         /// XXB默認提交【重寫時候可能需要寫入自定義的類似約束的邏輯】  
         /// </summary>  
         protected virtual void SubmitChanges()  
         {  
             ChangeSet cSet = DB.GetChangeSet();  
             if (cSet.Inserts.Count > 0 
                 || cSet.Updates.Count > 0 
                 || cSet.Deletes.Count > 0)  
             {  
                 try 
                 {  
                     DB.SubmitChanges(System.Data.Linq.ConflictMode.ContinueOnConflict);  
                 }  
                 catch (System.Data.Linq.ChangeConflictException)  
                 {  
                     foreach (System.Data.Linq.ObjectChangeConflict occ in DB.ChangeConflicts)  
                     {  
                         occ.Resolve(System.Data.Linq.RefreshMode.OverwriteCurrentValues);  
                         occ.Resolve(System.Data.Linq.RefreshMode.KeepCurrentValues);  
                         occ.Resolve(System.Data.Linq.RefreshMode.KeepChanges);  
                     }  
                     DB.SubmitChanges();  
                 }  
             }  
         }  
   
         #endregion  
   
         #region IRepository 成員  
   
         public virtual void Update<TEntity>(TEntity entity) where TEntity : class 
         {  
             this.SubmitChanges();  
   
         }  
   
         public virtual void Update<TEntity>(IEnumerable<TEntity> list) where TEntity : class 
         {  
             list.ToList().ForEach(entity =>  
             {  
                 this.Update<TEntity>(entity);  
             });  
         }  
   
         public virtual void Insert<TEntity>(TEntity entity) where TEntity : class 
         {  
             DB.GetTable<TEntity>().InsertOnSubmit(entity);  
             this.SubmitChanges();  
         }  
   
         public virtual void Insert<TEntity>(IEnumerable<TEntity> list) where TEntity : class 
         {  
             DB.GetTable<TEntity>().InsertAllOnSubmit<TEntity>(list);  
             this.SubmitChanges();  
         }  
   
         public virtual TEntity InsertGetIDENTITY<TEntity>(TEntity entity) where TEntity : class 
         {  
             this.Insert<TEntity>(entity);  
             return GetModel<TEntity>(i => i == entity).FirstOrDefault();  
         }  
   
         public virtual void Delete<TEntity>(TEntity entity) where TEntity : class 
         {  
             DB.GetTable<TEntity>().DeleteOnSubmit(entity);  
             this.SubmitChanges();  
         }  
   
         public virtual void Delete<TEntity>(IEnumerable<TEntity> list) where TEntity : class 
         {  
             DB.GetTable<TEntity>().DeleteAllOnSubmit<TEntity>(list);  
             this.SubmitChanges();  
         }  
   
         public virtual IQueryable<TEntity> GetModel<TEntity>() where TEntity : class 
         {  
             return this.DB.GetTable<TEntity>();  
         }  
   
         public virtual IQueryable<TEntity> GetModel<TEntity>(System.Linq.Expressions.Expression<Func<TEntity, bool>> predicate) where TEntity : class 
         {  
             return GetModel<TEntity>().Where(predicate);  
         }  
   
         public virtual TEntity Find<TEntity>(params object[] keyValues) where TEntity : class 
         {  
             var mapping = DB.Mapping.GetTable(typeof(TEntity));  
             var keys = mapping.RowType.IdentityMembers.Select((m, i) => m.Name + " = @" + i).ToArray();  
             TEntity entityTEntity = DB.GetTable<TEntity>().Where(String.Join(" && ", keys), keyValues).FirstOrDefault();  
             if (entityTEntity != null)  
                 DB.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, entityTEntity);  
             return entityTEntity;  
         }  
   
         #endregion  
     }

而用戶模塊User_InfoRepository在做多表關聯時，是這樣完成的：

public class User_InfoRepository : XXBBase  
     {  
         /// <summary>  
         /// 需要把Join的表關系寫在這里  
         /// </summary>  
         /// <returns></returns>  
         public IQueryable<User_Info> GetDetailModel()  
         {  
             var linq = from data1 in base.GetModel<User_Info>()  
                        join data2 in base.GetModel<User_Profile>() on data1.UserID equals data2.UserID  
                        select data1;  
             return linq;  
         }  
     }

原文鏈接：http://www.cnblogs.com/lori/archive/2012/08/23/2653426.html

責任編輯：林師授來源：博客園

線程 DbContext

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

線程共享的DbContext與私有的DbContext