Changeset 4092 for branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Server.LINQDataAccess/3.3/ContextFactory.cs

Timestamp:

07/23/10 14:17:20 (14 years ago)

Author:

cneumuel

Message:

replaced transaction- and context management from Spring-advice by custom context management (see ContextFactory) (#1098)

File:

• branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Server.LINQDataAccess/3.3/ContextFactory.cs (modified) (1 diff)

branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Server.LINQDataAccess/3.3/ContextFactory.cs

@@ -3 +3 @@
 using System.Linq;
 using System.Text;
-using System.Data.Common;
-using System.Data.SqlClient;
+using HeuristicLab.Hive.Server.DataAccess;
+using System.Collections;
+using System.Data.Linq;
+using System.Transactions;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Hive.Contracts;
 using HeuristicLab.Tracing;
+using System.Threading;
+
 
 namespace HeuristicLab.Hive.Server.LINQDataAccess {
-  public class ContextFactory {
-    [ThreadStatic]
-    private static HiveDataContext _hiveDataContext = null;
+  /// <summary>
+  /// This class handles creates one Context for each Thread which asks for one.
+  /// If one Thread calls GetContext several times, it always gets the same Context object.
+  /// A context object is removed from the cache when it is disposed. 
+  /// 
+  /// Every context has a DB-Transaction over its livetime. After using the context object
+  /// it has to be disposed in order to finish the corresponding transaction.
+  /// </summary>
+  class ContextFactory : IContextFactory {
+    private static IDictionary<object, HiveDataContext> contexts = new Dictionary<object, HiveDataContext>();
+    private static IDictionary<object, TransactionScope> transactions = new Dictionary<object, TransactionScope>();
 
-    [ThreadStatic]
-    private static SqlTransaction _currentTransaction = null;
-
-    public static HiveDataContext Context { 
+    private static IContextFactory instance = null;
+    public static IContextFactory Instance {
       get {
-        if (_hiveDataContext == null) {
-          Logger.Debug("Requested new Data Context");
-          _hiveDataContext = new HiveDataContext("Data Source=127.0.0.1;Initial Catalog=HeuristicLab.Hive;Integrated Security=SSPI");
-          _hiveDataContext.CommandTimeout = 240;
-        }
-        return _hiveDataContext;        
-      } 
-      set {        
-        _hiveDataContext = value;
+        if (instance == null)
+          instance = new ContextFactory();
+        return instance;
       }
     }
 
-    public static SqlTransaction CurrentTransaction { 
-      get {
-        return _currentTransaction;
-      } set {
-        _currentTransaction = value;
-      } 
+    #region IContextManager Members
+
+    public IDisposable GetContext() {
+      return GetContext(true);
     }
 
-    public static bool IsContextNull() {
-      return _hiveDataContext == null;
+    public IDisposable GetContext(bool withTransaction) {
+      Logger.Debug("opening transaction");
+      object obj = Thread.CurrentThread;
+
+      if (contexts.ContainsKey(obj)) {
+        throw new DataAccessException("Context for this Thread already defined");
+      }
+
+      Logger.Debug("creating context");
+      DisposableHiveDataContext context = CreateContext();
+      context.OnDisposing += new EventHandler(context_OnDisposing);
+      contexts.Add(obj, context);
+
+      if (withTransaction) {
+        TransactionScope transaction = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = ApplicationConstants.ISOLATION_LEVEL_SCOPE });
+        Logger.Debug("creating  transaction");
+        
+        transactions.Add(obj, transaction);
+      }
+      return context;
     }
+
+    private static DisposableHiveDataContext CreateContext() {
+      return new DisposableHiveDataContext("Data Source=127.0.0.1;Initial Catalog=HeuristicLab.Hive;Integrated Security=SSPI");
+    }
+
+    void context_OnDisposing(object sender, EventArgs e) {
+      RemoveContext();
+      RemoveAndCompleteTransaction();
+    }
+
+    public void RollbackTransaction() {
+      Logger.Debug("rolling back transaction");
+      object obj = Thread.CurrentThread;
+
+      TransactionScope transaction = transactions[obj];
+      transaction.Dispose();
+    }
+
+    public void RemoveContext() {
+      Logger.Debug("removing context");
+      object obj = Thread.CurrentThread;
+
+      contexts.Remove(obj);
+      // context gets disposed implicitly, when it is used as IDisposable
+    }
+
+    public void RemoveAndCompleteTransaction() {
+      Logger.Debug("completing transaction");
+      object obj = Thread.CurrentThread;
+
+      // context does not always have an associated transaction
+      if (transactions.ContainsKey(obj)) {
+        transactions[obj].Complete();
+        transactions[obj].Dispose();
+        transactions.Remove(obj);
+      }
+    }
+
+    public DataContext CurrentContext {
+      get {
+        object obj = Thread.CurrentThread;
+        if (contexts.ContainsKey(obj)) {
+          return contexts[obj];
+        } else {
+          return null;
+        }
+      }
+    }
+
+    #endregion
+  }
+
+  /// <summary>
+  /// Offers an event when it gets disposed
+  /// </summary>
+  class DisposableHiveDataContext : HiveDataContext {
+
+    public DisposableHiveDataContext(string connection) : base(connection) { }
+
+    protected override void Dispose(bool disposing) {
+      base.Dispose(disposing);
+      if (OnDisposing != null)
+        OnDisposing(this, new EventArgs());
+    }
+
+    public event EventHandler OnDisposing;
   }
 }