En parallèle ne fonctionne pas avec Entity Framework

Le sous-jacent de connexions de base de données que l'Entité Cadre à l'aide de pas thread-safe. Vous sera besoin de créer un nouveau contexte pour chaque opération sur un autre thread que vous allez effectuer.

Votre préoccupation quant à la façon de paralléliser l'opération est valide, et que de nombreux contextes vont coûter cher à ouvrir et à fermer.

Au lieu de cela, vous pourriez voulez inverser la façon dont votre pensée sur la parallélisation du code. Il semble que vous êtes en boucle sur un certain nombre d'éléments et puis l'appel de procédures stockées en série pour chaque élément.

Si vous le pouvez, créez un nouveau Tâche<TResult> (ou Tâche, si vous n'avez pas besoin d'un résultat) pour chaque procédure puis, dans ce Task<TResult>, d'ouvrir un seul contexte, boucle sur tous les éléments, puis exécutez la procédure stockée. De cette façon, vous avez seulement un certain nombre de contextes égal au nombre de procédures stockées qui vous sont exécutés en parallèle.

Supposons que vous avez un MyDbContext avec les deux procédures stockées, DoSomething1 et DoSomething2, qui prennent une instance d'une classe, MyItem.

La mise en œuvre de la ci-dessus ressemblerait à quelque chose comme:

//You'd probably want to materialize this into an IList<T> to avoid
//warnings about multiple iterations of an IEnumerable<T>.
//You definitely *don't* want this to be an IQueryable<T>
//returned from a context.
IEnumerable<MyItem> items = ...;

//The first stored procedure is called here.
Task t1 = Task.Run(() => { 
    //Create the context.
    using (var ctx = new MyDbContext())
    //Cycle through each item.
    foreach (MyItem item in items)
    {
        //Call the first stored procedure.
        //You'd of course, have to do something with item here.
        ctx.DoSomething1(item);
    }
});

//The second stored procedure is called here.
Task t2 = Task.Run(() => { 
    //Create the context.
    using (var ctx = new MyDbContext())
    //Cycle through each item.
    foreach (MyItem item in items)
    {
        //Call the first stored procedure.
        //You'd of course, have to do something with item here.
        ctx.DoSomething2(item);
    }
});

//Do something when both of the tasks are done.

Si vous ne peut pas exécuter les procédures stockées en parallèle (chacun est dépendant de l'exécuter dans un certain ordre), alors vous pouvez toujours paralléliser les opérations, il est juste un peu plus complexe.

Vous regardez la création des partitions à travers vos articles (à l'aide de la statique Créer méthode sur le outil de Partitionnement de la classe). Cela vous donnera les moyens de le faire IEnumerator<T> implémentations (remarque, c'est pas IEnumerable<T> de sorte que vous ne pouvez pas foreach dessus).

Pour chaque IEnumerator<T> exemple, vous obtenez en retour, vous devez créer un nouveau Task<TResult> (si vous avez besoin d'un résultat), et dans le Task<TResult> corps, vous devez créer le contexte et ensuite parcourir les articles retournés par l' IEnumerator<T>, l'appel de procédures stockées dans l'ordre.

Qui ressemblerait à ceci:

//Get the partitioner.
OrdinalPartitioner<MyItem> partitioner = Partitioner.Create(items);

//Get the partitions.
//You'll have to set the parameter for the number of partitions here.
//See the link for creating custom partitions for more
//creation strategies.
IList<IEnumerator<MyItem>> paritions = partitioner.GetPartitions(
    Environment.ProcessorCount);

//Create a task for each partition.
Task[] tasks = partitions.Select(p => Task.Run(() => { 
        //Create the context.
        using (var ctx = new MyDbContext())
        //Remember, the IEnumerator<T> implementation
        //might implement IDisposable.
        using (p)
        //While there are items in p.
        while (p.MoveNext())
        {
            //Get the current item.
            MyItem current = p.Current;

            //Call the stored procedures.  Process the item
            ctx.DoSomething1(current);
            ctx.DoSomething2(current);
        }
    })).
    //ToArray is needed (or something to materialize the list) to
    //avoid deferred execution.
    ToArray();

C'est ce que j'utilise et fonctionne très bien. Il prend par ailleurs en charge de la manipulation de l'erreur exceptions et dispose d'un mode debug qui rend beaucoup plus facile de suivre les choses vers le bas

public static ConcurrentQueue<Exception> Parallel<T>(this IEnumerable<T> items, Action<T> action, int? parallelCount = null, bool debugMode = false)
{
    var exceptions = new ConcurrentQueue<Exception>();
    if (debugMode)
    {
        foreach (var item in items)
        {
            try
            {
                action(item);
            }
            //Store the exception and continue with the loop.                     
            catch (Exception e)
            {
                exceptions.Enqueue(e);
            }
        }
    }
    else
    {
        var partitions = Partitioner.Create(items).GetPartitions(parallelCount ?? Environment.ProcessorCount).Select(partition => Task.Factory.StartNew(() =>
        {
            while (partition.MoveNext())
            {
                try
                {
                    action(partition.Current);
                }
                //Store the exception and continue with the loop.                     
                catch (Exception e)
                {
                    exceptions.Enqueue(e);
                }
            }
        }));
        Task.WaitAll(partitions.ToArray());
    }
    return exceptions;
}

Vous l'utilisez comme suit où que db est à l'origine DbContext et db.CreateInstance() crée une nouvelle instance à l'aide de la même chaîne de connexion.

        var batch = db.Set<SomeListToIterate>().ToList();
        var exceptions = batch.Parallel((item) =>
        {
            using (var batchDb = db.CreateInstance())
            {
                var batchTime = batchDb.GetDBTime();
                var someData = batchDb.Set<Permission>().Where(x=>x.ID = item.ID).ToList();
                //do stuff to someData
                item.WasMigrated = true; //note that this record is attached to db not batchDb and will only be saved when db.SaveChanges() is called
                batchDb.SaveChanges();        
            }                
        });
        if (exceptions.Count > 0)
        {
            logger.Error("ContactRecordMigration : Content: Error processing one or more records", new AggregateException(exceptions));
            throw new AggregateException(exceptions); //optionally throw an exception
        }
        db.SaveChanges(); //save the item modifications