[C#] Gérer correctement des retours de SqlDataReader null

Version imprimable

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:

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:

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.

07/08/2006, 11h53
Thomas Lebrun

Essaye de voir avec ca:

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

;)
07/08/2006, 12h13
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

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:

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;            
 
        }

Seconde solution :

Code:

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

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:

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;
        }

07/08/2006, 14h26
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
07/08/2006, 14h52
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
07/08/2006, 15h10
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

Pk tu retourne pas un datatable ?

Je me sert de cette méthode

Code:

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;
		}

Citation:

Envoyé par shwin

Pk tu retourne pas un datatable ?

Je me sert de cette méthode

Code:

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 ?

07/08/2006, 16h16
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
07/08/2006, 16h26
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 !!

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:

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:

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!

07/08/2006, 18h09
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
08/08/2006, 13h49
shwin

si tu est satisfait de la réponse, tu peux mettre résolu ? :resolu:
08/08/2006, 15h36
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.
08/08/2006, 16h03
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:

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
09/08/2006, 17h34
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.