Discussion :

[bombseb]

Bonjour,

Dans mon appli, je boucle sur le résultat d'une requête, et en fonction de ces résultats je supprime d'autres lignes dans une autre table (voir le code ci dessous).
Le problème est que j'ai ce message d'erreur à la ligne du cmd.Delete() :

System.InvalidOperationException
Un DataReader associé à cette Command est déjà ouvert. Il doit d'abord être fermé.

Je pense que c'est un problème de Using ? Mais je ne vois pas trop comment faire...

Est-ce que quelqu'un a une idée svp ?

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
                using (SqlConnection s = new SqlConnection(connectionString))
                {
                    s.Open();
                    using (SqlCommand cmdSelect = new SqlCommand("SELECT nom_table FROM dbsync", s))
                    {
                        cmdSelect.CommandType = CommandType.Text;
                        using (SqlDataReader sqlDataReader = cmdSelect.ExecuteReader())
                        {
                            while (sqlDataReader.Read())
                            {
                                string nom_table = sqlDataReader.GetString(0);
                                this.Synchro(nom_table);
 
                                using (SqlCommand cmdDelete = new SqlCommand($"DELETE FROM dbsync WHERE nom_table = '{nom_table}'", s))
                                {
                                    cmdDelete.CommandType = CommandType.Text;
                                    cmdDelete.ExecuteNonQuery();
                                }
                            }
                        }
                    }
                }

[jopopmk]

Salut,

plusieurs questions :
- sur quelle ligne intervient l'exception ?
- qu'y a-t-il derrière ta méthode Synchro ?
- si tu fais sauter ta seconde Command (cmdDelete) as-tu toujours la même exception ?

NB : le using est justement là pour faire proprement les choses

[Pol63]

il veut dire sur la connexion que tu as déjà un reader sur la connexion

en effet le reader est un objet qui demande l'exécution et val lire les lignes au fur et à mesure (à chaque tour)
donc tu ne peux pas utiliser la même connexion pour exécuter autre chose

tu pourrais t'en sortir en utilisation une autre connexion simultanément

mais d'une manière générale (sauf rare exception) quand on fait une boucle pour lire des données, puis que pour chaque on fait une requete c'est qu'on a raté un truc
car une base de données c'est ensembliste

genre ça

Code SQL :

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

DELETE FROM dbsync WHERE nom_table IN (SELECT nom_table FROM dbsync)

avec des requetes ensemblistes tu va pouvoir faire la même chose en 1000x plus rapide et avec moins de code


en plus là tu créé un nouveau command à chaque tour de boucle
même avec peu de bases on imagine facilement qu'en le créant une seule fois avant la boucle et en utilisant le même à chaque fois c'est mieux (mémoire utilisée etc...)

ajouté à cela que si pour faire 2 requetes il te faut 20 lignes de code c'est pas top, on créé souvent une classe d'encapsulation d'accès aux données

donc faut reprendre quelques cours je pense ^^

[François DORIN]

Bonjour,

donc faut reprendre quelques cours je pense ^^

Code SQL :

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

DELETE FROM dbsync WHERE nom_table IN (SELECT nom_table FROM dbsync)

On voit souvent la paille qui est dans l'oeil de son voisin, mais pas la poutre qui est dans le sien !
Le code SQL que tu proposes peut aisément se simplifier

Code SQL :

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

DELETE FROM dbsync

Bon, en réalité, il y a une subtile différence, c'est dans le cas où nom_table serait NULL.

Pour en revenir au problème initial, de ce que je comprends, la table dbsync est une table qui contient une liste d'enregistrements à traiter. Une fois traité, il faut les supprimer. Cela permet de gérer une liste d'attente.

Le problème ici est que l'on récupère tous les enregistrements pour ensuite les supprimer un à un. Autrement dit, le résultat de la première requête va être influencé par le DELETE de la seconde requête. Du coup, pour s'en tirer il faut :

• ou bien lire tous les enregistrements d'un coup, et ensuite les traiter un à un (il ne peut y avoir qu'un seul SqlReader par connexion, et non pas par SqlCommand comme le mentionne l'erreur);
• ou bien utiliser une seconde connexion (mais il faudra en plus gérer le type de transaction à utiliser).

Pour ma part, vu la situation, je simplifierai ainsi :

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
 
using (SqlConnection s = new SqlConnection(connectionString))
using (SqlCommand cmd = new SqlCommand())
{
   bool ok = true;
   string nom_table;
   s.Open();
   cmdSelect.Connection = s;
 
   while(ok)
   {
      cmd.CommandText = "SELECT TOP(1) nom_table FROM dbsync";
      cmd.Parameters.Clear();
      nom_table = cmd.ExecuteScalar() as string;
 
      if (!String.IsNullOrEmpty(nom_table))
      {
         this.Synchro(nom_table);
         cmd.CommandText = "DELETE FROM dbsync WHERE nom_table = @nomtable";
         cmd.Parameters.AddWithValue("@nomtable", nom_table);
         cmd.ExecuteNonQuery();
      }
      else 
      {
         ok = false;
      }
   }

Ainsi, plus besoin de reader !

A noter : le SELECT auquel j'ai rajouté la clause TOP(1), afin de dire que l'on ne prend qu'un seul enregistrement au lieu de tous.
Du coup, il est possible, dans ce cas particulier, d'utiliser ExecuteScalar.
Tant qu'il y a des enregistrements, on boucle.

[bombseb]

Salut,

Merci à vous de m'avoir répondu...

Le problème ici est que l'on récupère tous les enregistrements pour ensuite les supprimer un à un. Autrement dit, le résultat de la première requête va être influencé par le DELETE de la seconde requête. Du coup, pour s'en tirer il faut :

ou bien lire tous les enregistrements d'un coup, et ensuite les traiter un à un (il ne peut y avoir qu'un seul SqlReader par connexion, et non pas par SqlCommand comme le mentionne l'erreur);
ou bien utiliser une seconde connexion (mais il faudra en plus gérer le type de transaction à utiliser).

Je suis arrivé aux mêmes conclusions. J'ai fini par faire ça en deux étapes :
- Traiter les lignes de mon select
- Puis les supprimer

C'est vrai que ca n'a pas trop de sens de supprimer les lignes d'une table sur laquelle on est en train de travailler...

Petite question subsidiaire : Je suis allé voir dans la MSDN mais j'ai pas trop compris à quoi servait le ExecuteScalar...

[François DORIN]

Petite question subsidiaire : Je suis allé voir dans la MSDN mais j'ai pas trop compris à quoi servait le ExecuteScalar...

Un SqlReader permet d'accéder à toutes les colonnes de tous les enregistrements.
Le ExecuteScalar permet d'accéder à la première colonne du premier enregistrement.