En parallèle.Foreach SQL d'interrogation parfois des résultats dans le cadre

J'ai besoin d'accélérer l'exécution de 12 requêtes dans mon application. Je suis passé à partir d'une boucle foreach pour Parallèle.ForEach. Mais parfois, je reçois un message d'erreur indiquant "ExecuteReader nécessite une connexion ouverte et disponible La connexion de l'état actuel de la connexion." C'est ma compréhension que, puisque la plupart des 12 requêtes à l'aide de la même InitialCatalog, il n'est pas vraiment une nouvelle connexion pour les de la 12 et que peut être le problème? Comment puis-je résoudre ce problème? "sql" est une liste de type "Sql"- une classe est juste un nom de chaîne, chaîne de connectiona et une Liste de requêtes. Voici le code:

 ///<summary>
///Connects to SQL, performs all queries and stores results in a list of DataTables
///</summary>
///<returns>List of data tables for each query in the config file</returns>
public List<DataTable> GetAllData()
{
Stopwatch sw = new Stopwatch();
sw.Start();
List<DataTable> data = new List<DataTable>();
List<Sql> sql=new List<Sql>();
Sql one = new Sql();
one.connection = "Data Source=XXX-SQL1;Initial Catalog=XXXDB;Integrated Security=True";
one.name = "Col1";
one.queries.Add("SELECT Name FROM [Reports]");
one.queries.Add("SELECT Other FROM [Reports2]");
sql.Add(one);
Sql two = new Sql();
two.connection = "Data Source=XXX-SQL1;Initial Catalog=XXXDB;Integrated Security=True";
two.name = "Col2";
two.queries.Add("SELECT AlternateName FROM [Reports1]");
sql.Add(two);
Sql three = new Sql();
three.connection = "Data Source=YYY-SQL2;Initial Catalog=YYYDB;Integrated Security=True";
three.name = "Col3";
three.queries.Add("SELECT Frequency FROM Times");
sql.Add(three);
try
{
//ParallelOptions options = new ParallelOptions();
//options.MaxDegreeOfParallelism = 3;
//Parallel.ForEach(sql, options, s =>
Parallel.ForEach(sql, s =>
//foreach (Sql s in sql)
{
foreach (string q in s.queries)
{
using (connection = new SqlConnection(s.connection))
{
connection.Open();
DataTable dt = new DataTable();
dt.TableName = s.name;
command = new SqlCommand(q, connection);
SqlDataAdapter adapter = new SqlDataAdapter();
adapter.SelectCommand = command;
adapter.Fill(dt);
//adapter.Dispose();
lock (data)
{
data.Add(dt);
}
}
}
}
);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "GetAllData error");
}
sw.Stop();
MessageBox.Show(sw.Elapsed.ToString());
return data;
}

Voici le code Sql de la classe j'ai fait ce que vous auriez besoin:

///<summary>
///Class defines a SQL connection and its respective queries
///</summary>
public class Sql
{
///<summary>
///Name of the connection/query
///</summary>
public string name { get; set; }
///<summary>
///SQL Connection string
///</summary>
public string connection { get; set; }
///<summary>
///List of SQL queries for a connection
///</summary>
public List<string> queries = new List<string>();
}

OriginalL'auteur Theodosius Von Richthofen | 2013-04-18

  1. 6

    Je refactoriser votre logique d'entreprise (la connexion à la base de données).

    public class SqlOperation
{
public SqlOperation()
{
Queries = new List<string>();
}
public string TableName { get; set; }
public string ConnectionString { get; set; }
public List<string> Queries { get; set; }
}
public static List<DataTable> GetAllData(IEnumerable<SqlOperation> sql)
{
var taskArray =
sql.SelectMany(s =>
s.Queries
.Select(query =>
Task.Run(() => //Task.Factory.StartNew for .NET 4.0
ExecuteQuery(s.ConnectionString, s.TableName, query))))
.ToArray();
try
{
Task.WaitAll(taskArray);
}
catch(AggregateException e)
{
MessageBox.Show(e.ToString(), "GetAllData error");
}
return taskArray.Where(t => !t.IsFaulted).Select(t => t.Result).ToList();
}
public static DataTable ExecuteQuery(string connectionString, string tableName, string query)
{
DataTable dataTable = null;
using (var connection = new SqlConnection(connectionString))
{
dataTable = new DataTable();
dataTable.TableName = tableName;
using(var command = new SqlCommand(query, connection))
{
connection.Open();
using(var adapter = new SqlDataAdapter())
{
adapter.SelectCommand = command;
adapter.Fill(dataTable);
}
}
}
return dataTable;
}
    Pourquoi êtes-vous à l'aide de Parallel.ForEach pour démarrer un tas de tâches? Vous devriez commencer les tâches en série, ou de laisser Parallel.ForEach poignée de la parallélisation. Dans ce cas, je ne vois aucune raison de ne pas faire le dernier.
    J'essayais juste de remplacer la boucle foreach avec en Parallèle.ForEach. En gros, depuis que certains de ces requêtes prendre un certain temps, je voulais faire plus que 1 de la requête à la fois.
    Ressemble beaucoup, mais produit des erreurs: les erreurs Système.Le filetage.Les tâches.La tâche ne contient pas une définition pour 'Résultat' et aucune méthode d'extension 'Résultat' acceptant un premier argument de type 'System.Le filetage.Les tâches.La tâche pourrait être trouvé Et du Système.Le filetage.Les tâches.Tâche' ne contient pas une définition pour 'Exécuter' . Est-il une référence différente j'ai besoin ot quelque chose?
    Désolé, je n'avais pas beaucoup de temps pour faire une bonne réponse hier, mais je l'ai refait pour vous. Vous avez juste besoin de faire référence à System.Threading.Tasks.
    Utilisation Task.Factory.StartNew à la place.

    OriginalL'auteur Dustin Kingen

  2. 5

    Ado.Net a une jolie clever pool de connexion, donc, en général, vous devez simplement ouvrir les connexions et les relations étroites par commande et à laisser la piscine gérer si elles sont vraiment ouvert ou fermé.

    Donc une connexion par commande: 

      Parallel.ForEach(sql, s=>
//foreach (Sql s in sql)
{
foreach (string q in s.queries)
{
using (connection = new SqlConnection(s.connection))
{
connection.Open();
DataTable dt = new DataTable();
dt.TableName = s.name;
command = new SqlCommand(q, connection);
SqlDataAdapter adapter = new SqlDataAdapter();
adapter.SelectCommand = command;
adapter.Fill(dt);
//adapter.Dispose();
lock(data){
data.Add(dt);
}
}
}
}
    Il a aussi besoin de synchroniser le data.Add(dt); depuis List(T).Add n'est pas thread-safe.
    Hmmmmm...en essayant que (mettre le foreach q dans les requêtes avant de les utiliser entraîne un message d'erreur disant: Impossible d'ouvrir la base de données "xxx" demandée par la connexion. La connexion a échoué. Échec de la connexion de l'utilisateur "xxxxx". Chaque fois.
    Désolé, la connexion doit être ouvert. Voir modifier.
    hein, maintenant, je reçois le ExecuteReader nécessite une Connexion ouverte et disponible. La connexion de l'état actuel de la connexion d'erreur à chaque fois. Pourquoi aurais-je à faire de connexion.Open() lorsque l'original jamais eu besoin de qui? Désolé, je suis nouveau!
    Peut-être parce que le dataadapter poignées d'ouverture de connexions, etc. Si vous préciser un peu plus de code, je vais le faire fonctionner.

    OriginalL'auteur faester

  3. 1

    Vous pouvez également utiliser MultipleActiveResultSets=true; dans la chaîne de connexion à l'appui de plusieurs lecteurs,

    OriginalL'auteur Vinod Kumar Gupta