EFCoreのデータ競合のリカバリ時の動きを一からプロジェクトを作って説明する

## はじめに

EFCoreの競合解決の流れが公式のドキュメントだけだとわかりにくいので、解説してほしいと言われたときのメモです。基本的には公式のドキュメントのコードのまま、実行結果のキャプチャやSQLを追記しました。

https://learn.microsoft.com/ja-jp/ef/core/saving/concurrency?tabs=data-annotations

トランザクション分離レベルに関する内容を追記しました。

## 前準備

確認用のコンソールプロジェクトを作成します。
コマンドのパース用に[ConsoleAppFramework](https://github.com/Cysharp/ConsoleAppFramework)、データベース接続に[Pomelo.EntityFrameworkCore.MySql](https://github.com/PomeloFoundation/Pomelo.EntityFrameworkCore.MySql)、ダミーデータ作成に[Bogus](https://github.com/bchavez/Bogus)をインストールしています。

```sh
❯ dotnet new console -o DbConcurencyExceptionRecoverySample
❯ cd DbConcurencyExceptionRecoverySample
❯ dotnet new tool-manifest
❯ dotnet new gitignore
❯ dotnet add package ConsoleAppFramework
❯ dotnet add package Pomelo.EntityFrameworkCore.MySql --version 8.0.2
❯ dotnet add package Microsoft.EntityFrameworkCore.Design --version 8.0.12
❯ dotnet add package Bogus
❯ dotnet tool install dotnet-ef --version 8.0.12
```

とりあえず`Bogus`を使ってEFCoreでダミーデータをMySQLに登録するサブコマンドと、それを一覧表示するサブコマンドを書きます。サンプルで用意した`Blog`テーブルには競合検知用の`RowVersion`列を追加しています。

```csharp:Program.cs
using System.ComponentModel.DataAnnotations;
using System.Text.Json;
using Bogus;
using ConsoleAppFramework;
using Microsoft.EntityFrameworkCore;

var app = ConsoleApp.Create();

app.Add("drop", async () =>
{
    Console.WriteLine("drop... drop database");
    await using var dbContext = new MyDbContext();
    await dbContext.Database.EnsureDeletedAsync();
});

app.Add("init", async () =>
{
    Console.WriteLine("init... add sample data");
    await using var dbContext = new MyDbContext();
    await dbContext.AddRangeAsync(new Faker<Blog>()
        .RuleFor(p => p.Url, f => f.Internet.Url())
        .Generate(1000));
    await dbContext.SaveChangesAsync();
});

app.Add("show", async () =>
{
    Console.WriteLine("show... show all data");
    await using var dbContext = new MyDbContext();
    foreach (var blog in dbContext.Blogs)
    {
        Console.WriteLine($"BlogId: {blog.BlogId}, Url: {blog.Url}");
    }
});

app.Add("update", async (int id, string url) =>
{
    // 後で実装
});

app.Run(args);

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; } = null!;
    [Timestamp]
    public byte[] RowVersion { get; set; } = null!;
}

public class MyDbContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseMySql("server=localhost;port=3306;database=mydb;uid=root;pwd=root", ServerVersion.Parse("8.0"));
}
```

テスト用のデータベースを起動し、

```sh
❯ docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=password -e MYSQL_PASSWORD=root -e MYSQL_DATABASE=mydb mysql
```

データベースマイグレーションを登録して実行します。

```sh
❯ dotnet ef migrations add FirstMigration
❯ dotnet ef database update
```

データの登録(`init`)と表示(`show`)サブコマンドを実行して中身が入ったことを確認します。

```sh
❯ dotnet run init
init... add sample data

❯ dotnet run show
show... show all data
BlogId: 1, Url: http://forrest.biz
BlogId: 2, Url: http://sarina.org
BlogId: 3, Url: https://dan.com
...
BlogId: 998, Url: http://augustus.biz
BlogId: 999, Url: http://vida.info
BlogId: 1000, Url: http://lindsay.net
```

## 競合を確認する。

`Program.cs`に`update`サブコマンドを作り複数のウインドウで実行します。

```csharp:Program.cs
app.Add("update", async (int id, string url) =>
{
    await using var dbContext = new MyDbContext();
    var blog = (await dbContext.Blogs.FindAsync(id))!;
    Console.WriteLine($"before {JsonSerializer.Serialize(blog)}");
    blog.Url = $"{url}: {DateTimeOffset.Now}";
    Console.WriteLine("Press any key to save changes");
    Console.ReadKey();
    await dbContext.SaveChangesAsync();
    Console.WriteLine($"after {JsonSerializer.Serialize(blog)}");
});
```
左側のウインドウでは更新が成功しましたが、右側のウインドウでは`Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException`が発生して更新が失敗したことを確認できます。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/36535/9a9779b8-1afa-e7ac-bba2-ceb0a7821b0d.png)

これは、`Blog`テーブルが持つ`RowVersion`カラムをもとにEFCoreが同時実行を検知して、更新対象がすでに他のプロセスによって更新された後であることを検知したためです。詳細は下記のマイクロソフトの解説を確認ください。

https://learn.microsoft.com/ja-jp/ef/core/saving/concurrency?tabs=data-annotations

競合を検知した場合どのようにふるまうかは場合によるのですが、例えばとにかく後勝ちにしたいといった場合は、次のようにデータベースの値を再取得した後に現在の値をかぶせて更新を再実行します。

今回の例では、競合検知時にすでにデータが削除されていた（GetDatabaseValuesの結果がnull）場合解決をスキップしていますが、場合によってほかの対処が必要になるかもしれません。

```csharp
app.Add("update", async (int id, string url) =>
{
    await using var dbContext = new MyDbContext();
    var blog = (await dbContext.Blogs.FindAsync(id))!;
    Console.WriteLine($"before {JsonSerializer.Serialize(blog)}");
    blog.Url = $"{url}: {DateTimeOffset.Now}";
    Console.WriteLine("Press any key to save changes");
    Console.ReadKey();
    try
    {
        await dbContext.SaveChangesAsync();
    }
    catch (DbUpdateConcurrencyException ex)
    {
        Console.WriteLine("restore concurrency...");
        // 競合が発生したレコードを列挙する（今回は１件しか入っていないはずだけれど）
        foreach (var entry in ex.Entries)
        {
            var b = entry.Entity as Blog;
            if (b == null) continue;
            
            // 最新の情報を取得
            var target = entry.GetDatabaseValues();
            var current = entry.CurrentValues;
            
            // すでに削除されている場合はスキップ
            if (target == null) continue;

            // 対象が存在した場合は、データベースの値にかぶせて更新
            target[nameof(blog.Url)] = current[nameof(blog.Url)];
            // ほかにもリカバリ対象があれば同じように更新する
            // 例
            // target[nameof(blog.Score)] = current[nameof(blog.Score)];
            // target[nameof(blog.Author)] = current[nameof(blog.Author)];
            
            entry.OriginalValues.SetValues(target);
        }
        // リカバリーしたデータを書き戻す
        await dbContext.SaveChangesAsync();
    }
    Console.WriteLine($"after {JsonSerializer.Serialize(blog)}");
});

```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/36535/f31bf9fd-8593-37b6-3a26-38e20c3d6c07.png)

裏でどのようなSQLが実行されたか確認してみましょう。今回はGenericHostではないのでDbContextに直にLogToオプションを設定後に改めて二つのウインドウで実行します。

```csharp
public class MyDbContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options
            .UseMySql("server=localhost;port=3306;database=mydb;uid=root;pwd=root", ServerVersion.Parse("8.0"))
            .LogTo(Console.WriteLine, Microsoft.Extensions.Logging.LogLevel.Information);
}
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/36535/21b003b4-911f-d796-458f-0769164ec5fb.png)

競合が発生した側のログを見ると、下記の順で解決が行われているのを確認できます。

1. 更新対象の取得
1. 更新（データベースへの反映）
1. （競合の発生）
1. 最新の情報を取得
1. 更新（データベースへの反映）

```
❯ dotnet run update --id 1 --url test2

1. 更新対象の取得
info: 2025/01/15 10:48:01.979 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
      Executed DbCommand (43ms) [Parameters=[@__p_0='?' (DbType = Int32)], CommandType='Text', CommandTimeout='30']
      SELECT `b`.`BlogId`, `b`.`RowVersion`, `b`.`Url`
      FROM `Blogs` AS `b`
      WHERE `b`.`BlogId` = @__p_0
      LIMIT 1
before {"BlogId":1,"Url":"test: 2025/01/15 10:42:29 \u002B09:00","RowVersion":"CN01BeF0q6Y="}
Press any key to save changes
\

2. 更新（データベースへの反映）
info: 2025/01/15 10:48:05.471 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
      Executed DbCommand (2ms) [Parameters=[@p1='?' (DbType = Int32), @p2='?' (DbType = DateTime), @p0='?' (Size = 4000)], CommandType='Text', CommandTimeout='30']
      UPDATE `Blogs` SET `Url` = @p0
      WHERE `BlogId` = @p1 AND `RowVersion` = @p2;
      SELECT `RowVersion`
      FROM `Blogs`
      WHERE ROW_COUNT() = 1 AND `BlogId` = @p1;

3. （競合の発生）
restore concurrency...

4. 最新の情報を取得
info: 2025/01/15 10:48:05.496 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
      Executed DbCommand (1ms) [Parameters=[@__p_0='?' (DbType = Int32)], CommandType='Text', CommandTimeout='30']
      SELECT `b`.`BlogId`, `b`.`RowVersion`, `b`.`Url`
      FROM `Blogs` AS `b`
      WHERE `b`.`BlogId` = @__p_0
      LIMIT 1

5. 更新（データベースへの反映）
info: 2025/01/15 10:48:05.504 RelationalEventId.CommandExecuted[20101] (Microsoft.EntityFrameworkCore.Database.Command)
      Executed DbCommand (1ms) [Parameters=[@p1='?' (DbType = Int32), @p2='?' (DbType = DateTime), @p0='?' (Size = 4000)], CommandType='Text', CommandTimeout='30']
      UPDATE `Blogs` SET `Url` = @p0
      WHERE `BlogId` = @p1 AND `RowVersion` = @p2;
      SELECT `RowVersion`
      FROM `Blogs`
      WHERE ROW_COUNT() = 1 AND `BlogId` = @p1;
      
after {"BlogId":1,"Url":"test2: 2025/01/15 10:48:02 \u002B09:00","RowVersion":"CN01Bqei9bw="}
```

## 読み取り一貫性

MySQLの場合、トランザクション分離レベルのデフォルトが`RepeatableRead`になっている影響で、トランザクション内でこの処理を実行すると別トランザクションで更新したデータを参照できず引き続きDbConcurrencyExceptionが発生します。

```csharp
app.Add("update", async (int id, string url) =>
{
    await using var dbContext = new MyDbContext();
    await using var tsx = await dbContext.Database.BeginTransactionAsync();
    
    var blog = (await dbContext.Blogs.FindAsync(id))!;
    Console.WriteLine($"before {JsonSerializer.Serialize(blog)}");
    blog.Url = $"{url}: {DateTimeOffset.Now}";
    Console.WriteLine("Press any key to save changes");
    Console.ReadKey();
    try
    {
        await dbContext.SaveChangesAsync();
    }
    catch (DbUpdateConcurrencyException ex)
    {
        Console.WriteLine("restore concurrency...");
        foreach (var entry in ex.Entries)
        {
            var b = entry.Entity as Blog;
            
            if (b == null) continue;
            // 競合の解決のためにデータベースから最新の値を取得しようとしているが、
            // トランザクション分離レベルがRepeatableReadであるため、
            // BeginTransaction後に他のトランザクションでコミットされたデータを読み取れない。
            var target = entry.GetDatabaseValues();
            var current = entry.CurrentValues;

            if (target == null) continue;
            target[nameof(blog.Url)] = current[nameof(blog.Url)];
            entry.OriginalValues.SetValues(target);
        }
        await dbContext.SaveChangesAsync();
    }
    await tsx.CommitAsync();
    Console.WriteLine($"after {JsonSerializer.Serialize(blog)}");
});
```

対応としては、トランザクション分離レベルをReadCommitted以下にするか、コネクションをもう一つ作りそちらからリカバリー用データを読むなどが考えられます。

```csharp:トランザクション分離レベルをReadCommittedにして更新する。
    await using var dbContext = new MyDbContext();
    var isolatedLevel = IsolationLevel.ReadCommitted;
    await using var tsx = await dbContext.Database.BeginTransactionAsync(isolatedLevel);
    Console.WriteLine(isolatedLevel);
```

## おわりに

バッチのリカバリはAll or Nothingですべてなかったことにするか、処理したところまでは確定し再実行時は処理済みをスキップなどが楽でよいですが、どうにか自動復旧させたいといった要望も多くあると思います。どうしても抜けが出るのでもう少し楽にならないですかね。。。