Discussion :

[chrozak]

Bonjour a tous, je cherche à faire une identification sur mon programme qui renverrais sur le formulaire correspondant au droit donner a se compte. Pour cela j'ai une BDD access a laquelle mon programme est connecté. Mon soucis étant que je ne sais pas récupérer l'ID du type de compte une fois ma requête SELECT effectuer. J'ai vu que l'on devias utiliser private System.Data.OleDb.OleDbDataReader oDR ou un truc du genre, mais je n'arrive pas a l'adapter a mon programme. J'ai commencer a l'inclure mais sans grand succès. J'aurais beosin d'un petit cou de main .

Voila mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
 
//pour ma connexion  
 
    public class Cl_CAD
    {   
        private string rq_sql;
        private string cnx;
        private System.Data.OleDb.OleDbConnection oCNX;
        private System.Data.OleDb.OleDbCommand oCMD;
        private System.Data.OleDb.OleDbDataAdapter oDA;
        private System.Data.DataSet oDS;
        private System.Data.OleDb.OleDbDataReader oDR;
 
        public Cl_CAD()
        {
                this.rq_sql = null;
                this.cnx = @"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Users\cyprien\Desktop\Stage\BDDlogiciel.accdb";
                this.oCNX = new System.Data.OleDb.OleDbConnection(this.cnx);
                this.oCMD = new System.Data.OleDb.OleDbCommand();
                this.oDA = new System.Data.OleDb.OleDbDataAdapter();
                this.oDR = new System.Data.OleDb.OleDbDataReader();
        }
 
         //methode pour mes requête de selection
 
        public System.Data.DataSet m_GetRows(string rq_sql, string rows_name)
        {
            this.oDS = new System.Data.DataSet();
            this.rq_sql = rq_sql;
            this.oCMD.Connection = this.oCNX;
            this.oCMD.CommandText = this.rq_sql;
            this.oDA.SelectCommand = this.oCMD;
            this.oCNX.Open();
            this.oDA.Fill(this.oDS, rows_name);
            this.oCNX.Close();
            return this.oDS;
        }
 
 
        //requête pour l'identification
        public string identification(string login_compte, string mdp_compte)
        {
            this.rq_sql = @"SELECT ID_type_compte FROM Comptes WHERE login_compte = '" + login_compte + "' AND mdp_compte = '" + mdp_compte + "';";
            return this.rq_sql;
        }

Je précise que ma classe CL_CAD et ma requête ne sont pas dans le même fichier, ils sont séparés pour plus de "clarté" (C'est surtout qu'on m'a appris a le faire comme sa a l'école ), mais sa ne devrais pas avoir d'incidence sur la manière de faire. Enfin je ne pense pas.

Aidez moi svp

Cordialement Chrozak.

[lead8209]

Salut,
j'ai codé un petit truc vite fait en essayant de garder qqe nom de variables.

qqe remarques :
Je ne pas pas que ce soit pertinent de mettre ta requete en variable de classe. Utilises les paramètres ! et repère bien ce qui doit être connu par toutes les fonctions (on object connexion) et ce qui ne doit pas (requete) car c'est propre à l'appel d'une fonction.

C'est bien d'avoir séparé la classe base de données et la Form. Tu remarqueras que je l'ai fait apparaitre dans le code suivant.
Il faudrait que tu finisse de créer ta classe base de données Cl_CAD en ajoutant les méthodes :
Connexion à finir.
Deconnexion ~ok
ExecuteQuerry ok à utiliser pour les req select
ExecuteNonQuerry à utiliser pour les req non select
Comme çà tu pourras la mettre dans une dll (:idée) et tu pourras t'en resservir pour d'autres projets.

Petit plus aussi tu peux mettre en place la gestion des transactions ca peut-être utile.

L'idée c'est d'avoir un object base de données sur ta From et de l'interroger en passant des req et des paramètres. Lui te retourne des infos.





Voila si tu as des questions n'hésites pas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
public class Cl_CAD
    {
        private System.Data.OleDb.OleDbCommand oCMD;
 
        public Cl_CAD()
        {
 
 
        }
        public bool Connexion()
        {
            OleDbConnection connexion = new System.Data.OleDb.OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Users\cyprien\Desktop\Stage\BDDlogiciel.accdb");
            connexion.Open();
            this.oCMD = new System.Data.OleDb.OleDbCommand();
 
            return true; 
 
            //toto gérer le cas d'une exception et retourner false; on peut aussi passer en paramètre la chaine de connexion
        }
 public void Deconnexion()
        {
            this.oCMD.Connection.Close();
 
            //toto gérer le cas d'une exception et retourner false; on peut aussi passer en paramètre la chaine de connexion
        }
 
        //methode pour mes requête de selection
        public string m_DerniereErreur = "";
        /// <summary>
        /// Obtient le résultat d'une requete SELECT
        /// </summary>
        /// <param name="pRequete">Requete a exécuter</param>
        /// <param name="pParametres">Paramètres de la requete</param>
        /// <returns>Retourne le résultat de la requete ou null en cas d'erreur. Si null appeller m_DerniereErreur pour connaitre la raison</returns>
        public DataTable ExecuteQuery(string pRequete, params OleDbParameter[] pParametres)
        {
            try
            {
                OleDbCommand oCommand = oCMD.Clone(); //création de la commande
                oCommand.CommandText = pRequete; //passage de la requete
                //passage des parametres
                if (pParametres != null)
                {
                    for (int i = 0; i < pParametres.Length; i++)
                    {
                        oCommand.Parameters.Add(pParametres[i]);
                    }
                }
 
                //transformation du retour en datatable
                OleDbDataAdapter data_adapter = new OleDbDataAdapter(oCommand);
                DataTable data = new DataTable();
                data_adapter.Fill(data);
 
                return data;
            }
            catch (OleDbException ex)
            {
                m_DerniereErreur = ex.Message;
                return null;
            }
        }
 
 
    }
 
    class GUI
    {
        Cl_CAD m_OleDb = new Cl_CAD();
        public GUI()
        {
            if (!m_OleDb.Connexion())
            {
                MessageBox.Show("Erreur de connexion");
            }
        }
 
        //a appeller sur la form derrière le bouton connexion si tu en as un.
        public string identification(string login_compte, string mdp_compte)
        {
            //on va utiliser une requete parametée c'est mieux --> google
            DataTable table = m_OleDb.ExecuteQuery(@"SELECT ID_type_compte FROM Comptes WHERE login_compte = @login AND mdp_compte = @mdp;",
                new OleDbParameter("@login", login_compte),
                new OleDbParameter("@mdp", mdp_compte));
 
            if (table != null)
            {
                if (table.Rows.Count != 0)//correspondance trouvée pour cette combinaison login / mdp
                {
                    return table.Rows[0]["ID_type_compte"].ToString();
                    //attention à ne pas en avoir plusieurs mais tu as dû gérer ça dans le formulaire de création login/mdp ? :)
                }
                else //pas de correspondant d'un type de compte pour cette combinaison login / mdp
                {
                    return table.Rows[0]["ID_type_compte"].ToString();
                }
            }
            else
            {
                //une erreur de syntaxe dans ta requete retourne object null.
                MessageBox("Erreur OleDb " + m_OleDb.m_DerniereErreur);
                return "";
            }
 
 
        }
    }

[chrozak]

Executenonquerry est déjà fais, c'est juste que je ne voyais pas l'utilité de l'afficher. Pour le .dll je dis +1 mais étant donner que je suis étudiant et que je vais pas faire énormément de c# durant mon année, je préfère le refaire de 0 à chaque fois, sa m'aideras a retenir la manière de faire .

La gestion des transaction ?? ^^ tu peux développer ?

Je sais pas si j'ai tout compris sur les requêtes paramétré et leurs paramètre, mais si je met ma requête en variable c'est parce que je l'utilise pour n'importe quelle requête. Et si j'ai bien compris, sa ne marcherais pas si je mettais des paramètre. Jusqu’à maintenant j'ai gérer une bonne trentaine de requête de sélection, d'ajout, de modif et de suppression avec juste cette variable, sa m'arrangerais de garder cette manière de faire ^^. Après je vais essayer de faire juste celle la avec une requête paramètre. Je te tiens au courant.
Merci

edit : une petit screen de l'organisation de mes fichiers
mpg_XXX => la ou sont stockées les requêtes
pcs =>XXX => lien entre mes mpg, les form ou sont récupérées les données (provenant de textbox, par exemple ici mon login et mdp), et ma classe CL_CAD pour la connexion.
Dans ma couche client il y a tous mes form
Et la couche data pour ou il y a ma connexion.
http://hpics.li/4890afa

Avec mon architecture tu devrais voir un peu mieux

[lead8209]

Les transactions sont des verrous. elles te permettent de réserver la base. De plus elles sont super utiles si tu fais plusieurs requêtes d’affilé par exemple :
Tu fais 2 inserts. Le 2ième foire.
Tu peux faire un transaction.Rollback ce qui annule le 1er insert.
Si les deux passent tu fais un commit et tu es sûr que tout est dedans

Les paramètres sont très utiles aussi. Dans ton champ login essayes de mettre ça : --> toto' et exécute ta requete avec et sans utiliser les paramètres Ca permet de pas se soucier des cotes.
Ou même le piratage par injection : --> 'DROP TABLE etc... //


Je sais pas ce que les autres en pensent mais moins tu as de variables de classe moins tu peux générer de bugs. Mais après chacun sa technique.
Je ne vois pas vraiment l'utilité de ta variable string requete soit partagée par toutes tes fonctions. Un jour tu va oublier de la mettre à jour avant d'exécuter ton ExecuteNonQuerry et tu n'auras pas vraiment le résultat attendu. Ou même une autre fonction modifiera ta variable entre l'appel de ta 1ere fonction et de ExecuteNonQuerry.
Petit exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
string req = "";
        private void CallBackBouton()
        {
            //moins sûr
            this.req = "SELECT Blablabla FROM XXX";
            ExecuteNonQuerry2();
 
            //plus sûr plus beau :)
            ExecuteNonQuerry1("SELECT Blablabla FROM XXX");
        }
 
        private void ExecuteNonQuerry1(string pReq)
        {
            m_OleDb.ExecuteQuery(pReq);
 
        }
        private void ExecuteNonQuerry2()
        {
            m_OleDb.ExecuteQuery(req);
        }

[chrozak]

Pour en revenir à problème pour récupérer ID du type de compte, pourrais-tu m'indiquer ou je dois mettre les différentes parties du code que tu as fais, parce que la j'ai un peu du mal a m'y retrouver .
La classe GUI est vraiment une nouvelle classe ou je dois utiliser celle de ma connexion ?

[rosert]

dans ta couches Accès aux données:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
SqlConnection conn;//variables de classe
SqlCommand cmd;//variables de classe
SqlDataAdapter da;//variables de classe
 
public void conncreate()
        {
            conn = new SqlConnection(TaConnexion);
            cmd = new SqlCommand();
            cmd.Connection = conn;
        }
 
public DataSet dsSelectFieldValue(string SelectField, string table, string fieldname, string fieldValue)
        {
            DataSet ds = new DataSet();
            conncreate();
            da = new SqlDataAdapter("Select " + SelectField + "  from " + table + " where " + fieldname + "=@fieldvalue", conn);
            da.SelectCommand.CommandType = CommandType.Text;
            da.SelectCommand.Parameters.AddWithValue("@fieldvalue", fieldValue);
            da.Fill(ds);
            return ds;
        }

et où tu souhaites récupérer la valeur rendue:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
string maValeur = "";
DataSet ds = objDM.dsSelectFieldValue("colARecuperer", "table", "champAComparer", "valeurDeLaComparaison");
                    if (ds.Tables[0].Rows.Count > 0)
                        maValeur= ds.Tables[0].Rows[0][0].ToString().Trim();

tu peux retirer, dans la partie accès au données, fieldName et fieldValue si tu n'as pas à faire de comparaison, retirer l'ajout des paramètres et adapter l'appel de la fonction. voilà, j'ai fais au plus simple, et c'est facilement réutilisable et adaptable si le nombre de champs à comparer varie. N'hésite pas à revenir vers moi au besoin.