Gestion des transaction sous Oracle

Question

Bonjour à tous,

Je développe une application en C# (forcément) liée à une base Oracle.

Cependant, je n'arrive pas à gérer les transactions sur cette base : exemple, j'insère un enregistrement dans une table et lorsque j'appuie sur le bouton Annuler de ma fenêtre où j'ai codé un Rollback, il ne se passe rien.

Pouvez-vous m'aider ?

Ci-joint ma classe de connection.

Merci d'avance, (ne pas faire attention à la méthode FormaterRequete...) .

using System;
using System.Data;
using System.Data.OracleClient;
using System.Windows.Forms;

namespace DAL
{
    public class CDalOracle
    {
        #region Attributs
        private int               m_iNombreLignes;        // Nombre de lignes du résultat d'une requête
        private int               m_iNombreColonnes;      // Nombre de colonnes du résultat d'une requête
        private OracleConnection  m_oracleConnection;     // Connection à la base de données Oracle
        private OracleCommand     m_oracleCommande;       // Instruction SQL  
        private OracleDataReader  m_oracleDataReader;     // Flux de lignes de données stockant le résultat d'une requête
        private OracleTransaction m_oracleTransaction;    // Gère les transactions Commit & Rollback
        private static string     m_sCHAINE_DE_CONNEXION; // Chaine de connection à la BDD
        #endregion

        public CDalOracle()
        {
            m_iNombreLignes        = 0;
            m_iNombreColonnes      = 0;
            m_oracleConnection     = new OracleConnection();
            m_oracleCommande       = new OracleCommand();
            m_oracleDataReader     = null;            m_sCHAINE_DE_CONNEXION @"Data Source (
                                         DESCRIPTION = (
                                           ADDRESS_LIST = (                                             ADDRESS (PROTOCOL TCP)(HOST = SRV-TOPMAN)(PORT = 1521))
                                           )                                           (CONNECT_DATA                                              (SERVER DEDICATED)(SERVICE_NAME = bdd)
                                           )
                                         );                                       User Id toto; Password toto;";
        }

        public void Commit()
        {
            m_oracleCommande.CommandType = CommandType.Text;
            m_oracleCommande.Transaction = m_oracleTransaction;
            m_oracleTransaction.Commit();
        }

        public void Connection()
        {
            try
            {
                m_oracleConnection.ConnectionString = m_sCHAINE_DE_CONNEXION;
                m_oracleConnection.Open();
            }
            catch (OracleException e)
            {
                MessageBox.Show(e.Message);
            }
        }

        public void Deconnection()
        {
            try
            {
                m_oracleConnection.Close();
            }
            catch (OracleException e)
            {
                MessageBox.Show(e.Message);
            }
        }

        public void DemarrerTransaction()
        {
            try
            {
                m_oracleTransaction          = m_oracleConnection.BeginTransaction();
                m_oracleCommande.CommandType = CommandType.Text;
                m_oracleCommande.Transaction = m_oracleTransaction;
            }
            catch (OracleException e)
            {
                MessageBox.Show(e.Message);
            }
        }

        public bool ExecuteRequete(string sRequete)
        {
            bool bRetour = false;

            try
            {
                m_oracleCommande = new OracleCommand(sRequete, m_oracleConnection);
                m_oracleCommande.ExecuteNonQuery();
                bRetour          = true;
            }
            catch (OracleException e)
            {
                //m_oracleTransaction.Rollback();
                MessageBox.Show(e.Message);
            }
            finally
            {
                m_oracleCommande = null;
            }

            return bRetour;
        }

        public bool ExecuteRequete(string sRequete, params String[] listeParametres)
        {
            bool bRetour = false;

            try
            {
                string sReq = FormaterRequeteAvecParametres(sRequete, listeParametres);

                if (sReq != null)
                {
                    m_oracleCommande = new OracleCommand(sReq, m_oracleConnection);
                    m_oracleCommande.ExecuteNonQuery();
                    bRetour          = true;
                }
                else
                {
                    //m_oracleTransaction.Rollback();
                    MessageBox.Show("Erreur lors de l'exécution de la requête.", "Erreur !");
                }
            }
            catch (OracleException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                m_oracleCommande = null;
            }

            return bRetour;
        }

        public string FormaterRequeteAvecParametres(string sRequete, String[] listeParametres)
        {
            string sRetour = null;

            try
            {
                int iIndiceParams = 0;                      // Indice du paramètre courant de listeParametres
                int iNombreParams = listeParametres.Length; // Nombre de paramètres associés à sRequete
                int iLongueur     = 0;                      // Longueur de tous les paramètres de la requête
                int j             = 0;                      // Indice de cReq

                for (int i = 0; i < iNombreParams; i++)
                {
                    iLongueur += listeParametres[i].Length;

                    // Dans le cas d'un paramètre vide, on ajoute 3 caractères pour écrire IS NULL au lieu de = ''
                    if (listeParametres[i] == "")
                        iLongueur += 4;
                }

                int iLongueurNouvelleChaine = iLongueur + sRequete.Length - iNombreParams;  // Longueur de la nouvelle chaine propre
                char[] cReq                 = new char[iLongueurNouvelleChaine];

                // Pour tous les caractères de sRequete
                for (int i = 0; i < sRequete.Length; i++)
                {
                    if (sRequete[i] == '¤') // Si c'est un ¤, on remplace ¤ par le premier paramètre de listeParametres[]
                    {
                        string sParam = listeParametres[iIndiceParams++];

                        if (sRequete[i - 1] != '\'')
                            sParam = sParam.Replace(",", ".");

                        sParam = sParam.Replace("'", " ");

                        if (cReq[0] == 'S' && cReq[1] == 'E' && cReq[2] == 'L')
                        {
                            if (sParam == "")
                            {
                                cReq[j - 3] = 'I';
                                cReq[j - 2] = 'S';
                                cReq[j - 1] = ' ';
                                cReq[j++]   = 'N';
                                cReq[j++]   = 'U';
                                cReq[j++]   = 'L';
                                cReq[j++]   = 'L';
                            }
                            else
                            {
                                for (int k = 0; k < sParam.Length; k++)
                                    cReq[j++] = sParam[k];
                            }
                        }
                        else
                        {
                            for (int k = 0; k < sParam.Length; k++)
                                cReq[j++] = sParam[k];
                        }
                    }
                    else // Sinon on copie normalement le caractère
                    {
                        if (cReq[0] == 'S' && cReq[1] == 'E' && cReq[2] == 'L' && cReq[3] == 'E' && cReq[4] == 'C' && cReq[5] == 'T')
                        {
                            if (j > 3)
                            {
                                if (cReq[j - 4] == 'N' && cReq[j - 3] == 'U' && cReq[j - 2] == 'L' && cReq[j - 1] == 'L')
                                    cReq[j++] = ' ';
                                else
                                    cReq[j++] = sRequete[i];
                            }
                            else
                            {
                                cReq[j++] = sRequete[i];
                            }
                        }
                        else
                        {
                            cReq[j++] = sRequete[i];
                        }
                    }
                }

                sRetour = new string(cReq);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }

            return sRetour;
        }

        public String[,] GetResultatsRequete(string sRequete)
        {
            String[,] sTabResult = null;

            try
            {
                m_oracleCommande   = new OracleCommand(sRequete, m_oracleConnection);
                m_oracleDataReader = m_oracleCommande.ExecuteReader();
                m_iNombreLignes    = 0;
                m_iNombreColonnes  = this.m_oracleDataReader.FieldCount;

                // Initialisation du tableau de retour
                while (m_oracleDataReader.Read())
                    m_iNombreLignes++;

                sTabResult = new String[m_iNombreLignes, m_iNombreColonnes];

                m_oracleDataReader.Close();
                m_oracleDataReader = m_oracleCommande.ExecuteReader();

                int i = 0;
                while (m_oracleDataReader.Read())
                {
                    for (int j = 0; j < m_iNombreColonnes; j++)
                        if (m_oracleDataReader.IsDBNull(j) == false)
                            sTabResult[i, j] = m_oracleDataReader.GetOracleValue(j).ToString();
                        else
                            sTabResult[i, j] = ""; // Met "" dans les champs null
                    i++;
                }
            }
            catch (OracleException e)
            {
                MessageBox.Show(e.Message);
                sTabResult = null;
            }
            finally
            {
                m_oracleDataReader.Close();
                m_oracleCommande = null;
                m_oracleDataReader = null;
            }

            return sTabResult;
        }

        public String[,] GetResultatsRequete(string sRequete, params String[] listeParametres)
        {
            String[,] sTabResult = null;

            try
            {
                string sReq        = FormaterRequeteAvecParametres(sRequete, listeParametres);
                m_oracleCommande   = new OracleCommand(sReq, m_oracleConnection);
                m_oracleDataReader = m_oracleCommande.ExecuteReader();
                m_iNombreLignes    = 0;
                m_iNombreColonnes  = this.m_oracleDataReader.FieldCount;

                // Initialisation du tableau de retour
                while (m_oracleDataReader.Read())
                    m_iNombreLignes++;

                sTabResult = new String[m_iNombreLignes, m_iNombreColonnes];

                m_oracleDataReader.Close();
                m_oracleDataReader = m_oracleCommande.ExecuteReader();

                int i = 0;
                while (m_oracleDataReader.Read())
                {
                    for (int j = 0; j < m_iNombreColonnes; j++)
                        if (m_oracleDataReader.IsDBNull(j) == false)
                            sTabResult[i, j] = m_oracleDataReader.GetOracleValue(j).ToString();
                        else
                            sTabResult[i, j] = ""; // Met "" dans les champs null
                    i++;
                }
            }
            catch (OracleException e)
            {
                MessageBox.Show(e.Message);
                sTabResult = null;
            }
            finally
            {
                m_oracleDataReader.Close();
                m_oracleCommande = null;
                m_oracleDataReader = null;
            }

            return sTabResult;
        }

        public void Rollback()
        {
            m_oracleCommande.CommandType = CommandType.Text;
            m_oracleCommande.Transaction = m_oracleTransaction;
            m_oracleTransaction.Rollback();
        }
    }
}

cs_rodcobalt22 · Answer

Tu veux dire quoi par il ne se passe rien.

Ta modification est appliqué ou elle ne l'est pas ?
Par contre, je te conseil de revoir la gestion de tes membres car ils sont réaffecté plusieur fois (et d'après moi pour rien).

Peut être qu'en faisant le ménage tu comprendrais pourquoi cela ne fonctionne pas.

RodCobalt22, vous salue bien ;-)

Utilisateur anonyme · Answer

En fait, lorsque je fais l'ajout et que je regarde tout de suite en base (sans commit préalable), je vois la ligne que je viens d'ajouter.
Mais lorsque j'appuie alors sur le bouton annuler de la fenetre (à partir d'où est codé le rollback) et qu'il s'exécute, je regarde en base et la ligne est toujours présente (même lorsque j'actualise).

cs_coq · Answer

Salut,

De ce que je vois, tu ne lie pas de transaction à la commande, donc tu n'utilises pas de transaction. 

/*
coq
MVP Visual C#
CoqBlog
*/

Utilisateur anonyme · Answer

Comment faire ?

Pourrais-tu me guider ?

Merci d'avance.

cs_rodcobalt22 · Answer

C'est au niveau de ton objet Command. il y a une propriété Transaction qui ne doit pas être renseigné.
Un conseil, refait ce code pour y voir plus clair car tu as des affectations dan tout les coins

RodCobalt22, vous salue bien 
Pensez au TAG résolu ! Ainsi les réponses seront plus facile à trouver et les serial Helper iront plus vite

cs_cedkat · Answer

Bonjour,

Quelqu'un a-t-il résolu le problème de la ransaction en lecture seul sur l'objet command ?

J'ai beau cherché mais je vois partout cmd.Transaction = transaction, or cela ne marche pas.

Merci 

Voici mon code :

public
int ExecuteNonQuery(
string query, 
OracleTransaction transaction)
{
   
try
   {
      
OracleCommand cmd = F_Connexion.CreateCommand(query, F_Connexion);
      
if (transaction != 
null)
         cmd.Transaction = transaction;
      
if (F_Connexion.State != 
ConnectionState.Open)
      {
         F_Connexion.Open();
      }
      
return cmd.ExecuteNonQuery();
}
Merci

Phoenix

cs_cedkat · Answer

Un petit element qui peut avoir son importance, je n'utilise pas une connexion oracle de microsoft mais celle d'ODP.

Phoenix

cs_rodcobalt22 · Answer

RodCobalt22, vous salue bien 
Pensez au TAG résolu ! Ainsi les réponses seront plus facile à trouver et les serial Helper iront plus vite 
 PS : Pardonnez mes fautes d'orthographe (All

Gestion des transaction sous Oracle

8 réponses

Votre réponse

Discussions similaires