/// <summary>
        /// Requête de type INSERT, UPDATE or DELETE
        /// </summary>
        /// <param name="commandText">Requête texte</param>
        /// <param name="connexion">Connexion courante</param>
        /// <param name="parameters">Liste de paramètres</param>
        /// <param name="checkConcurrency">Concurrence à vérifier oui non</param>
        /// <returns>Nombre de lignes modifiées</returns>
        public static int ExecuteSql(string commandText, DbConnection connexion, List <DbParameter> parameters, bool checkConcurrency)
        {
            int rowCount = 0;

            try
            {
                // Ajout d'un RowCount pour déterminer le nombres de lignes modifiées par la requête
                commandText = commandText + " SELECT @@ROWCOUNT ";

                rowCount = ConnectionHelper.ExecuteScalar <int>(commandText, CommandType.Text, connexion, parameters);

                // check concurreny
                if (checkConcurrency)
                {
                    if (rowCount <= 0)
                    {
                        throw new CustomException(CustomExceptionErrorCode.ConcurrentAccess);
                    }
                }
            }
            catch (SqlException ex)
            {
                int errorNumber = ex.Number;

                // throw custom exception
                SqlServerConnectionHelper.ManageExceptionByErrorNumber(errorNumber, ex);

                // default
                throw;
            }

            return(rowCount);
        }
        /// <summary>
        /// Exécute un procédure avec paramètres
        /// </summary>
        /// <param name="commandText">Nom de la procédure</param>
        /// <param name="connection">Connexion à la base de donnée</param>
        /// <param name="parameters">Liste de paramètres</param>
        /// <returns><see cref="DbDataReader"/> alimenté avec le résultat de la requête</returns>
        public static DbDataReader ExecuteProcWithReader(string commandText, DbConnection connection, List <DbParameter> parameters)
        {
            DbDataReader reader = null;

            using (DbCommand command = ConnectionHelper.CreateCommand(connection, CommandType.StoredProcedure, commandText, parameters))
            {
                try
                {
                    reader = command.ExecuteReader(CommandBehavior.CloseConnection);
                }
                catch (SqlException ex)
                {
                    int errorNumber = ex.Number;

                    // Managing error code sent from procedure with the try catch
                    // If an error occured in the procedure, a message is sent with all the informations
                    // (the error code is at the beginning of the message)
                    if (errorNumber == 50000)
                    {
                        errorNumber = SqlServerConnectionHelper.GetNumberException(ex.Message);
                    }

                    // throw custom exception
                    SqlServerConnectionHelper.ManageExceptionByErrorNumber(errorNumber, ex);

                    // default
                    throw;
                }
            }

            return(reader);
        }
        /// <summary>
        /// Exécute un procédure avec paramètres en vérifiant la concurrence
        /// </summary>
        /// <param name="commandText">Nom de la procédure</param>
        /// <param name="connection">Connexion à la base de donnée</param>
        /// <param name="parameters">Liste de paramètres</param>
        /// <param name="actionReader">Méthode appelée lors de chaque itération sur le datareader</param>
        /// <param name="actionReader2">Méthode appelée lors de chaque itération du second datareader</param>
        public static void ExecuteProcWithReaderWithConcurrency(string commandText, DbConnection connection, List <DbParameter> parameters, Action <IDataReader> actionReader, Action <IDataReader> actionReader2)
        {
            // to check concurrency add parameter
            // stored procedure must contain an output param named @nbModifiedLine
            SqlServerConnectionHelper.AddParamToList(parameters, "@nbModifiedLine", 0, ParameterDirection.Output);

            using (DbCommand command = ConnectionHelper.CreateCommand(connection, CommandType.StoredProcedure, commandText, parameters))
            {
                try
                {
                    using (DbDataReader reader = command.ExecuteReader(CommandBehavior.CloseConnection))
                    {
                        while (reader.Read())
                        {
                            // if we want to get output parameter we need to process and close the datareader.
                            // we pass the treatment on datareader as parameter
                            actionReader(reader);
                        }

                        reader.NextResult();

                        while (reader.Read())
                        {
                            // if we want to get output parameter we need to process and close the datareader.
                            // we pass the treatment on datareader as parameter
                            actionReader2(reader);
                        }
                    }

                    // Get output params AFTER we've processed and CLOSED the SqlDataReadeer
                    int count = (int)command.Parameters["@nbModifiedLine"].Value;

                    if (count <= 0)
                    {
                        throw new CustomException(CustomExceptionErrorCode.ConcurrentAccess);
                    }
                }
                catch (SqlException ex)
                {
                    int errorNumber = ex.Number;

                    // Managing error code sent from procedure with the try catch
                    // If an error occured in the procedure, a message is sent with all the informations
                    // (the error code is at the beginning of the message)
                    if (errorNumber == 50000)
                    {
                        errorNumber = SqlServerConnectionHelper.GetNumberException(ex.Message);
                    }

                    // throw custom exception
                    SqlServerConnectionHelper.ManageExceptionByErrorNumber(errorNumber, ex);

                    // default
                    throw;
                }
            }
        }
        /// <summary>
        /// Ajout d'un paramètre à une liste de paramètres existante
        /// </summary>
        /// <param name="list">Liste de paramètres</param>
        /// <param name="name">Nom du paramètre</param>
        /// <param name="value">Valeur du paramètre</param>
        /// <param name="direction">Sens du paramètre</param>
        /// <returns>La liste avec les paramètres ajoutés</returns>
        public static List <DbParameter> AddParamToList(List <DbParameter> list, string name, object value, ParameterDirection direction)
        {
            // Test if list is initialized
            if (list == null)
            {
                throw new ArgumentNullException("list", TYPEVALUENOTRECOGNIZED);
            }

            // Added parameter
            list.Add(SqlServerConnectionHelper.CreateParam(name, value, direction));

            // Back to list
            return(list);
        }
        /// <summary>
        /// Exécute un procédure avec paramètres
        /// Si <see cref="checkConcurrency"/> est vrai on n'utilise pas la valeur en retour de <see cref="ExecuteNonQuery"/>.
        /// <see cref="RowCount"/> doit être effectué manuellement dans toutes les procédures.
        /// </summary>
        /// <param name="commandText">Nom de la procédure</param>
        /// <param name="connection">Connexion à la base de donnée</param>
        /// <param name="parameters">Liste de paramètres</param>
        /// <param name="checkConcurrency">Concurrence à vérifier oui non</param>
        public static void ExecuteProc(string commandText, DbConnection connection, List <DbParameter> parameters, bool checkConcurrency)
        {
            // to check concurrency add parameter
            // stored procedure must contain an output param named @nbModifiedLine
            if (checkConcurrency)
            {
                SqlServerConnectionHelper.AddParamToList(parameters, "@nbModifiedLine", 0, ParameterDirection.Output);
            }

            using (DbCommand command = ConnectionHelper.CreateCommand(connection, CommandType.StoredProcedure, commandText, parameters))
            {
                try
                {
                    // Command execution :
                    // dont use the return value of ExecuteNonQuery because NOCOUNT could be OFF or ON
                    // manage nb lines manually with @nbModifiedLine
                    command.ExecuteNonQuery();

                    if (checkConcurrency)
                    {
                        // read parameter to check concurreny
                        DbParameter paramCount = parameters.First(p => p.ParameterName == "@nbModifiedLine");
                        int         count      = int.Parse(paramCount.Value.ToString());

                        if (count <= 0)
                        {
                            throw new CustomException(CustomExceptionErrorCode.ConcurrentAccess);
                        }
                    }
                }
                catch (SqlException ex)
                {
                    int errorNumber = ex.Number;

                    // Managing error code sent from procedure with the try catch
                    // If an error occured in the procedure, a message is sent with all the informations
                    // (the error code is at the beginning of the message)
                    if (errorNumber == 50000)
                    {
                        errorNumber = SqlServerConnectionHelper.GetNumberException(ex.Message);
                    }

                    // throw custom exception
                    SqlServerConnectionHelper.ManageExceptionByErrorNumber(errorNumber, ex);

                    // default
                    throw;
                }
            }
        }
        /// <summary>
        /// Requête de type INSERT avec retour de la ligne insérée
        /// </summary>
        /// <param name="commandText">Requête texte</param>
        /// <param name="connexion">Connexion courante</param>
        /// <param name="parameters">Liste de paramètres</param>
        /// <returns>ID de la ligne insérée</returns>
        public static int ExecuteSqlWithIdentity(string commandText, DbConnection connexion, List <DbParameter> parameters)
        {
            int id = 0;

            try
            {
                // Récupération de l'ID qui vient d'être inséré
                commandText = commandText + " SELECT ISNULL(SCOPE_IDENTITY(), 0) ";

                id = (int)ConnectionHelper.ExecuteScalar <decimal>(commandText, CommandType.Text, connexion, parameters);
            }
            catch (SqlException ex)
            {
                int errorNumber = ex.Number;

                // throw custom exception
                SqlServerConnectionHelper.ManageExceptionByErrorNumber(errorNumber, ex);

                // default
                throw;
            }

            return(id);
        }
 /// <summary>
 /// Requête de type INSERT, UPDATE or DELETE avec gestion de la concurrence d'accès
 /// </summary>
 /// <param name="commandText">Requête texte</param>
 /// <param name="connexion">Connexion courante</param>
 /// <param name="parameters">Liste de paramètres</param>
 /// <returns>Nombre de lignes modifiées</returns>
 public static int ExecuteSqlWithConcurrency(string commandText, DbConnection connexion, List <DbParameter> parameters)
 {
     return(SqlServerConnectionHelper.ExecuteSql(commandText, connexion, parameters, true));
 }
 /// <summary>
 /// Exécute un procédure avec paramètres en vérifiant la concurrence
 /// </summary>
 /// <param name="commandText">Nom de la procédure</param>
 /// <param name="connection">Connexion à la base de donnée</param>
 /// <param name="parameters">Liste de paramètres</param>
 public static void ExecuteProcWithConcurrency(string commandText, DbConnection connection, List <DbParameter> parameters)
 {
     SqlServerConnectionHelper.ExecuteProc(commandText, connection, parameters, true);
 }
 /// <summary>
 /// Exécute un procédure sans paramètre
 /// </summary>
 /// <param name="commandText">Nom de la procédure</param>
 /// <param name="connexion">Connexion à la base de donnée</param>
 public static void ExecuteProc(string commandText, DbConnection connexion)
 {
     SqlServerConnectionHelper.ExecuteProc(commandText, connexion, null, false);
 }