Beispiel #1
0
 /// <summary>
 /// Supprime le contexte transactionnel.
 /// </summary>
 internal static void ClearTransactionnalContext()
 {
     if (HttpContext.Current == null)
     {
         _currentContext = null;
     }
     else
     {
         HttpContext.Current.Items.Remove(SqlServerTransactionalContext);
     }
 }
Beispiel #2
0
        /// <summary>
        /// Fournit le context transactionnel courant.
        /// </summary>
        /// <returns>Context transactionnel.</returns>
        private static TransactionalContext ObtainTransactionalContext()
        {
            TransactionalContext context = null;

            if (HttpContext.Current == null)
            {
                return(_currentContext ?? (_currentContext = new TransactionalContext()));
            }

            if (HttpContext.Current.Items.Contains(SqlServerTransactionalContext))
            {
                context = (TransactionalContext)HttpContext.Current.Items[SqlServerTransactionalContext];
            }
            else
            {
                context = new TransactionalContext();
                HttpContext.Current.Items[SqlServerTransactionalContext] = context;
            }

            return(context);
        }
Beispiel #3
0
        /// <summary>
        /// Fournit une connexion base de données.
        /// Si aucune connexion n'est associée au context, une nouvelle connexion
        /// est ouverte.
        /// Une transaction doit être disponible.
        /// La connexion est enregistrée dans ce context et sera automatiquement libérée.
        /// </summary>
        /// <param name="connectionName">Nom de la source de données.</param>
        /// <param name="disableCheckTransCtx">Si <code>True</code> ne vérifie pas la présence d'un contexte transactionnel.</param>
        /// <param name="mustCloseConnection">Indique si la connexion doit être fermée par l'appelant.</param>
        /// <returns>Connexion.</returns>
        internal SqlServerConnection ObtainConnection(string connectionName, bool disableCheckTransCtx, out bool mustCloseConnection)
        {
            SqlServerConnection  connection = null;
            TransactionalContext context    = null;

            mustCloseConnection = false;
            if (!disableCheckTransCtx)
            {
                Transaction currentTransaction = Transaction.Current;
                if (currentTransaction == null)
                {
                    if (HttpContext.Current == null)
                    {
                        mustCloseConnection = true;
                    }
                    else
                    {
                        throw new NotSupportedException("Pas de context transactionnel !");
                    }
                }
                else
                {
                    context    = ObtainTransactionalContext();
                    connection = context.GetConnection(connectionName);
                }
            }
            else
            {
                Transaction currentTransaction = Transaction.Current;
                if (currentTransaction != null)
                {
                    context    = ObtainTransactionalContext();
                    connection = context.GetConnection(connectionName);
                }
                else
                {
                    mustCloseConnection = true;
                }
            }

            if (connection == null)
            {
                ConnectionStringSettings connectionSetting;
                lock (_connectionSettings) {
                    if (!_connectionSettings.TryGetValue(connectionName, out connectionSetting))
                    {
                        connectionSetting = ConfigurationManager.ConnectionStrings[connectionName];
                        if (connectionSetting == null)
                        {
                            throw new SqlServerException("Connection setting not found for '" + connectionName + "' !");
                        }

                        _connectionSettings.Add(connectionName, connectionSetting);
                    }
                }

                DbProviderFactory factory;
                lock (_factories) {
                    if (!_factories.TryGetValue(connectionSetting.ProviderName, out factory))
                    {
                        factory = DbProviderFactories.GetFactory(connectionSetting.ProviderName);
                        _factories.Add(connectionSetting.ProviderName, factory);
                    }
                }

                connection = new SqlServerConnection(factory, connectionSetting.ConnectionString, connectionName);
                if (context != null)
                {
                    context.RegisterConnection(connection);
                }

                connection.Open();
            }

            if (connection.State == ConnectionState.Closed)
            {
                connection.Open();
            }

            return(connection);
        }