Entity Framework SaveChanges() vs SaveChangesAsync() et Find() vs FindAsync()

Tout le temps que vous avez besoin pour faire une action sur un serveur distant, le programme génère la demande, l'envoie, puis attend une réponse. Je vais utiliser SaveChanges() et SaveChangesAsync() comme un exemple, mais le même s'applique à Find() et FindAsync().

Dire que vous avez une liste myList de+ de 100 articles que vous devez ajouter à votre base de données. Pour insérer le, votre fonction ressemblerait à quelque chose comme ceci:

using(var context = new MyEDM())
{
    context.MyTable.AddRange(myList);
    context.SaveChanges();
}

D'abord, vous créez une instance de MyEDM, ajouter la liste myList à la table MyTable, puis d'appeler SaveChanges() pour conserver les modifications apportées à la base de données. Il fonctionne comme vous le souhaitez, les enregistrements s'engager, mais votre programme ne peut rien faire d'autre jusqu'à la validation de finitions. Cela peut prendre un certain temps en fonction de ce que vous livrez. Si vous commettez des modifications aux enregistrements, l'entité doit s'engager à ceux que l'on à la fois (une fois, j'ai eu un enregistrement de prendre 2 minutes pour les mises à jour)!

Pour résoudre ce problème, vous pouvez faire une des deux choses. Le premier est que vous pouvez démarrer un nouveau thread pour gérer l'insertion. Tout cela permettra de libérer le thread appelant à poursuivre l'exécution, vous avez créé un nouveau thread qui va tout simplement s'asseoir et à attendre. Il n'est pas nécessaire pour que les frais généraux, et c'est ce que le async await modèle résout.

Pour les I/O opperations, await devient rapidement votre meilleur ami. La prise de la section de code à partir de ci-dessus, nous pouvons le modifier:

using(var context = new MyEDM())
{
    Console.WriteLine("Save Starting");
    context.MyTable.AddRange(myList);
    await context.SaveChangesAsync();
    Console.WriteLine("Save Complete");
}

C'est un très petit changement, mais il y a de profonds effets sur l'efficacité et les performances de votre code. Donc ce qui se passe? Le début du code est le même, vous créez une instance de MyEDM et ajouter votre myList à MyTable. Mais lorsque vous appelez await context.SaveChangesAsync(), l'exécution de code renvoie à la fonction d'appel! ainsi, Alors que vous êtes en attente pour tous les enregistrements de la commettre, votre code peut continuer à exécuter. Dire la fonction qui contient le code ci-dessus a eu la signature de public async Task SaveRecords(List<MyTable> saveList), la fonction d'appel pourrait ressembler à ceci:

public async Task MyCallingFunction()
{
    Console.WriteLine("Function Starting");
    Task saveTask = SaveRecords(GenerateNewRecords());

    for(int i = 0; i < 1000; i++){
        Console.WriteLine("Continuing to execute!");
    }

    await saveTask;
    Console.Log("Function Complete");
}

Pourquoi vous aurait une fonction de ce genre, je ne sais pas, mais ce qu'il sorties montre comment async await œuvres. D'abord, revenons sur ce qui se passe.

L'exécution saisit MyCallingFunction, Function Starting puis Save Starting est écrit sur la console, alors la fonction SaveChangesAsync() est appelée. À ce stade, l'exécution renvoie à MyCallingFunction et entre dans la boucle de l'écriture de Continuer à Exécuter' jusqu'à 1000 fois. Lorsque SaveChangesAsync() terminée, l'exécution renvoie à la SaveRecordsfonction, écrit Save Complete à la console. Une fois que tout dans SaveRecords terminée, l'exécution se poursuivra en MyCallingFunction droite ou elle était quand SaveChangesAsync() fini. Confus? Voici un exemple de sortie:

Fonction De Départ 
Enregistrer De Départ 
En continuant à exécuter! 
En continuant à exécuter! 
En continuant à exécuter! 
En continuant à exécuter! 
En continuant à exécuter! 
.... 
En continuant à exécuter! 
Enregistrez! 
En continuant à exécuter! 
En continuant à exécuter! 
En continuant à exécuter! 
.... 
En continuant à exécuter! 
Fonction Complète! 

Ou peut-être:

Fonction De Départ 
Enregistrer De Départ 
En continuant à exécuter! 
En continuant à exécuter! 
Enregistrez! 
En continuant à exécuter! 
En continuant à exécuter! 
En continuant à exécuter! 
.... 
En continuant à exécuter! 
Fonction Complète! 

C'est la beauté de async await, votre code peut continuer à s'exécuter pendant que vous êtes en attente de quelque chose à la fin. En réalité, vous avez une fonction plus comme ce que votre appel de la fonction:

public async Task MyCallingFunction()
{
    List<Task> myTasks = new List<Task>();
    myTasks.Add(SaveRecords(GenerateNewRecords()));
    myTasks.Add(SaveRecords2(GenerateNewRecords2()));
    myTasks.Add(SaveRecords3(GenerateNewRecords3()));
    myTasks.Add(SaveRecords4(GenerateNewRecords4()));

    await Task.WhenAll(myTasks.ToArray());
}

Ici, vous avez quatre différents enregistrer l'enregistrement fonctions de passe en même temps. MyCallingFunction va terminer beaucoup plus rapidement en utilisant async await que si la personne SaveRecords fonctions ont été appelés dans la série.

La seule chose que je n'ai pas touché sur encore est le await mot-clé. Ce qu'il fait est d'arrêter la fonction en cours d'exécution jusqu'à ce que Task que vous êtes en attente est terminée. Ainsi, dans le cas de l'original MyCallingFunction, la ligne Function Complete ne sera pas écrit dans la console jusqu'à ce que le SaveRecords fonction se termine.

Longue histoire courte, si vous avez une option pour utiliser async await, vous devriez comme il va augmenter considérablement les performances de votre application.

Mon restant d'explication sera basée sur l'extrait de code suivant.

using System;
using System.Threading;
using System.Threading.Tasks;
using static System.Console;

public static class Program
{
    const int N = 20;
    static readonly object obj = new object();
    static int counter;

    public static void Job(ConsoleColor color, int multiplier = 1)
    {
        for (long i = 0; i < N * multiplier; i++)
        {
            lock (obj)
            {
                counter++;
                ForegroundColor = color;
                Write($"{Thread.CurrentThread.ManagedThreadId}");
                if (counter % N == 0) WriteLine();
                ResetColor();
            }
            Thread.Sleep(N);
        }
    }

    static async Task JobAsync()
    {
       //intentionally removed
    }

    public static async Task Main()
    {
       //intentionally removed
    }
}

Cas 1

static async Task JobAsync()
{
    Task t = Task.Run(() => Job(ConsoleColor.Red, 1));
    Job(ConsoleColor.Green, 2);
    await t;
    Job(ConsoleColor.Blue, 1);
}

public static async Task Main()
{
    Task t = JobAsync();
    Job(ConsoleColor.White, 1);
    await t;
}

Remarques: Comme la partie synchrone (vert) de JobAsync tours de plus que la tâche t (rouge) ensuite, la tâche t est déjà achevé au moment de l' await t. En conséquence, la poursuite (bleu) fonctionne sur le même thread que le vert.
La machine synchrone partie de Main (blanc) va tourner après que le vert est fini de tourner. C'est pourquoi la partie synchrone asynchrone de la méthode est problématique.

Cas 2

static async Task JobAsync()
{
    Task t = Task.Run(() => Job(ConsoleColor.Red, 2));
    Job(ConsoleColor.Green, 1);
    await t;
    Job(ConsoleColor.Blue, 1);
}

public static async Task Main()
{
    Task t = JobAsync();
    Job(ConsoleColor.White, 1);
    await t;
}

Remarques: Cette affaire est à l'opposé de la première affaire. La partie synchrone (vert) de JobAsync rotations plus courtes que la tâche t (rouge) ensuite, la tâche t n'a pas été achevé au moment de l' await t. En conséquence, la poursuite (bleu) s'exécute sur l'autre thread que le vert.
La machine synchrone partie de Main (blanc) encore tours après le vert est fini de tourner.

Cas 3

static async Task JobAsync()
{
    Task t = Task.Run(() => Job(ConsoleColor.Red, 1));
    await t;
    Job(ConsoleColor.Green, 1);
    Job(ConsoleColor.Blue, 1);
}

public static async Task Main()
{
    Task t = JobAsync();
    Job(ConsoleColor.White, 1);
    await t;
}

Remarques: Cette affaire permettra de résoudre le problème dans les cas précédents, à propos de la partie synchrone asynchrone de la méthode. La tâche t est immédiatement attendu. En conséquence, la poursuite (bleu) s'exécute sur l'autre thread que le vert.
La machine synchrone partie de Main (blanc) va tourner immédiatement parallèle à JobAsync.

Si vous souhaitez ajouter d'autres cas, n'hésitez pas à modifier.