Discussion :

[Jinroh77]

Bonjour,
Pour executer mes requetes j'utilise une classe crée par mes soins dont voici le code pour une requete de type select

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
 
public SqlDataReader QueryRequete()
        {
            ValidationStrRequete();
            SqlCommand Command = new SqlCommand(this.sRequete, cConnection.cpCurseur);
            OpenConnection();
            try
            {
                return Command.ExecuteReader();
            }
            catch (SqlException ex)
            {
                ViewException(ex);
                return null;
            }
        }

Le problème avec cela est que dans mon code pour mes applis je récupère le SqlDataReader

Code :

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

SqlDataReader drTriplet = cGpe.QueryRequete();

Le problème : Lorsque la requete échoue pour un problème de connection, de string de requete incorrecte etc... j'ai un retour "null" et cela dans mon code ce n'est pas beau à gérer
J'ai ma méthode ViewException qui va m'afficher le message d'erreur mais après cela je n'ai aucun blocage de l'application.
Elle va récupérer le SqlDataReader null et essayer (impossible) de travailler avec.
J'avais bien mis des tests drReader.HasRows après la récupération et avant l'execution de mon code mais je n'avais pas pensé au drReaer != null ....
Et vu le nombre de Reader que je récupère je em demande si c'est vraiment efficace de rajouter le != null ou depuis la méthode QueryRequete() directement de faire un autre retour, ou bloquer le programme, relancer en début de méthode appelante, retourner sur le form ou quelque chose dans le genre.... le plus effice pour l'utilisateur en fait.

Merci pour vos idée.

[Thomas Lebrun]

Essaye de voir avec ca:

http://blog.developpez.com/index.php...&c=1&tb=1&pb=1

[Jinroh77]

Hummmm dans l'idée ça me plait, amis j'ai également besoin de faire une vérification sur l'objet Reader lui même.
Que certaine valeurs soit null, je le gère par la requete elle même qui effectue (par une moulinette) des isnull(Champs,-1) ou isnull(Champs,'NA) en focntion du type (automatique).

Le problème est lorsuqe la requete échoue, ma méthode d'execution de requete va renvoyer null (ce qui est loin d'être une bonne idée mais je ne sais pas quoi mettre d'autre pour le moment). Et au moment de l'assignation je vais avoir mon SqlDataReader Null lui même, et non ses valeurs.
L'idéal serait qu'au lieu de renvoyer null ma méthode d'execution de requete bloque mon programme.

Merci

[rockcoeur]

Salut

Pourquoi ne travailles tu pas avec un DataSet que tu rempli s'il y a des valeurs au retour de la requete, sinon tu l'initialise à null.

En plus c'est relativement simple à utiliser pour faire de l'affichage.

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
 
public DataSet QueryRequete()
        {
            ValidationStrRequete();
            SqlDataReader sqlTemp ;
            DataSet dsTemp = new DataSet ("Table") ;
            SqlCommand Command = new SqlCommand(this.sRequete, cConnection.cpCurseur);
            OpenConnection();
 
             sqlTemp = Command.ExecuteReader();
 
            if(sqlTemp != null)
            {
              DataRow drTemp = dsTemp.Tables[0].NewRow();
              drTemp["champs1"] = drTemp.IsDBNull( drTemp.GetOrdinal( "Champs1" ) ) ?
                  drTemp.GetString( m_oDataReader.GetOrdinal( "Champs1" ) ) : "";
              //tu recommence pour tous les champs qui sont contenus dans drTemp    
            }
            else
              dsTemp = null;
 
           return dsTemp;            
 
        }

[rockcoeur]

Seconde solution :

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
 
public DataSet QueryRequete()
        {
            ValidationStrRequete();
            SqlDataReader sqlTemp ;
            DataSet dsTemp = new DataSet ("Table") ;
            SqlCommand Command = new SqlCommand(this.sRequete, cConnection.cpCurseur);
            OpenConnection();
 
             sqlTemp = Command.ExecuteReader();
 
            if(sqlTemp != null)
            {
              DataRow drTemp = dsTemp.Tables[0].NewRow();
              drTemp["champs1"] = drTemp.IsDBNull( drTemp.GetOrdinal( "Champs1" ) ) ?
                  drTemp.GetString( m_oDataReader.GetOrdinal( "Champs1" ) ) : "";
              //tu recommence pour tous les champs qui sont contenus dans drTemp    
            }
            else
              throw new Exception ("Erreur lors de l'execution de la requete SQL");
 
           return dsTemp;            
 
        }

Dans ce cas tu extploites l'erreur dans la focntion appelante.

Cordialement
Rockcoeur

[Jinroh77]

Je me sert de ces méthodes un peu partout dans mon code, et d'après tout ce que j'avais pu lire, les DataSet étaient plutôt déconseillé par rapport à l'utilisation mémoire etc...
Ensuite à ce que j'ai compris le DataSet ici reviens un peu à une DataTable, pour lesquelles j'ai une méthode qui me les crée, au besoin.
Méthode bien générique qui va s'occuper du nombre de colonnes, de lignes, du nom des colonnes etc...

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
 
public static DataTable GetTableFromDReader(SqlDataReader drReader)
        {
            DataTable dtTable = new DataTable();
 
            int iNbrCol = drReader.FieldCount;
            int iNumCol = 0;
            do
            {
 
                DataColumn Colonne = new DataColumn(drReader.GetName(iNumCol));
                dtTable.Columns.Add(Colonne);
                iNumCol += 1;
            } while (iNumCol < iNbrCol);
 
            int iNumLigne = 0;
            //Crée, Ajoute et Remplit les lignes
            while (drReader.Read())
            {
                DataRow ligne = dtTable.NewRow();
                dtTable.Rows.Add(ligne);
                iNumCol = 0;
                do
                {
                    dtTable.Rows[iNumLigne][iNumCol] = drReader.GetValue(iNumCol);
                    iNumCol += 1;
                } while (iNbrCol > iNumCol);
                iNumLigne += 1;
            }
            return dtTable;
        }

[rockcoeur]

En fait je ne cerne pas tres bien ton probleme, car tu peux detecter ton SqlDataReader a null et faire un affichage en conséquence.

En fait peux tu etre plus precis dans la description de ce que tu souhaites faire lorsque tu as des données dans ta requete et lorsque tu as des erreurs.

Cordialement
Rockcoeur

[Jinroh77]

J'aimerais directement dans ma méthode d'execution de la requete, lorsque le SqlDataReader est null, renvoyé autre chose que le "null" actuel, qui me permettrait de ne pas trop toucher à mon code actuel.
Et ne pas devoir rajouter des
if (drReader != null )
{
go
}
else
pas bien

Merci

[rockcoeur]

OK bah dans ce cas j'ai une solution pour toi mais elle est un peux 'gore'.

Si tu detecte dans ta methode un "SqlDataReader == null" tu relance une requete SQL vers une Table defaut qui contient une ligne genre


colonne 1
defaut

dans ce cas tu n'auras jamais de valeur null dans ton SqlDataReader, mais cela va t'imposer de verifier pour chaque ligne si tu n'as pas la valeur par defaut, et si tu l'as il va falloir que tu fasse un traitement spécial.

a+ rockcoeur

[shwin]

Pk tu retourne pas un datatable ?

Je me sert de cette méthode

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
 
public DataTable GetDataTableFromCommand(IDbCommand command)
		{
			InitializeCommand(command);
 
			DataTable table = new DataTable();
			try
			{
				DateTime dt1 = DateTime.Now;
 
				Debug.WriteLine(string.Format("Command: {0}", command.CommandText));
				foreach (IDataParameter param in command.Parameters)
					Debug.WriteLine(string.Format(@"         {0}={1}", param.ParameterName, param.Value.ToString()));
 
				SqlDataAdapter adapter = new SqlDataAdapter((SqlCommand)command);
				adapter.Fill(table);
				Debug.WriteLine(string.Format("Call time: {0}", DateTime.Now.Subtract(dt1)));
			}
			catch (SqlException e)
			{
				Trace.WriteLine(e.Message);
				EventLog.WriteEntry(e.Source, e.Message);
				throw;
			}
			finally
			{
				command.Connection.Close();  // Ensure the connection get closed
				SqlConnection.ClearPool((SqlConnection)command.Connection);
			}
 
			return table;
		}

[Jinroh77]

Pk tu retourne pas un datatable ?

Je me sert de cette méthode

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
 
public DataTable GetDataTableFromCommand(IDbCommand command)
		{
			InitializeCommand(command);
 
			DataTable table = new DataTable();
			try
			{
				DateTime dt1 = DateTime.Now;
 
				Debug.WriteLine(string.Format("Command: {0}", command.CommandText));
				foreach (IDataParameter param in command.Parameters)
					Debug.WriteLine(string.Format(@"         {0}={1}", param.ParameterName, param.Value.ToString()));
 
				SqlDataAdapter adapter = new SqlDataAdapter((SqlCommand)command);
				adapter.Fill(table);
				Debug.WriteLine(string.Format("Call time: {0}", DateTime.Now.Subtract(dt1)));
			}
			catch (SqlException e)
			{
				Trace.WriteLine(e.Message);
				EventLog.WriteEntry(e.Source, e.Message);
				throw;
			}
			finally
			{
				command.Connection.Close();  // Ensure the connection get closed
				SqlConnection.ClearPool((SqlConnection)command.Connection);
			}
 
			return table;
		}

Cela impliquerait que pour toutes mes requêtes de SELECT sur la base de donnée, la méthode va créer une DataTable dans laquelle je epux ensuite faire mes lecture tranquillement ?
Quand je demande un select, il ouvre la connection, remplit une DataTable en mémoire et referme la connection.

Ca reprend un peu les principes des DataSets ?

[shwin]

Faut utiliser les datasets quand les datasets sont utiles. S'il y a des dataset et datatable, c'est parce qu'ils y a des différences, je remarque sur sur ce site, beaucoup de personne utilise les datasets inutilement.

Retourne un datatable quand tu as besoin de savoir ce que ta requête te retourne (si plusieur champs). Si par exemple, ta requête te retourne seulement un champ, utilise pas le datatable mais bien la return value du executeScalar

[Jinroh77]

J'étais justement partis dans une utilisations des DataReader pure, c'est pour cela que l'orsque l'on me conseille de partir sur des DataSet je prends un peu de distance.
En voyant ta procédure, je vois bien que ce ne sont pas des DataSet mais la forme semblait s'en rapprocher, à tort apparement.

Dans ce que tu es en train de me dire, qui me plait, il faudrait, à chaque fois que ma requete retourne plusieurs champs, remplir une DataTable directement et faire une lecture dedans, et non faire la lecture sur le DataReader comme je le fais actuellement ?

L'idée me plait, me parait assez logique, mais petite question très naïve, n'y a-t-il pas des problème de gestion de mémoire avec cette Table si elle devient relativement importante ?
Vers ou se situerait ces limites de tailles ?

Merci beaucoup pour ces précisions !!

[shwin]

si tu fait des select avec plusieur millier de lignes, tu va surement avoir des problèmes de performance/mémoire. Mais tes requêtes ne devraient jamais retourner des résultats trop important, si c'est le cas, tu as un problèmes d'interfaces. Car ton interfaces est saturé par le nombre d'informations.

Utiliser des datasets est + lourd que les datatables.

Ce que je me suis fait, c'est une classe DataBaseHelper qui est hérité par mes autres classes
J'ai des méthodes de ce style

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
 
private void InitializeCommand(IDbCommand command)
		{
			if (command.Connection == null)
				command.Connection = Connection;
 
 
			if (command.Connection.State == ConnectionState.Closed)
			{
				try
				{
					command.Connection.Open();
				}
				catch (Exception e)
				{
					Trace.WriteLine(e.Message);
					EventLog.WriteEntry(e.Source, e.Message);
					throw;
				}
			}
		}
 
public object ExecuteScalar(IDbCommand command)
		{
			InitializeCommand(command);
 
			object result = null;
 
			try
			{
				DateTime dt1 = DateTime.Now;
				Debug.WriteLine(string.Format("Command: {0}", command.CommandText));
				foreach (IDataParameter param in command.Parameters)
					Debug.WriteLine(string.Format(@"         {0}={1}", param.ParameterName, param.Value.ToString()));
 
				result = command.ExecuteScalar();
				Debug.WriteLine(string.Format("Call time: {0}", DateTime.Now.Subtract(dt1)));
			}
			catch (SqlException e)
			{
				Trace.WriteLine(e.Message);
				EventLog.WriteEntry(e.Source, e.Message);
				throw;
			}
			finally
			{
				command.Connection.Close();  // Ensure the connection get closed
				SqlConnection.ClearPool((SqlConnection)command.Connection);
			}
			return result;
		}
	}
private SqlConnection _connection;
		public SqlConnection Connection
		{
			get 
			{
				if (_connection == null)
				{
					System.Configuration.Configuration config =  System.Configuration.ConfigurationManager.OpenExeConfiguration(System.Configuration.ConfigurationUserLevel.None);
					_connection = new SqlConnection(config.ConnectionStrings.ConnectionStrings["Host.Properties.Settings.Connection"].ConnectionString);
 
				}
			_connection.Open();
			return _connection;
			}
 
			private set { _connection = value; }
		}

De cette manière, dans ma classe qui a besoin d'interagir avec ma BD, je proc`de de cette facon

Code :

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

1
2
3
4
5
6
7
8
9
 
SqlCommand command = new SqlCommand();
command.Connection = base.Connection;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "pMyStoredProc";
 
command.Parameters.Add("@param", SqlDbType.NVarChar).Value = valeur;
command.Parameters.Add("@param2", SqlDbType.DateTime).Value = valeur2;
DataTable dt = base.GetDataTableFromCommand(command);

Ceci est un simple exemple, la structure va devenir + complexe. Mais c'est une bonne méthode!

[Jinroh77]

Dans l'idée, c'est à peu près ce que j'essaye de faire.
Mais l'idée de récupérer à chaque fois un DataTable est bien bonne, je vais essayer d'adapter ma classe en fonction.

Merci

[shwin]

si tu est satisfait de la réponse, tu peux mettre résolu ?

[Jinroh77]

Je suis en train de vérifier, car meme si je crée ma DataTable directement, si la table est vide il me renvois quand même et je dois faire une gestion de null dans mon code.

[shwin]

une table vide != une table null
dans mon exemple, je créé une table et je la renvoi, elle est pe etre vide mais jamais null

donc

Code :

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

1
2
3
4
5
 
foreach (DataRow row in dt.Rows)
{
DoSomething();
}

Comme ca tu ten fou que la table soit vide ou pas, il ne fera tout simplement pas d'itération si jamais elle est vide

[Jinroh77]

Okiiii, merci pour l'aide !!

Je met ça à résolu et je ré-ouvre en cas de problème d'intégration.

Merci pour toute ton aide.