TransactionManager.cs

Go to the documentation of this file.

#if !NETFX_CORE && !(ANDROID || IOS)
//-----------------------------------------------------------------------
// <copyright file="TransactionManager.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Provides an automated way to reuse open</summary>
//-----------------------------------------------------------------------
using System;
using Csla.Configuration;
using System.Data;
using Csla.Properties;
 
namespace Csla.Data
{
  [Obsolete("Use dependency injection", false)]
  public class TransactionManager<C, T> : IDisposable, Core.IUseApplicationContext
    where C : IDbConnection, new()
    where T : IDbTransaction
  {
    private static object _lock = new object();
    private C _connection;
    private T _transaction;
    private string _connectionString;
    private string _label;
 
    ApplicationContext Core.IUseApplicationContext.ApplicationContext { get => ApplicationContext; set => ApplicationContext = value; }
    private ApplicationContext ApplicationContext { get; set; }
 
    public TransactionManager<C, T> GetManager(string database)
    {
      return GetManager(database, true);
    }
 
    public TransactionManager<C, T> GetManager(string database, string label)
    {
      return GetManager(database, true, label);
    }
 
    public TransactionManager<C, T> GetManager(string database, bool isDatabaseName)
    {
      return GetManager(database, isDatabaseName, "default");
    }
 
    public TransactionManager<C, T> GetManager(string database, bool isDatabaseName, string label)
    {
      if (isDatabaseName)
      {
#if NETSTANDARD2_0 || NET5_0 || NET6_0
        throw new NotSupportedException("isDatabaseName==true");
#else
        var connection = ConfigurationManager.ConnectionStrings[database];
        if (connection == null)
          throw new System.Configuration.ConfigurationErrorsException(String.Format(Resources.DatabaseNameNotFound, database));
 
        var conn = ConfigurationManager.ConnectionStrings[database].ConnectionString;
        if (string.IsNullOrEmpty(conn))
          throw new System.Configuration.ConfigurationErrorsException(String.Format(Resources.DatabaseNameNotFound, database));
        database = conn;
#endif
      }
 
      lock (_lock)
      {
        var contextLabel = GetContextName(database, label);
        TransactionManager<C, T> mgr = null;
        if (ApplicationContext.LocalContext.Contains(contextLabel))
        {
          mgr = (TransactionManager<C, T>)(ApplicationContext.LocalContext[contextLabel]);
 
        }
        else
        {
          mgr = new TransactionManager<C, T>(database, label);
          ApplicationContext.LocalContext[contextLabel] = mgr;
        }
        mgr.AddRef();
        return mgr;
      }
    }
 
    private TransactionManager(string connectionString, string label)
    {
      _label = label;
      _connectionString = connectionString;
 
      // create and open connection
      _connection = new C();
      _connection.ConnectionString = connectionString;
      _connection.Open();
      //start transaction
      _transaction = (T)_connection.BeginTransaction();
 
    }
 
    private static string GetContextName(string connectionString, string label)
    {
      return "__transaction:" + label + "-" + connectionString;
    }
 
    public T Transaction
    {
      get
      {
        return _transaction;
      }
    }
 
    public C Connection
    {
      get
      {
        return _connection;
      }
    }
 
    private bool _commit = false;
 
    public void Commit()
    {
      if (RefCount == 1)
        _commit = true;
    }
 
#region  Reference counting
 
    private int _refCount;
 
    public int RefCount
    {
      get { return _refCount; }
    }
 
    private void AddRef()
    {
      _refCount += 1;
    }
 
    private void DeRef()
    {
      lock (_lock)
      {
        _refCount -= 1;
        if (_refCount == 0)
        {
          try
          {
            if (_commit)
              _transaction.Commit();
            else
              _transaction.Rollback();
          }
          finally
          {
            _transaction.Dispose();
            _connection.Dispose();
            ApplicationContext.LocalContext.Remove(GetContextName(_connectionString, _label));
          }
        }
      }
 
    }
 
#endregion
 
#region  IDisposable
 
    public void Dispose()
    {
      DeRef();
    }
 
#endregion
  }
}
#endif