实体框架 SaveChanges() 与 SaveChangesAsync() 和 Find() 与 FindAsync()

Question

我一直在寻找上述两对之间的区别，但没有找到任何文章清楚地解释它以及何时使用一对。

那么SaveChanges()和SaveChangesAsync()有什么区别呢？
在Find() 和FindAsync() 之间？

在服务器端，当我们使用Async方法时，我们还需要添加await。因此，我认为它在服务器端不是异步的。

它是否仅有助于防止客户端浏览器上的 UI 阻塞？或者它们之间有什么优缺点？

Answer 1

只要您需要在远程服务器上执行操作，您的程序就会生成请求、发送请求，然后等待响应。我将以SaveChanges() 和SaveChangesAsync() 为例，但同样适用于Find() 和FindAsync()。

假设您有一个列表myList，其中包含需要添加到数据库中的 100 多个项目。要插入它，您的函数将如下所示：

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

首先创建MyEDM 的实例，将列表myList 添加到表MyTable，然后调用SaveChanges() 将更改持久化到数据库。它按照您的意愿工作，记录被提交，但您的程序在提交完成之前不能做任何其他事情。这可能需要很长时间，具体取决于您的承诺。如果您要提交对记录的更改，实体必须一次提交这些更改（我曾经保存需要 2 分钟进行更新）！

要解决此问题，您可以执行以下两项操作之一。首先是您可以启动一个新线程来处理插入。虽然这将释放调用线程以继续执行，但您创建了一个新线程，它将坐在那里等待。不需要这种开销，这就是 async await 模式解决的问题。

对于 I/O 操作，await 很快成为您最好的朋友。取上面的代码部分，我们可以修改为：

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

这是一个非常小的变化，但会对代码的效率和性能产生深远的影响。那么会发生什么？代码的开头是相同的，您创建一个MyEDM 的实例并将您的myList 添加到MyTable。但是当您调用await context.SaveChangesAsync() 时，代码的执行返回到调用函数！ 因此，当您等待所有这些记录提交时，您的代码可以继续执行。假设包含上述代码的函数的签名为public async Task SaveRecords(List<MyTable> saveList)，调用函数可能如下所示：

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");
}

我不知道为什么会有这样的函数，但它的输出显示了async await 的工作原理。首先让我们回顾一下发生了什么。

执行进入MyCallingFunction，Function Starting 然后Save Starting 被写入控制台，然后函数SaveChangesAsync() 被调用。此时，执行返回MyCallingFunction，并进入for循环写入'Continuing to Execute'最多1000次。当SaveChangesAsync() 完成时，执行返回到SaveRecords 函数，将Save Complete 写入控制台。一旦SaveRecords 中的所有内容完成，将在MyCallingFunction 中继续执行，就像SaveChangesAsync() 完成时一样。使困惑？这是一个示例输出：

功能启动 保存开始 继续执行！ 继续执行！ 继续执行！ 继续执行！ 继续执行！ …… 继续执行！ 保存完成！ 继续执行！ 继续执行！ 继续执行！ …… 继续执行！ 功能齐全！

或许：

功能启动 保存开始 继续执行！ 继续执行！ 保存完成！ 继续执行！ 继续执行！ 继续执行！ …… 继续执行！ 功能齐全！

这就是async await 的美妙之处，您的代码可以在等待完成的同时继续运行。实际上，您将有一个更像这样的函数作为您的调用函数：

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());
}

在这里，您有四个不同的保存记录功能同时进行。 MyCallingFunction 使用 async await 将比连续调用单个 SaveRecords 函数快得多。

我还没有提到的一件事是await 关键字。它的作用是停止当前函数的执行，直到您等待的 Task 完成为止。所以对于原始的MyCallingFunction，在SaveRecords 函数完成之前，Function Complete 行不会被写入控制台。

长话短说，如果您可以选择使用async await，您应该这样做，因为它会大大提高您的应用程序的性能。

Answer 2

我剩下的解释将基于以下代码sn-p。

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
    }
}

案例一

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;
}

备注：由于JobAsync 的同步部分（绿色）比任务t（红色）旋转的时间更长，所以t 的任务在await t 处已经完成。结果，延续（蓝色）在与绿色线程相同的线程上运行。 Main（白色）的同步部分将在绿色旋转完成后旋转。这就是为什么异步方法中的同步部分有问题的原因。

案例 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;
}

备注：本例与第一种情况相反。 JobAsync 的同步部分（绿色）比任务 t（红色）旋转的时间短，然后任务 t 在 await t 处尚未完成。结果，延续（蓝色）在与绿色线程不同的线程上运行。 Main（白色）的同步部分在绿色旋转完成后仍然旋转。

案例 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;
}

备注：本案例将解决前面案例中异步方法中同步部分的问题。立即等待任务t。结果，延续（蓝色）在与绿色线程不同的线程上运行。 Main（白色）的同步部分将立即与JobAsync 平行旋转。

如果您想添加其他案例，请随时编辑。

Answer 3

此说法不正确：

在服务器端，当我们使用 Async 方法时，我们还需要添加 await。

您不需要添加“等待”，await 只是 C# 中的一个方便关键字，它使您可以在调用后编写更多行代码，而其他行只有在保存操作完成后才会执行。但正如您所指出的，您只需调用 SaveChanges 而不是 SaveChangesAsync 即可完成此操作。

但从根本上说，异步调用远不止于此。这里的想法是，如果在保存操作正在进行时（在服务器上）还有其他工作，那么您应该使用SaveChangesAsync。不要使用“等待”。只需致电SaveChangesAsync，然后继续并行执行其他操作。这可能包括在 Web 应用程序中，甚至在保存完成之前向客户端返回响应。但当然，您仍然需要检查保存的最终结果，以便在保存失败时，您可以将其传达给您的用户，或以某种方式记录。