begin process at 2008 08 08 21:47:50
1 223 607 membres
365 nouveaux aujourd'hui
14 230 membres club

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum.
Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

Sujet : Gestion des transaction sous Oracle [ Base de données / Oracle ] (come62)

Gestion des transaction sous Oracle le 06/09/2007 14:11:16

come62
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();
        }
    }
}

Re : Gestion des transaction sous Oracle le 07/09/2007 10:12:40

rodcobalt22
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 ;-)

Re : Gestion des transaction sous Oracle le 07/09/2007 10:16:29

come62
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).

Re : Gestion des transaction sous Oracle le 08/09/2007 23:38:57

coq
(Admin CS)
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
*/

Re : Gestion des transaction sous Oracle le 10/09/2007 10:20:04

come62
Comment faire ?

Pourrais-tu me guider ?

Merci d'avance.

Re : Gestion des transaction sous Oracle le 11/09/2007 12:10:12

rodcobalt22
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

Re : Gestion des transaction sous Oracle le 15/04/2008 08:57:41

cedkat
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 :

publicint 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


Re : Gestion des transaction sous Oracle le 15/04/2008 09:22:54

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

Phoenix


Re : Gestion des transaction sous Oracle le 15/04/2008 09:25:58

rodcobalt22


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


Classé sous : string, creq, oracledatareader, oraclecommande, srequete

Participer à cet échange

Pub



Appels d'offres

CalendriCode

Août 2008
LMMJVSD
    123
45678910
11121314151617
18192021222324
25262728293031

Téléchargements

Logiciels à télécharger sur le même thème :

Boutique

Boutique de goodies CodeS-SourceS