C# OracleTransaction.Commit方法代码示例

        /// <summary>
        /// Procédure publique qui va appeler la procédure stockée permettant de mettre à jour une vacation
        /// </summary>
        /// <param name="pHeureDebutVac">Heure de début de la vacation</param>
        /// <param name="pHeureFinVac">Heure de fin de la vacation</param>
        /// <param name="pNumeroVac">Numero de la vacation à mettre à jour</param>
        public void MajVacation(DateTime pHeureDebutVac, DateTime pHeureFinVac, Int16 pNumeroVac)
        {
            String MessageErreur = "";
            try
            {
                UneOracleCommand = new OracleCommand("MDL.pckgestionajoutmodif.modifvacation", CnOracle); //Package.procedure
                UneOracleCommand.CommandType = CommandType.StoredProcedure;
                // Paramètres qui stocke l'ID de l'atelier associé à la vacation, le numero de la vacation ainsi que l'heure de debut et de fin de la vacation
                UneOracleCommand.Parameters.Add("pHeureDebut", OracleDbType.Date, ParameterDirection.Input).Value = pHeureDebutVac;
                UneOracleCommand.Parameters.Add("pHeureFin", OracleDbType.Date, ParameterDirection.Input).Value = pHeureFinVac;
                UneOracleCommand.Parameters.Add("pNumero", OracleDbType.Int16, ParameterDirection.Input).Value = pNumeroVac;
                // début de la transaction Oracle il vaut mieyx gérer les transactions dans l'applicatif que dans la bd dans les procédures stockées.
                UneOracleTransaction = this.CnOracle.BeginTransaction();
                //execution
                UneOracleCommand.ExecuteNonQuery();
                // fin de la transaction. Si on arrive à ce point, c'est qu'aucune exception n'a été levée
                UneOracleTransaction.Commit();
            }
            catch (OracleException Oex)
            {

                MessageErreur = this.GetMessageOracle(Oex.Message);
            }
            catch (Exception)
            {

                MessageErreur ="Erreur de la mise à jour de la vacation";
            }
            finally
            {
                if (MessageErreur.Length > 0)
                {
                    // annulation de la transaction
                    UneOracleTransaction.Rollback();
                    // Déclenchement de l'exception
                    throw new Exception(MessageErreur);
                }
            }
        }

        //******************************************* debut des modif**********************************************************************//
        /// <summary>
        ///  Procédure publique qui va appeler la procédure stockée permettant d'ajouter un nouvel Atelier 
        /// </summary>
        /// <param name="pLibelleAtelier">Libelle de l'atelier</param>
        /// <param name="pNbPlacesMax">Nombre de places Maximum pour participer à un atelier</param>
        public void creerAtelier(String pLibelleAtelier, Int32 pNbPlacesMax, String pLibelleTheme, DateTime pHeureDebVac, DateTime pHeureFinVac)
        {
            String MessageErreur = "";
            try
            {
                UneOracleCommand = new OracleCommand("MDL.pckgestionajoutmodif.ajoutatelier", CnOracle); //Package.procedure
                UneOracleCommand.CommandType = CommandType.StoredProcedure;
                // Paramètres qui stocke le libelle et le nbre de place max d'un atelier
                UneOracleCommand.Parameters.Add("pLibelleAtelier", OracleDbType.Varchar2, ParameterDirection.Input).Value = pLibelleAtelier;
                UneOracleCommand.Parameters.Add("pNbPlacesMax", OracleDbType.Int32, ParameterDirection.Input).Value = pNbPlacesMax;
                UneOracleCommand.Parameters.Add("pLibelleTheme", OracleDbType.Varchar2, ParameterDirection.Input).Value = pLibelleTheme;
                UneOracleCommand.Parameters.Add("pHeureDebutVac", OracleDbType.Date, ParameterDirection.Input).Value = pHeureDebVac;
                UneOracleCommand.Parameters.Add("pHeureFinVac", OracleDbType.Date, ParameterDirection.Input).Value = pHeureFinVac;
                // début de la transaction Oracle il vaut mieyx gérer les transactions dans l'applicatif que dans la bd dans les procédures stockées.
                UneOracleTransaction = this.CnOracle.BeginTransaction();
                //execution
                UneOracleCommand.ExecuteNonQuery();
                // fin de la transaction. Si on arrive à ce point, c'est qu'aucune exception n'a été levée
                UneOracleTransaction.Commit();

            }
            catch (OracleException Oex)
            {
                MessageErreur = this.GetMessageOracle(Oex.Message);
            }
            catch (Exception)
            {

                MessageErreur = "Autre Erreur, les informations n'ont pas été correctement saisies";
            }
            finally
            {
                if (MessageErreur.Length > 0)
                {
                    // annulation de la transaction
                    UneOracleTransaction.Rollback();
                    // Déclenchement de l'exception
                    throw new Exception(MessageErreur);
                }
            }
        }

        /// <summary>
        /// Procédure publique qui va appeler la procédure stockée permettant d'inscrire un nouvel intervenant sans nuité
        /// </summary>
        /// <param name="Cmd">nom de l'objet command concerné par les paramètres</param>
        /// <param name="pNom">nom du participant</param>
        /// <param name="pPrenom">prénom du participant</param>
        /// <param name="pAdresse1">adresse1 du participant</param>
        /// <param name="pAdresse2">adresse2 du participant</param>
        /// <param name="pCp">cp du participant</param>
        /// <param name="pVille">ville du participant</param>
        /// <param name="pTel">téléphone du participant</param>
        /// <param name="pMail">mail du participant</param>
        /// <param name="pIdAtelier"> Id de l'atelier où interviendra l'intervenant</param>
        /// <param name="pIdStatut">statut de l'intervenant pour l'atelier : animateur ou intervenant</param>
        public void InscrireIntervenant(String pNom, String pPrenom, String pAdresse1, String pAdresse2, String pCp, String pVille, String pTel, String pMail, Int16 pIdAtelier, String pIdStatut)
        {
            /// <remarks>
            /// procédure qui va créer :
            /// 1- un enregistrement dans la table participant
            /// 2- un enregistrement dans la table intervenant
            ///  en cas d'erreur Oracle, appel à la méthode GetMessageOracle dont le rôle est d'extraire uniquement le message renvoyé
            /// par une procédure ou un trigger Oracle
            /// </remarks>
            ///
            String MessageErreur = "";
            try
            {
                UneOracleCommand = new OracleCommand("pckparticipant.nouvelintervenant", CnOracle);
                UneOracleCommand.CommandType = CommandType.StoredProcedure;
                // début de la transaction Oracle il vaut mieyx gérer les transactions dans l'applicatif que dans la bd dans les procédures stockées.
                UneOracleTransaction = this.CnOracle.BeginTransaction();
                // on appelle la procédure ParamCommunsNouveauxParticipants pour charger les paramètres communs aux intervenants
                this.ParamCommunsNouveauxParticipants(UneOracleCommand, pNom, pPrenom, pAdresse1, pAdresse2, pCp, pVille, pTel, pMail);
                // on appelle la procédure ParamsCommunsIntervenant pour charger les paramètres communs aux intervenants
                this.ParamsSpecifiquesIntervenant(UneOracleCommand, pIdAtelier, pIdStatut);
                //execution
                UneOracleCommand.ExecuteNonQuery();
                // fin de la transaction. Si on arrive à ce point, c'est qu'aucune exception n'a été levée
                UneOracleTransaction.Commit();
            }
            catch (OracleException Oex)
            {
                MessageErreur = "Erreur Oracle \n" + this.GetMessageOracle(Oex.Message);
            }
            catch (Exception ex)
            {

                MessageErreur = "Autre Erreur, les informations n'ont pas été correctement saisies";
            }
            finally
            {
                if (MessageErreur.Length > 0)
                {
                    // annulation de la transaction
                    UneOracleTransaction.Rollback();
                    // Déclenchement de l'exception
                    throw new Exception(MessageErreur);
                }
            }
        }

        /// <summary>
        /// Procédure publique qui va appeler la procédure stockée permettant de mettre à jour un participant
        /// </summary>
        /// <param name="pIdParticipant">Id du participant à mettre à jour</param>
        /// <param name="pCleWifi">La clé wifi (généré ou null)</param>
        public void MajParticipant(Int32 pIdParticipant,String pCleWifi )
        {
            String MessageErreur = "";
            try
            {
                UneOracleCommand = new OracleCommand("pckparticipant.enregistrearriveparticipant", CnOracle); //Package.procedure
                UneOracleCommand.CommandType = CommandType.StoredProcedure;
                // Paramètres qui stocke l'ID du participant ainsi que la clé wifi de celui-ci
                UneOracleCommand.Parameters.Add("pIdParticipant", OracleDbType.Int32, ParameterDirection.Input).Value = pIdParticipant;
                UneOracleCommand.Parameters.Add("pCleWifi", OracleDbType.Char, ParameterDirection.Input).Value = pCleWifi;
                // début de la transaction Oracle il vaut mieyx gérer les transactions dans l'applicatif que dans la bd dans les procédures stockées.
                UneOracleTransaction = this.CnOracle.BeginTransaction();
                //execution
                UneOracleCommand.ExecuteNonQuery();
                // fin de la transaction. Si on arrive à ce point, c'est qu'aucune exception n'a été levée
                UneOracleTransaction.Commit();
            }
            catch (OracleException Oex)
            {

                MessageErreur = this.GetMessageOracle(Oex.Message);
            }
            catch (Exception)
            {

                MessageErreur = "Erreur de la mise à jour du participant";
            }
            finally
            {
                if (MessageErreur.Length > 0)
                {
                    // annulation de la transaction
                    UneOracleTransaction.Rollback();
                    // Déclenchement de l'exception
                    throw new Exception(MessageErreur);
                }
            }
        }

        /// <summary>
        /// Procédure publique qui va appeler la procédure stockée permettant d'ajouter une nouvelle vacation
        /// </summary>
        /// <param name="pIdAtelier">Id de l'atelier que l'on va associé à la vacation</param>
        /// <param name="pHeureDebut">Heure debut de la vacation</param>
        /// <param name="pHeureFin">Heure fin de la vacation</param>
        public void creerVacation(Int32 pIdAtelier, String pHeureDebut, String pHeureFin)
        {
            /// <remarks>
            ///
            /// </remarks>
            ///
            String MessageErreur = "";
            try
            {
                UneOracleCommand = new OracleCommand("MDL.pckgestionajoutmodif.ajoutvacation", CnOracle); //Package.procedure
                UneOracleCommand.CommandType = CommandType.StoredProcedure;
                // Paramètres qui stocke l'ID de l'atelier associé à la vacation ainsi que l'heure de debut et de fin de la vacation
                UneOracleCommand.Parameters.Add("pIdAtelier", OracleDbType.Int32, ParameterDirection.Input).Value = pIdAtelier;
                UneOracleCommand.Parameters.Add("pHeureDebut", OracleDbType.Varchar2, ParameterDirection.Input).Value = pHeureDebut;
                UneOracleCommand.Parameters.Add("pHeureFin", OracleDbType.Varchar2, ParameterDirection.Input).Value = pHeureFin;
                // début de la transaction Oracle il vaut mieyx gérer les transactions dans l'applicatif que dans la bd dans les procédures stockées.
                UneOracleTransaction = this.CnOracle.BeginTransaction();
                //execution
                UneOracleCommand.ExecuteNonQuery();
                // fin de la transaction. Si on arrive à ce point, c'est qu'aucune exception n'a été levée
                UneOracleTransaction.Commit();

            }
            catch (OracleException Oex)
            {
                MessageErreur = this.GetMessageOracle(Oex.Message);
            }
            catch (Exception)
            {

                MessageErreur = "Autre Erreur, les informations n'ont pas été correctement saisies";
            }
            finally
            {
                if (MessageErreur.Length > 0)
                {
                    // annulation de la transaction
                    UneOracleTransaction.Rollback();
                    // Déclenchement de l'exception
                    throw new Exception(MessageErreur);
                }
            }
        }

        /// <summary>
        /// Execute an OracleCommand (that returns a resultset) against the specified OracleTransaction
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new OracleParameter("@prodid", 24));
        /// </remarks>
        /// <param name="transaction">有效的 OracleTransaction</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">存储过程名称或 PL/SQL</param> 
        /// <param name="commandParameters">params OracleParameter[]</param>
        /// <returns>返回DataSet</returns>
        public static DataSet ExecuteDataset(OracleTransaction transaction, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
        {
            //create a command and prepare it for execution
            OracleCommand cmd = new OracleCommand();
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);

            //create the DataAdapter & DataSet
            OracleDataAdapter da;
            DataSet ds = new DataSet();
            try
            {
                da = new OracleDataAdapter(cmd);
                //fill the DataSet using default values for DataTable names, etc.
                da.Fill(ds);
                if (transaction != null)
                {
                    transaction.Commit();
                }
            }
            catch
            {
                if (transaction != null)
                {
                    // Rollback the transaction
                    transaction.Rollback();
                }
            }

            //return the dataset
            return ds;
        }

        /// <summary>
        /// Create and prepare an OracleCommand, and call ExecuteReader with the appropriate CommandBehavior.
        /// </summary>
        /// <remarks>
        /// If we created and opened the connection, we want the connection to be closed when the DataReader is closed.
        /// 
        /// If the caller provided the connection, we want to leave it to them to manage.
        /// </remarks>
        /// <param name="connection">有效的 OracleConnection, on which to execute this command</param>
        /// <param name="transaction">有效的 OracleTransaction, or 'null'</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">存储过程名称或 PL/SQL</param> 
        /// <param name="commandParameters">an array of OracleParameters to be associated with the command or 'null' if no parameters are required</param>
        /// <param name="connectionOwnership">indicates whether the connection parameter was provided by the caller, or created by OracleProvider</param>
        /// <returns>OracleDataReader containing the results of the command</returns>
        private static OracleDataReader ExecuteReader(OracleConnection connection, OracleTransaction transaction, CommandType commandType, string commandText, OracleParameter[] commandParameters, OracleConnectionOwnership connectionOwnership)
        {
            //create a command and prepare it for execution
            OracleCommand cmd = new OracleCommand();
            PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters);

            //create a reader
            OracleDataReader dr = null;

            try
            {
                // call ExecuteReader with the appropriate CommandBehavior
                if (connectionOwnership == OracleConnectionOwnership.External)
                {
                    dr = cmd.ExecuteReader();
                }
                else
                {
                    dr = cmd.ExecuteReader((CommandBehavior)((int)CommandBehavior.CloseConnection));
                }
                if (transaction != null)
                {
                    transaction.Commit();
                }
                return (OracleDataReader)dr;
            }
            catch
            {
                if (transaction != null)
                {
                    // Rollback the transaction
                    transaction.Rollback();
                }
                throw;
            }
        }

        /// <summary>
        ///返回结果集的第一行第一列
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new OracleParameter("@prodid", 24));
        /// </remarks>
        /// <param name="transaction">有效的 OracleTransaction</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or T-OleDb command</param>
        /// <param name="commandParameters">params OracleParameter[]</param>
        /// <returns>返回结果集的第一行第一列</returns>
        public static object ExecuteScalar(OracleTransaction transaction, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
        {
            //create a command and prepare it for execution
            OracleCommand cmd = new OracleCommand();
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);

            try
            {
                //execute the command & return the results
                object obj = cmd.ExecuteScalar();
                if (transaction != null)
                {
                    transaction.Commit();
                }
                return obj;
            }
            catch
            {
                if (transaction != null)
                {
                    // Rollback the transaction
                    transaction.Rollback();
                }
                return null;
            }

        }

 /// <summary>
 ///执行一个命令，没有返回数据集，只返回影响记录数 
 /// </summary>
 /// <remarks>
 /// e.g.:  
 ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new OracleParameter("@prodid", 24));
 /// </remarks>
 /// <param name="transaction">有效的 OracleTransaction</param>
 /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
 /// <param name="commandText">存储过程名称或 PL/SQL</param>  
 /// <param name="commandParameters">OracleParameter[]</param>
 /// <returns>影响记录数</returns>
 public static int ExecuteNonQuery(OracleTransaction transaction, CommandType commandType, string commandText, params OracleParameter[] commandParameters)
 {
     OracleCommand cmd = new OracleCommand();
     PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
     try
     {
         int returnInt = cmd.ExecuteNonQuery();
         if (transaction != null)
         {
             transaction.Commit();
         }
         return returnInt;
     }
     catch
     {
         if (transaction != null)
         {
             transaction.Rollback();
         }
         return 0;
     }
 }

 /// <summary>
 /// 返回执行响应的行数
 /// </summary>
 /// <param name="trans">command中执行的事物（OracleTransaction）</param>
 /// <param name="cmdType">执行类型（过程/语句）</param>
 /// <param name="cmdText">执行的过程名称/查询语句</param>
 /// <param name="commandParameters">command执行的OracleParameter[]数组</param>
 /// <returns>int 返回command执行响应的行数</returns>
 public static int ExecuteNonQuery(OracleTransaction trans, CommandType cmdType, string cmdText, params OracleParameter[] commandParameters)
 {
     int val = 0;
     OracleCommand cmd = new OracleCommand();
     try
     {
         PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
         val = cmd.ExecuteNonQuery();
         cmd.Parameters.Clear();
         //Close(trans.Connection);
         //Dispose(trans.Connection);
         trans.Commit();
         return val;
     }
     catch
     {
         trans.Rollback();
         return val;
     }
 }

        public string execute_transaction(string[] strSql)
        {
            objConnection = open_connection();
            try
            {
                if (open_con)
                {
                    objTransaction = objConnection.BeginTransaction();

                    Int32 i = 0;
                    string strQuery = "";
                    for (i = 0; i <= strSql.Length - 1; i++)
                    {
                        strQuery = "";
                        strQuery = strSql[i];

                        if (strQuery.Length != 0)
                        {
                            objCommand = new OracleCommand(strQuery, objConnection);
                            objCommand.CommandType = CommandType.Text;
                            try
                            {
                                objCommand.ExecuteNonQuery();
                                err_flag = false;
                            }
                            catch (Exception objError)
                            {
                                ErrorStr = objError.Message;
                                err_flag = true;

                                objTransaction.Rollback();
                                objCommand.Dispose();
                                objConnection.Close();
                                objConnection.Dispose();
                            }
                        }
                    }

                    if (!err_flag)
                    {
                        objTransaction.Commit();
                        objCommand.Dispose();
                        objConnection.Close();
                        objConnection.Dispose();
                    }
                    else
                    {
                        objTransaction.Rollback();
                        objCommand.Dispose();
                        objConnection.Close();
                        objConnection.Dispose();
                    }
                }
                else
                {
                    ErrorStr = "Error : Unable to connect to database.";
                    err_flag = true;
                }
            }
            catch (Exception objError)
            {
                ErrorStr = objError.Message;
                err_flag = true;

                objTransaction.Rollback();
                objCommand.Dispose();
                objConnection.Close();
                objConnection.Dispose();
            }
            finally
            {
                objCommand.Dispose();
                objConnection.Close();
                objConnection.Dispose();
            }
            return ErrorStr;
        }

        public void CommitTransaction(OracleTransaction trans, bool closeConnection)
        {
            trans.Commit();

            if (closeConnection && trans.Connection.State != ConnectionState.Closed)
            {
                trans.Connection.Close();
            }

            trans = null;
        }

        /// <summary>
        /// Procédure publique qui va appeler la procédure stockée permettant d'inscrire un nouvel intervenant sans nuité
        /// </summary>
        /// <param name="Cmd">nom de l'objet command concerné par les paramètres</param>
        /// <param name="pNom">nom du participant</param>
        /// <param name="pPrenom">prénom du participant</param>
        /// <param name="pAdresse1">adresse1 du participant</param>
        /// <param name="pAdresse2">adresse2 du participant</param>
        /// <param name="pCp">cp du participant</param>
        /// <param name="pVille">ville du participant</param>
        /// <param name="pTel">téléphone du participant</param>
        /// <param name="pMail">mail du participant</param>
        /// <param name="pIdQualite">qualité du licencié</param>
        /// <param name="pNumeroLicence">numéro de licence du licencié</param>
        /// <param name="pLesAteliers">collection des ateliers du licencié</param>
        /// <param name="pLesCategories">collection des catégories de l'hotel du licencié</param>
        /// <param name="pLesHotels">collection des hotels du licencié</param>
        /// <param name="pLesNuits">collection des nuits du licencié</param>
        /// <param name="pNumCheque">numéro du cheque du licencié</param>
        /// <param name="pMontantCheque">montant du cheque du licencié</param>
        /// <param name="pLesAccompagnants">collection des accompagnants du licencié</param>
        /// <param name="pInscription">type du paiement du licencié</param>
        public void InscrireLicencie(String pNom, String pPrenom, String pAdresse1, String pAdresse2, String pCp, String pVille, String pTel, String pMail, Int16 pIdQualite, Int64 pNumeroLicence, Collection<Int16> pLesAteliers, Collection<string> pLesCategories, Collection<string> pLesHotels, Collection<Int16> pLesNuits, Int64 pNumCheque, Double pMontantCheque, Collection<Int16> pLesAccompagnants, String pInscription)
        {
            String MessageErreur = "";
            try
            {
                // pckparticipant.nouvelintervenant est une procédure surchargée
                UneOracleCommand = new OracleCommand("pckparticipant.nouveaulicencie", CnOracle);
                UneOracleCommand.CommandType = CommandType.StoredProcedure;
                // début de la transaction Oracle : il vaut mieyx gérer les transactions dans l'applicatif que dans la bd.
                UneOracleTransaction = this.CnOracle.BeginTransaction();
                this.ParamCommunsNouveauxParticipants(UneOracleCommand, pNom, pPrenom, pAdresse1, pAdresse2, pCp, pVille, pTel, pMail);
                this.ParamsSpecifiquesLicencie(UneOracleCommand, pIdQualite, pNumeroLicence, pNumCheque, pMontantCheque, pInscription);
                if (pLesAteliers.Count == 0)
                {
                    pLesAteliers.Add(0);
                }
                // Paramètre qui stocke les ateliers sélectionnées
                OracleParameter pOraLesAteliers = new OracleParameter();
                pOraLesAteliers.ParameterName = "pLesAteliers";
                pOraLesAteliers.OracleDbType = OracleDbType.Int16;
                pOraLesAteliers.CollectionType = OracleCollectionType.PLSQLAssociativeArray;
                pOraLesAteliers.Value = pLesAteliers.ToArray();
                pOraLesAteliers.Size = pLesAteliers.Count;
                UneOracleCommand.Parameters.Add(pOraLesAteliers);
                //On va créer ici les paramètres spécifiques à l'inscription d'un intervenant qui réserve des nuits d'hôtel.
                // Paramètre qui stocke les catégories sélectionnées
                OracleParameter pOraLescategories = new OracleParameter();
                pOraLescategories.ParameterName = "pLesCategories";
                pOraLescategories.OracleDbType = OracleDbType.Char;
                pOraLescategories.CollectionType = OracleCollectionType.PLSQLAssociativeArray;
                pOraLescategories.Value = pLesCategories.ToArray();
                pOraLescategories.Size = pLesCategories.Count;
                UneOracleCommand.Parameters.Add(pOraLescategories);
                // Paramètre qui stocke les hotels sélectionnées
                OracleParameter pOraLesHotels = new OracleParameter();
                pOraLesHotels.ParameterName = "pLesHotels";
                pOraLesHotels.OracleDbType = OracleDbType.Char;
                pOraLesHotels.CollectionType = OracleCollectionType.PLSQLAssociativeArray;
                pOraLesHotels.Value = pLesHotels.ToArray();
                pOraLesHotels.Size = pLesHotels.Count;
                UneOracleCommand.Parameters.Add(pOraLesHotels);
                // Paramètres qui stocke les nuits sélectionnées
                OracleParameter pOraLesNuits = new OracleParameter();
                pOraLesNuits.ParameterName = "pLesNuits";
                pOraLesNuits.OracleDbType = OracleDbType.Int16;
                pOraLesNuits.CollectionType = OracleCollectionType.PLSQLAssociativeArray;
                pOraLesNuits.Value = pLesNuits.ToArray();
                pOraLesNuits.Size = pLesNuits.Count;
                UneOracleCommand.Parameters.Add(pOraLesNuits);
                if (pLesAccompagnants.Count == 0)
                {
                    pLesAccompagnants.Add(0);
                }
                // Paramètres qui stocke les accompagnants sélectionnées
                OracleParameter pOraLesAccompagnants = new OracleParameter();
                pOraLesAccompagnants.ParameterName = "plesaccompagnants";
                pOraLesAccompagnants.OracleDbType = OracleDbType.Int16;
                pOraLesAccompagnants.CollectionType = OracleCollectionType.PLSQLAssociativeArray;
                pOraLesAccompagnants.Value = pLesAccompagnants.ToArray();
                pOraLesAccompagnants.Size = pLesAccompagnants.Count;
                UneOracleCommand.Parameters.Add(pOraLesAccompagnants);
                //execution
                UneOracleCommand.ExecuteNonQuery();
                // fin de la transaction. Si on arrive à ce point, c'est qu'aucune exception n'a été levée
                UneOracleTransaction.Commit();
            }
            catch (OracleException Oex)
            {
                //MessageErreur="Erreur Oracle \n" + this.GetMessageOracle(Oex.Message);
                MessageBox.Show(Oex.Message);
            }
            catch (Exception ex)
            {

                MessageErreur = "Autre Erreur, les informations n'ont pas été correctement saisies";
            }
            finally
            {
//.........这里部分代码省略.........

 /// <summary>
 /// Fonction qui permet d'enregistrer un paiement
 /// </summary>
 /// <param name="pMontantCheque">Numero du cheque du licencie</param>
 /// <param name="pNumeroCheque">Numero du cheque du licencie</param>
 /// <param name="pNumeroLicencie">Numero de licence du licencie</param>
 /// <param name="pTypePaiement">Type de paiement du licencie</param>
 public void EnregistrerPaiement(Double pMontantCheque, Int64 pNumeroCheque, Int64 pNumeroLicencie, String pTypePaiement)
 {
     Int64 MonIdLicencie = 0;
     UneOracleCommand = new OracleCommand("Select Idlicencie from licencie where numerolicence =" + pNumeroLicencie, CnOracle);
     OracleDataReader rdr = UneOracleCommand.ExecuteReader();
     while (rdr.Read())
     {
         MonIdLicencie = System.Convert.ToInt64(rdr[0]);
     }
     UneOracleCommand = new OracleCommand("pckparticipant.ENREGISTREPAIEMENT", CnOracle);
     UneOracleCommand.CommandType = CommandType.StoredProcedure;
     // début de la transaction Oracle : il vaut mieyx gérer les transactions dans l'applicatif que dans la bd.
     UneOracleTransaction = this.CnOracle.BeginTransaction();
     this.ParamsSpecifiquePaiement(UneOracleCommand, pMontantCheque, pNumeroCheque, pTypePaiement, MonIdLicencie);
     UneOracleCommand.ExecuteNonQuery();
     // fin de la transaction. Si on arrive à ce point, c'est qu'aucune exception n'a été levée
     UneOracleTransaction.Commit();
 }