source: branches/3.3-HiveMigration/sources/HeuristicLab.Hive/HeuristicLab.Hive.Server.LINQDataAccess/3.3/ContextFactory.cs @ 4120

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
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 {
  /// <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 object locker = new object();
    private static IDictionary<int, HiveDataContext> contexts = new Dictionary<int, HiveDataContext>();
    private static IDictionary<int, TransactionScope> transactions = new Dictionary<int, TransactionScope>();

    private static IContextFactory instance = null;
    public static IContextFactory Instance {
      get {
        if (instance == null)
          instance = new ContextFactory();
        return instance;
      }
    }

    #region IContextManager Members

    public IDisposable GetContext() {
      return GetContext(true);
    }

    public IDisposable GetContext(bool withTransaction) {
      lock (locker) {
        Logger.Debug("opening transaction");
        int threadId = Thread.CurrentThread.ManagedThreadId;

        if (contexts.ContainsKey(threadId)) {
          throw new DataAccessException("Context for this Thread already defined");
        }

        Logger.Debug("creating context");
        DisposableHiveDataContext context = CreateContext();
        context.OnDisposing += new EventHandler(context_OnDisposing);
        contexts.Add(threadId, context);

        if (withTransaction) {
          TransactionScope transaction = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = ApplicationConstants.ISOLATION_LEVEL_SCOPE });
          Logger.Debug("creating  transaction");

          transactions.Add(threadId, 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");
      int threadId = Thread.CurrentThread.ManagedThreadId;

      TransactionScope transaction = transactions[threadId];
      transaction.Dispose();
    }

    public void RemoveContext() {
      lock (locker) {
        Logger.Debug("removing context");
        int threadId = Thread.CurrentThread.ManagedThreadId;

        contexts.Remove(threadId);
        // context gets disposed implicitly, when it is used as IDisposable
      }
    }

    public void RemoveAndCompleteTransaction() {
      lock (locker) {
        Logger.Debug("completing transaction");
        int threadId = Thread.CurrentThread.ManagedThreadId;

        // context does not always have an associated transaction
        if (transactions.ContainsKey(threadId)) {
          transactions[threadId].Complete();
          transactions[threadId].Dispose();
          transactions.Remove(threadId);
        }
      }
    }

    public DataContext CurrentContext {
      get {
        int threadId = Thread.CurrentThread.ManagedThreadId;
        if (contexts.ContainsKey(threadId)) {
          return contexts[threadId];
        } 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;
  }
}