LINQ-to-SQL那點事~線程共享的DbContext與私有的DbContext

本文轉載自查看原文 2012-08-23 23:04 3378 LINQ/ MVC/ 系統架構

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

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

 1     /// <summary>
 2         /// 使用默認的連接串創建實現（每拖一次數據庫，就會產生一個連接串）
 3         /// </summary>
 4         public DataClasses1DataContext() : 
 5                 base(global::test.Properties.Settings.Default.EEE114ConnectionString, mappingSource)
 6         {
 7             OnCreated();
 8         }
 9         /// <summary>
10         /// 使用指定的連接串，可能配置在config文件里
11         /// </summary>
12         /// <param name="connection"></param>
13         public DataClasses1DataContext(string connection) : 
14                 base(connection, mappingSource)
15         {
16             OnCreated();
17         }
18         /// <summary>
19         /// 使用使用了IDbConnection接口的對象創建實例
20         /// </summary>
21         /// <param name="connection"></param>
22         public DataClasses1DataContext(System.Data.IDbConnection connection) : 
23                 base(connection, mappingSource)
24         {
25             OnCreated();
26         }
27         /// <summary>
28         /// 使用連接串和數據庫的映射文件來建立實例，mappingSource可能是一個XML文件
29         /// </summary>
30         /// <param name="connection"></param>
31         /// <param name="mappingSource"></param>
32         public DataClasses1DataContext(string connection, System.Data.Linq.Mapping.MappingSource mappingSource) : 
33                 base(connection, mappingSource)
34         {
35             OnCreated();
36         }

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

1 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生成工廠：

  1     /// <summary>
  2     /// 數據庫建立工廠
  3     /// Created By : 張占嶺
  4     /// Created Date：2011-10-14
  5     /// Modify By:
  6     /// Modify Date:
  7     /// Modify Reason:
  8     /// </summary>
  9     internal sealed class DbFactory
 10     {
 11         #region Fields
 12         static System.Timers.Timer sysTimer = new System.Timers.Timer(10000);
 13         volatile static Dictionary<Thread, DataContext[]> divDataContext = new Dictionary<Thread, DataContext[]>();
 14         #endregion
 15 
 16         #region Constructors
 17         /// <summary>
 18         /// 類構造方法
 19         /// </summary>
 20         static DbFactory()
 21         {
 22             sysTimer.AutoReset = true;
 23             sysTimer.Enabled = true;
 24             sysTimer.Elapsed += new System.Timers.ElapsedEventHandler(sysTimer_Elapsed);
 25             sysTimer.Start();
 26         }
 27         #endregion
 28 
 29         #region  Static Methods
 30 
 31         /// <summary>
 32         /// 訂閱Elapsed事件的方法
 33         /// </summary>
 34         /// <param name="sender"></param>
 35         /// <param name="e"></param>
 36         static void sysTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
 37         {
 38             List<Thread> list = divDataContext.Keys.Where(item => item.ThreadState == ThreadState.Stopped).ToList();
 39             for (int index = 0; index < list.Count; index++)
 40             {
 41                 for (int refer = 0; refer < divDataContext[list[index]].Length; refer++)
 42                     if (divDataContext[list[index]][refer] != null)
 43                     {
 44                         divDataContext[list[index]][refer].Dispose();
 45                         divDataContext[list[index]][refer] = null;
 46                     }
 47                 divDataContext.Remove(list[index]);
 48                 list[index] = null;
 49             }
 50         }
 51         /// <summary>
 52         /// 通過工廠的制造模式獲取相應的LINQ數據庫連接對象
 53         /// </summary>
 54         /// <param name="dbName">數據庫名稱(需要與真實數據庫名稱保持一致)</param>
 55         /// <returns>LINQ數據庫連接對象</returns>
 56         public static DataContextIntance(string dbName)
 57         {
 58             return Intance(dbName, Thread.CurrentThread, 1, 0);
 59         }
 60 
 61         /// <summary>
 62         /// 通過工廠的制造模式獲取相應的LINQ數據庫連接對象
 63         /// </summary>
 64         /// <param name="dbName"></param>
 65         /// <param name="dbCount"></param>
 66         /// <param name="dbIndex"></param>
 67         /// <returns></returns>
 68         public static DataContextIntance(string dbName, int dbCount, int dbIndex)
 69         {
 70             return Intance(dbName, Thread.CurrentThread, dbCount, dbIndex);
 71         }
 72 
 73         /// <summary>
 74         /// 通過工廠的制造模式獲取相應的LINQ數據庫連接對象
 75         /// </summary>
 76         /// <param name="dbName">數據庫名稱(需要與真實數據庫名稱保持一致)</param>
 77         /// <param name="thread">當前線程引用的對象</param>
 78         /// <param name="dbCount">linq to sql數據庫數量</param>
 79         /// <param name="dbIndex">當前索引</param>
 80         /// <returns>LINQ對象上下文</returns>
 81         public static DataContextIntance(string dbName, Thread thread, int dbCount, int dbIndex)
 82         {
 83             if (!divDataContext.Keys.Contains(thread))
 84             {
 85                 divDataContext.Add(thread, new DbContext[dbCount]);
 86             }
 87             if (divDataContext[thread][dbIndex] == null)
 88             {
 89                 divDataContext[thread][dbIndex] = new DbContext(dbName);
 90             }
 91             return divDataContext[thread][dbIndex];
 92         }
 93 
 94         /// <summary>
 95         /// 通過工廠的制造模式獲取相應的LINQ數據庫連接對象
 96         /// </summary>
 97         /// <param name="dbName"></param>
 98         /// <param name="thread"></param>
 99         /// <returns></returns>
100         public static DataContextIntance(string dbName, Thread thread)
101         {
102             return Intance(dbName, thread, 1, 0);
103         }
104         #endregion
105 
106     }

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

 1 /// <summary>
 2     /// XXB數據庫基類
 3     /// </summary>
 4     public class XXB_DataBase : DataBase
 5     {
 6         private readonly static string _conn;
 7         static XXB_DataBase()
 8         {
 9             if (ConfigurationManager.ConnectionStrings["XXB"] == null)
10                 throw new Exception("請設置XXB配置字符");
11             else
12                 _conn = ConfigurationManager.ConnectionStrings["XXB"].ToString();
13         }
14         public XXB_DataBase()
15             : base(DbFactory.Intance(_conn, 2, 1))
16         { }
17 
18     }

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

代碼：

具體領域數據基類：

1  /// <summary>
2     /// ＸＸＢ數據基類
3     /// </summary>
4     public abstract class XXBBase : DataBase
5     {
6         public XXBBase()
7             : base(new LINQ.DataClasses1DataContext(System.Configuration.ConfigurationManager.ConnectionStrings["XXB"].ToString()))
8         { }
9     }

統一數據基類：

  1   /// <summary>
  2     /// 標准數據操作基類
  3     /// </summary>
  4     public abstract class DataBase : IRepository
  5     {
  6         /// <summary>
  7         /// 數據訪問對象（只對子類可見）
  8         /// </summary>
  9         protected DataContext DB;
 10 
 11         #region Constructors
 12         public DataBase(DataContext db)
 13             : this(() => { return db; })
 14         { }
 15         public DataBase(Func<DataContext> func)
 16         {
 17             this.DB = func();
 18         }
 19         #endregion
 20 
 21         #region DBContext SubmitChanges
 22         /// <summary>
 23         /// XXB默認提交【重寫時候可能需要寫入自定義的類似約束的邏輯】
 24         /// </summary>
 25         protected virtual void SubmitChanges()
 26         {
 27             ChangeSet cSet = DB.GetChangeSet();
 28             if (cSet.Inserts.Count > 0
 29                 || cSet.Updates.Count > 0
 30                 || cSet.Deletes.Count > 0)
 31             {
 32                 try
 33                 {
 34                     DB.SubmitChanges(System.Data.Linq.ConflictMode.ContinueOnConflict);
 35                 }
 36                 catch (System.Data.Linq.ChangeConflictException)
 37                 {
 38                     foreach (System.Data.Linq.ObjectChangeConflict occ in DB.ChangeConflicts)
 39                     {
 40                         occ.Resolve(System.Data.Linq.RefreshMode.OverwriteCurrentValues);
 41                         occ.Resolve(System.Data.Linq.RefreshMode.KeepCurrentValues);
 42                         occ.Resolve(System.Data.Linq.RefreshMode.KeepChanges);
 43                     }
 44                     DB.SubmitChanges();
 45                 }
 46             }
 47         }
 48 
 49         #endregion
 50 
 51         #region IRepository 成員
 52 
 53         public virtual void Update<TEntity>(TEntity entity) where TEntity : class
 54         {
 55             this.SubmitChanges();
 56 
 57         }
 58 
 59         public virtual void Update<TEntity>(IEnumerable<TEntity> list) where TEntity : class
 60         {
 61             list.ToList().ForEach(entity =>
 62             {
 63                 this.Update<TEntity>(entity);
 64             });
 65         }
 66 
 67         public virtual void Insert<TEntity>(TEntity entity) where TEntity : class
 68         {
 69             DB.GetTable<TEntity>().InsertOnSubmit(entity);
 70             this.SubmitChanges();
 71         }
 72 
 73         public virtual void Insert<TEntity>(IEnumerable<TEntity> list) where TEntity : class
 74         {
 75             DB.GetTable<TEntity>().InsertAllOnSubmit<TEntity>(list);
 76             this.SubmitChanges();
 77         }
 78 
 79         public virtual TEntity InsertGetIDENTITY<TEntity>(TEntity entity) where TEntity : class
 80         {
 81             this.Insert<TEntity>(entity);
 82             return GetModel<TEntity>(i => i == entity).FirstOrDefault();
 83         }
 84 
 85         public virtual void Delete<TEntity>(TEntity entity) where TEntity : class
 86         {
 87             DB.GetTable<TEntity>().DeleteOnSubmit(entity);
 88             this.SubmitChanges();
 89         }
 90 
 91         public virtual void Delete<TEntity>(IEnumerable<TEntity> list) where TEntity : class
 92         {
 93             DB.GetTable<TEntity>().DeleteAllOnSubmit<TEntity>(list);
 94             this.SubmitChanges();
 95         }
 96 
 97         public virtual IQueryable<TEntity> GetModel<TEntity>() where TEntity : class
 98         {
 99             return this.DB.GetTable<TEntity>();
100         }
101 
102         public virtual IQueryable<TEntity> GetModel<TEntity>(System.Linq.Expressions.Expression<Func<TEntity, bool>> predicate) where TEntity : class
103         {
104             return GetModel<TEntity>().Where(predicate);
105         }
106 
107         public virtual TEntity Find<TEntity>(params object[] keyValues) where TEntity : class
108         {
109             var mapping = DB.Mapping.GetTable(typeof(TEntity));
110             var keys = mapping.RowType.IdentityMembers.Select((m, i) => m.Name + " = @" + i).ToArray();
111             TEntity entityTEntity = DB.GetTable<TEntity>().Where(String.Join(" && ", keys), keyValues).FirstOrDefault();
112             if (entityTEntity != null)
113                 DB.Refresh(System.Data.Linq.RefreshMode.OverwriteCurrentValues, entityTEntity);
114             return entityTEntity;
115         }
116 
117         #endregion
118     }

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

 1 public class User_InfoRepository : XXBBase
 2     {
 3         /// <summary>
 4         /// 需要把Join的表關系寫在這里
 5         /// </summary>
 6         /// <returns></returns>
 7         public IQueryable<User_Info> GetDetailModel()
 8         {
 9             var linq = from data1 in base.GetModel<User_Info>()
10                        join data2 in base.GetModel<User_Profile>() on data1.UserID equals data2.UserID
11                        select data1;
12             return linq;
13         }
14     }

回到目錄

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 LINQ-to-SQL那點事~LINQ-to-SQL中的數據緩存與應對 ObjectContext,DataContext和DBContext 分別獲取linq 的sql方法 EntityFramework DbContext 線程安全 C# Linq-To-SQL DbContext 查詢 DbContext 查詢（二）關於多線程efcore dbcontext 的解決方案。 DbContext 查詢（三）創建DbContext SqlSugar之DbContext