C# en parallèle de multiples insertions dans la base de données

Modifier

Avec le recul, à l'aide d'un Parallel.ForEach pour paralléliser DB insertions est un peu inutile, car il va consommer un thread pour chaque Connexion. Sans doute, une meilleure parallèle solution serait d'utiliser les versions asynchrones de la System.Data Db Opérations, telles que ExecuteNonQueryAsync , de démarrer les exécutions (simultanément), et ensuite utiliser await Task.WhenAll() attendre la fin - cela permettra d'éviter le Fil généraux de l'appelant, bien que l'ensemble de la Db de rendement ne sera probablement pas tous rapide. Plus ici

Réponse originale à cette question, en Parallèle de multiples Insertions dans la Base de données

Vous pouvez le faire en parallèle à l'aide de TPL, par exemple, plus précisément avec la localInit surcharge de En parallèle.ForEach. Vous aurez presque certainement envie de regarder la limitation de la quantité de parallélisme en peaufinant MaxDegreeOfParalelism afin de ne pas inonder votre base de données:

Parallel.ForEach(dt.Rows,
    //Adjust this for optimum throughput vs minimal impact to your other DB users
    new ParallelOptions { MaxDegreeOfParallelism = 4 },
    () =>
    {
        var con = new SqlConnection();
        var cmd = con.CreateCommand();
        cmd.CommandText = sql_proc;
        cmd.CommandType = CommandType.StoredProcedure;
        con.Open();

        cmd.Parameters.Add(new SqlParameter("@a", SqlDbType.Int));
        //NB : Size sensitive parameters must have size
        cmd.Parameters.Add(new SqlParameter("@b", SqlDbType.VarChar, 100));
        cmd.Parameters.Add(new SqlParameter("@c", SqlDbType.Bit));
        //Prepare won't help with SPROCs but can improve plan caching for adhoc sql
        //cmd.Prepare();
        return new {Conn = con, Cmd = cmd};
    },
    (dr, pls, localInit) =>
    {
        localInit.Cmd.Parameters["@a"] = dr["a"];
        localInit.Cmd.Parameters["@b"] = dr["b"];
        localInit.Cmd.Parameters["@c"] = dr["c"];
        localInit.Cmd.ExecuteNonQuery();
        return localInit;
    },
    (localInit) =>
    {
        localInit.Cmd.Dispose();
        localInit.Conn.Dispose();
    });

Notes:

• Sauf si vous savez vraiment ce que vous faites, en général, nous devrions laisser de TPL à se prononcer sur le degré de parallélisme. Toutefois, en fonction de combien de contention (lire: les serrures de travail de base de données) pour les ressources, en limitant la limite supérieure de tâches simultanées peuvent être nécessaires (essai et erreur peut être utile, par exemple, essayez avec accès simultanés de 4, 8, 16 tâches simultanées etc pour voir qui donne le plus de débit, et de surveiller le verrouillage et la charge du PROCESSEUR sur votre Serveur Sql server.
• De même, en laissant TPL par défaut de l'outil de partionnement est généralement suffisant pour la partition des datarow à travers les tâches.
• Chaque Tâche aura besoin de son propre distinct de Connexion Sql.
• Plutôt que de créer et d'élimination de la commande sur chaque appel, de créer une fois par tâche, puis garder la réutilisation de la même Commande, juste la mise à jour des paramètres à chaque fois.
• Utiliser le LocalInit /Local Enfin lambdas à la tâche de définir et de nettoyage, comme l'Élimination des commandes et des connexions.
• Vous pourriez aussi envisager d'utiliser .Prepare() si vous utilisez Sql ad Hoc ou Sql versions antérieures à 2005
• Je suis en supposant que l'énumération d'un DataTable's lignes est thread-safe. Vous aurez envie de vérifier, bien sûr.

Note De Côté:

10 minutes de 3000 lignes est excessif, même avec une grande table et un seul thread. Qu'est-ce que votre proc? J'ai supposé que le traitement n'est pas trivial, d'où la nécessité pour la procédure stockée, mais si vous êtes juste en faisant de simples insère, comme par @3dd commentaire, SqlBulkCopy donnera des inserts ~ 1M de lignes par minute sur un raisonnablement table étroite.

OriginalL'auteur StuartLC

Vous pouvez utiliser SqlBulkCopy. Voir l'exemple de code ci-dessous. Le WriteToServer méthode, écrit Le datatable à la base de données, à condition qu'ils soient de la même cartographie

using (SqlBulkCopy bulkCopy = new SqlBulkCopy(ConSQL)) {
if (ConSQL.State == ConnectionState.Closed) {
    ConSQL.Open();
}

bulkCopy.ColumnMappings.Add(0, 0);
bulkCopy.ColumnMappings.Add(1, 1);
bulkCopy.ColumnMappings.Add(2, 2);

bulkCopy.DestinationTableName = "dbo.TableName";

bulkCopy.WriteToServer(dataTable);

bulkCopy.Close(); //redundant - since using will dispose the object

}

OriginalL'auteur mayowa ogundele