日期：2026年 03月 07日

標籤： Docker Docker-Compose Container Ubuntu Linux MySQL Asp.NET Core Web MVC Quartz.NET

摘要：資料庫分散式架構

第一部分：SAGA 介紹

Step 1：為什麼需要 SAGA - 較高的效能

資料庫架構中，以下是 XA 與 SAGA 兩者的差異

對比之下，若需要 分散式資料庫 + 效能高 + 非金融 + 開發時間充裕 ，那麼 SAGA 很適合考慮引用

Step 2：XA 與 SAGA 應用情境

在應用情境下，若非單式體的小型專案，那麼主流大多是 Saga 模式，解決分布式資料庫存儲問題

Saga = 用補償換取高可用與高擴展
XA = 用鎖與阻塞換取強一致性

Step 3：實現 SAGA 的成本

Saga 模式實現的成本為以下 3 點：

因此對產品系統沒有一定程度的理解，是不容易 設計出正確的 Saga 模型

Step 4：Saga 設計的責任歸屬

Saga 需要深度理解系統業務，而且比 XA 還要求高，因此 SAGA 模式，困難的地方是 複雜度提高(開發時間增加)
以下是 XA 與 Saga 的責任區分

簡言之：

SAGA => 把「資料庫原本做的事」全部拿回來自己做。

開發團隊成員若以下其中一項沒有實現，就會造成嚴重的災難
※極有可能出現代碼都是對的，但常常出現 最終沒有一致性

Step 5：Saga 的 2 種實作方式

Saga 模型的實作方式有 2 種，分別是 Orchestration（中央協調式）、 Choreography(事件驅動式)
本偏代碼範例說明實現的是 Orchestration（中央協調式），以下是 2 者的差異：

簡言之：若是想要系統可維護性高，未來複雜度低、可適用擴展的大型專案，那麼推薦 Orchestration（中央協調式） 開始。

Step 6：Orchestration、Choreography 評估選擇情境

Saga 模型的實作方式有 2 種，分別是 Orchestration（中央協調式）、 Choreography(事件驅動式)
本偏代碼範例說明實現的是 Orchestration（中央協調式），以下是 2 者的差異：

Choreography： 是最佳的解耦合，但難於維護
Orchestration： 是最佳的可維護性，但中心服務會導致系統有高耦合

Step 7：SAGA - 優缺點

SAGA 模式的優點如下，實現 最終一致性：
優點結論：高效能

並遺毒的缺點如下：
缺點結論：高複雜度

Step 8： SAGA - 適合應用情境

SAGA 模式具有 最終一致性、高複雜度 主要特性
因此適合的應用情境如下：

Step 9： SAGA - 不可用情境

SAGA 模式具有 最終一致性、高複雜度 主要特性
因此不適合的應用情境如下：

第二部分：SAGA 範例架構設計 - 準備環境

Step 1：Docker Compose - 下載

將範例代碼下載後，將代碼根目錄的 .sql 與 docker-compose.yml 放進 Ubuntu 的目錄下，如圖：

Step 2：Docker Compos - 安裝Mysql

輸入以下指令，進行安裝

docker-compose up -d

確認 Mysql-Saga 容器(資料庫)有啟動：

Step 3：Docker Compos - 內容說明

此 dokcer-compose.yml 安裝腳本，安裝了以下內容：

version: '3.8'

services:
  mysql-shop:
    image: mysql:8.0
    container_name: mysql-sage
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: Member
    ports:
      - "3016:3306"
    volumes:
      - ./mysql-bank-a-data:/var/lib/mysql
      - ./init-Balance.sql:/docker-entrypoint-initdb.d/init-Balance.sql
      - ./init-Log.sql:/docker-entrypoint-initdb.d/init-Log.sql
      - ./init-Member.sql:/docker-entrypoint-initdb.d/init-Member.sql
    command: --default-authentication-plugin=mysql_native_password
            --innodb_lock_wait_timeout=120
            --max_connections=1000
    networks:
      - saga-network

networks:
  saga-network:
    driver: bridge

Step 4：資料庫結構

預設資料庫有 Member , Log , Balance，工作內容與存在的資料表如下：

有預設資料的表包含 AccountBalance, Member, Product
※用於補償機制的表，都可以實現 SAGA 的核心 : 可重試、冪等性、狀態追蹤
※資料表欄位 Status 為了 Demo 說明才使用 Varchar 顯示，實務上請落實團隊規範(通常是 bool / enum / int 等)

Step 5：範例情境說明 - 主體架構

目前我們環境架構如下，我們是在一家購物平台，用戶購買了一台電視，消費金額，公司將用戶的金流資訊都存於 Balance 資料庫
個人用戶資訊存於 Member 資料庫，於是我們實現了 Log 資料庫，實現 Saga 模式，完成分布式資料庫 ：
購物流程與分布式資料庫工作

架構如圖：

Step 6：主體架構異常點 - 生成 SagaId 前

在新增 SagaId 前，資料庫就異常，那麼就直接無視，因為尚未進入系統

Step 7：主體架構異常點 - 扣款前

新增 SagaId 後(Log)，扣款時異常(Balance)，這時將此筆 SagaId 標記異常， 直接取消，因為沒有真正扣款

Step 8：主體架構異常點 - 新增消費紀錄前

扣款後(Balance)，新增消費紀錄時異常(Member)，因為有真正扣款，因此 需要將後續的，消費紀錄、用戶消費統計補齊

Step 9：主體架構異常點 - 更新標記前

新增消費紀錄後(Member)，更新 SagaId 標記前(Log)，這時的 補償只要將該筆 SagaId 補上”COMPLETED”即可

Step 10：範例專案說明

核心代碼主要有 3 大部分

※代碼中的 DAO、DTO、Repository 實現等，因代碼龐大忽略介紹，只重點說明 Saga 實現方式。

第三部分：SAGA 範例實作 - 主體流程

Step 1：主體代碼 - 控制器

將範例代碼下載後，並起且動專案
進入 HomeController.cs 後，有以下功能

/// <summary>
/// 完整走完
/// </summary>
/// <returns></returns>
[HttpGet]
public async Task<ActionResult> FullSAGA()
{
    var resultData = GetMemberShoppingData();
    await _shoppingCartService.Shoppinng(resultData);
    return Ok("成功! 正常情況下，沒有任何異常的寫入 - SAGA (寫 3 種分散式庫都正常)");
   
}
/// <summary>
/// 第一步執行前中斷 (未執行)
/// </summary>
[HttpGet]
public async Task<ActionResult> Step1SAGA()
{
    var resultData = GetMemberShoppingData();
    await _shoppingCartService.Shoppinng(resultData, Enum.InterruptStepEnum.InterruptStep1);
    return Ok();
}
/// <summary>
/// 第二步執行前中斷 (寫入 Log 結束)
/// </summary>
[HttpGet]
public async Task<ActionResult> Step2SAGA()
{
    var resultData = GetMemberShoppingData();
    await _shoppingCartService.Shoppinng(resultData, Enum.InterruptStepEnum.InterruptStep2);
    return Ok();
}
/// <summary>
/// 第三步執行前中斷 (寫入 Log + 扣款 Balance 表 結束)
/// </summary>
[HttpGet]
public async Task<ActionResult> Step3SAGA()
{
    var resultData = GetMemberShoppingData();
    await _shoppingCartService.Shoppinng(resultData, Enum.InterruptStepEnum.InterruptStep3);
    return Ok();
}
/// <summary>
/// 第四步執行前中斷 (寫入 Log + 扣款 Balance 表 + 本地 Member 表 結束)
/// </summary>
[HttpGet]
public async Task<ActionResult> Step4SAGA()
{
    var resultData = GetMemberShoppingData();
    await _shoppingCartService.Shoppinng(resultData, Enum.InterruptStepEnum.InterruptStep4);
    return Ok();
}
/// <summary>
/// 取得用戶購買資料 - 範例使用，固定同個用戶
/// </summary>
private RequestModel GetMemberShoppingData()
{
    // 假資料 
    return new RequestModel()
    {
        MemberId = 1,
        ProductId = 1001,
        Count = 1
    };
}

Step 2：主體代碼 - 控制器

HomeController.cs 執行後，會觸發 ShoppingCartService.cs ，代碼主要功能內容如下：

public class ShoppingCartService : IShoppingCartService
{
    private readonly IUnitOfWorkFactory _uowFactory;
    private readonly IUnitOfWorkAccessor _uowAccessor;
    private readonly ILogger<ShoppingCartService> _logger;
    private readonly IBalanceRepository _balanceRepository;
    private readonly ILogRepository _logRepository;
    private readonly IMemberRepository _memberRespository;

    public ShoppingCartService(IUnitOfWorkFactory uowFactory,
        IUnitOfWorkAccessor uowAccessor,
        ILogger<ShoppingCartService> logger,
        IBalanceRepository balanceRepository,
        ILogRepository logRepository,
        IMemberRepository memberRespository)
    {
        _uowFactory = uowFactory;
        _uowAccessor = uowAccessor;
        _logger = logger;
        _balanceRepository = balanceRepository;
        _logRepository = logRepository;
        _memberRespository = memberRespository;
    }

    /// <summary>
    /// 購物車 - 正常流程
    /// </summary>
    /// <param name="shoppingData">會員購物資料</param>
    /// <param name="stepEnum">模擬中斷</param>
    /// <returns></returns>
    public async Task Shoppinng(RequestModel shoppingData, InterruptStepEnum stepEnum= InterruptStepEnum.None)
        {
            // 取得資料
            var prdouctInfo = await GetProductInfo(shoppingData.ProductId);
            var memberInfo = await GetMemberInfo(shoppingData.MemberId);

            // 簡易驗證
            if (memberInfo == null || prdouctInfo == null)
                throw new Exception("傳入參數錯誤");

            if (stepEnum == InterruptStepEnum.InterruptStep1)
                throw new Exception("第一步執行前中斷 (未執行)");
            // 1.Log DB：建立交易紀錄(Pending)
            var sagaId = await CreateLog(shoppingData, prdouctInfo);


            if (stepEnum == InterruptStepEnum.InterruptStep2)
                throw new Exception("第二步執行前中斷 (寫入 Log 結束)");
            // 2.Balance DB：扣款
            await Deduction(shoppingData, prdouctInfo, sagaId);


            if (stepEnum == InterruptStepEnum.InterruptStep3)
                throw new Exception("第三步執行前中斷 (寫入 Log + 扣款 Balance 表 結束)");
            // 3.Member DB：更新會員消費 / 訂單狀態
            await UpdateMemberAndProudct(shoppingData, prdouctInfo, sagaId);
            

            if (stepEnum == InterruptStepEnum.InterruptStep4)
                throw new Exception("第四步執行前中斷(寫入 Log + 扣款 Balance 表 + 本地 Member 表 結束)");
            // 4.Log DB：更新交易狀態 = Completed

            await FinishLog(sagaId);
        }

    /// <summary>
    /// 1. 建立交易紀錄 => DB : Log
    /// </summary>
    public async Task<string> CreateLog(RequestModel shoppingData, ProductDao product)
        {
            using var uow = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Log);            
            _uowAccessor.Current = uow;

            var insertData = new SagaTransactionDao() 
            {
                 Amount = product.Price * shoppingData.Count,
                 MemberId = shoppingData.MemberId,
                 ProductId = product.ProductId,
                 Status = SagaTransactionStatusEnum.PENDING.ToString(),                  
            };
            var sagaId = await _logRepository.CreateLog(insertData);

            return sagaId;
        }

    /// <summary>
    /// 2. 扣款 => DB : Balance
    /// </summary>
    public async Task Deduction(RequestModel shoppingData, ProductDao product, string sagaId)
        {            
            using var uow = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Balance);
            _uowAccessor.Current = uow;
            var totalCost = product.Price * shoppingData.Count;
            try
            {
                await uow.BeginTransactionAsync();

                await _balanceRepository.UpdateBalance(shoppingData.MemberId, totalCost);                
                
                await _balanceRepository.CreateBalanceTransaction(shoppingData.MemberId, totalCost, product.ProductId, sagaId);

                await uow.CommitAsync();

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                await uow.RollbackAsync();
            }

        }

    /// <summary>
    /// 3. 更新會員消費 / 訂單狀態 => DB : Member
    /// </summary>
    public async Task UpdateMemberAndProudct(RequestModel shoppingData, ProductDao product, string sagaId)
        {
            using var uow = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Member);
            _uowAccessor.Current = uow;
            var totalCost = product.Price * shoppingData.Count;

            var insertData = new PurchaseDao()
            {
                SagaId = sagaId,
                Amount = totalCost,
                MemberId = shoppingData.MemberId,
                ProductId = product.ProductId,
                Status = SagaTransactionStatusEnum.COMPLETED.ToString(),
            };

            try
            {
                await uow.BeginTransactionAsync();

                await _memberRespository.InsertPurchase(insertData);
                await _memberRespository.UpdateMemberSpentMoney(shoppingData.MemberId, totalCost);

                await uow.CommitAsync();

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                await uow.RollbackAsync();
            }

        }

    /// <summary>
    // 4. 更新交易狀態 = Completed => DB : Log
    /// </summary>
    public async Task FinishLog(string sagaId)
        {
            using var uow = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Log);
            _uowAccessor.Current = uow;

            try
            {
                await _logRepository.UpdateLogStatus(sagaId, "COMPLETED");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }


    /// <summary>
    /// 取得產品資訊
    /// </summary>
    public async Task<ProductDao> GetProductInfo(long productId)
        {
            using var uow = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Member);            
            _uowAccessor.Current = uow;
            return await _memberRespository.GetProduct(productId);
        }

    /// <summary>
    /// 取得系統內會員資料
    /// </summary>
    public async Task<MemberDao> GetMemberInfo(long memberId)
        {
            using var uow = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Member);
            _uowAccessor.Current = uow;
            return await _memberRespository.GetMember(memberId);
        }
}

第四部分：SAGA 範例實作 - 補償服務

Step 1：補償服務 - 補償機制

開啟 QuartzJobForCompensatory.cs 檔案後，這是由 Quartz.Net 觸發，每 5 分鐘進行一次，模擬主體流程，分布式資料庫各階段異常時如何補償

    public class QuartzJobForCompensatory : IJob
    {
        private readonly IUnitOfWorkFactory _uowFactory;
        private readonly IUnitOfWorkAccessor _uowAccessor;
        private readonly ILogger<QuartzJobForCompensatory> _logger;
        private readonly IBalanceRepository _balanceRepository;
        private readonly ILogRepository _logRepository;
        private readonly IMemberRepository _memberRespository;
        private readonly IShoppingCartService _shoppingCartService;

        public QuartzJobForCompensatory(
            IUnitOfWorkFactory uowFactory,
            IUnitOfWorkAccessor uowAccessor,
            ILogger<QuartzJobForCompensatory> logger,
            IBalanceRepository balanceRepository,
            ILogRepository logRepository,
            IMemberRepository memberRespository,
            IShoppingCartService shoppingCartService)
        {
            _uowFactory = uowFactory;
            _uowAccessor = uowAccessor;
            _logger = logger;
            _balanceRepository = balanceRepository;
            _logRepository = logRepository;
            _memberRespository = memberRespository;
            _shoppingCartService = shoppingCartService;
        }

        /// <summary>
        /// 1. 實際執行
        /// </summary>
        public async Task Execute(IJobExecutionContext context)
        {
            var currentTiem = DateTime.Now;
            var seqTime = currentTiem.ToString("yyyyMMddHHmmss");
            Console.WriteLine("===== 開始處理 =====");
            Console.WriteLine("時間紀錄 : " + currentTiem.ToString("yyyy/MM/dd HH:mm:ss") + " 流水時間序 : "+ seqTime);

            // 1-1. 取出補償需處理的資料
            var compensatoryInfo = await GetSagaIdCompensatoryStatus();

            // 1-2. 補償1 : 捨棄未扣款的資料 - 影響 Log 庫
            if (compensatoryInfo.notDeductionSagaIds.Any())
            {
                await CompensatoryNotDeduction(compensatoryInfo.notDeductionSagaIds);
                Console.WriteLine($@"[{seqTime}] 補償1 : SagaId : {string.Join(", " , compensatoryInfo.notDeductionSagaIds)}");
            }

            // 1-3. 補償2 : 繼續將 Balance 已扣款資料統計到 Purchase - 影響 Member 庫
            if (compensatoryInfo.notPurchaseSagaIds.Any())
            {
                await CompensatoryNotPurchase(compensatoryInfo.notPurchaseSagaIds);
                Console.WriteLine($@"[{seqTime}] 補償2 : SagaId : {string.Join(", ", compensatoryInfo.notPurchaseSagaIds)}");

            }

            // 1-4. 補償3 : 將尚未標記 Complate 的 SagaId 處理完成 - 影響 Log 庫
            // 標記要包含本次有執行 (寫入 Log + 扣款 Balance 表 結束) 的資料
            var executeMarkIds = compensatoryInfo.notMarkComplateSagaIds;
            executeMarkIds.AddRange(compensatoryInfo.notPurchaseSagaIds);
            if (executeMarkIds.Any())
            {
                await CompensatorynotMarkComplate(executeMarkIds);
                Console.WriteLine($@"[{seqTime}] 補償3  : SagaId : {string.Join(", ", executeMarkIds)}");
            }

            Console.WriteLine("===== 結束處理 =====");
            Console.WriteLine("");
            // 上述補償 1~3 每個都是獨立的庫 EX:
            // 1. 當補償2 有 SagaId = 'A' 完成寫入 Member 庫後，這時發生中斷
            // 2. 下次服務再次觸發，會發現只差標記 Log 已完成，會直接進入 補償3
            // ※ 補償1 直接捨棄，若上次未執行，則下次服務觸發仍會在補償1 讓對應 SagaId 標記 FAILED
        }

        /// <summary>
        /// 1-1. 取得補償狀態
        /// </summary>
        private async Task<CompensatoryDto> GetSagaIdCompensatoryStatus()
        {
            var reuslt = new CompensatoryDto();

            using var uow = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Log);
            _uowAccessor.Current = uow;
            try
            {
                var getPendingSagaIds = await GetOverTimeSagaId();

                // 流程中尚需 : 扣款 + 購買統計 + 標記完成 (取消整筆訂單)
                reuslt.notDeductionSagaIds = await GetNotDeductionSagaIds(getPendingSagaIds);

                // 流程中尚需 : 購買統計 + 標記完成 (繼續處理，因為已經扣錢)
                reuslt.notPurchaseSagaIds = await GetNotPurchaseSagaIds(getPendingSagaIds.Except(reuslt.notDeductionSagaIds)
                                                                                                       .ToList());
                // 流程中尚需 : 標記完成 (繼續處理，已經完成只差在標記)
                reuslt.notMarkComplateSagaIds = getPendingSagaIds.Except(reuslt.notDeductionSagaIds)
                                                                 .Except(reuslt.notPurchaseSagaIds)
                                                                 .ToList();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                throw;
            }
            return reuslt;

            /// 取出超時要處理的資料 - SagaId + Status
            async Task<List<string>> GetOverTimeSagaId()
            {
                var getResult = new List<string>();
                var sql = $@"
SELECT SagaId 
  FROM SagaTransaction 
 WHERE SagaTransaction.STATUS = 'PENDING'
   AND NOW() > DATE_ADD(CreatedAt, INTERVAL 5 MINUTE)
;";
                try
                {
                    getResult = (await uow.Connection.QueryAsync<string>(sql)).ToList();
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                }
                return getResult;
            }

            // 取得尚未執行扣款的資料
            async Task<List<string>> GetNotDeductionSagaIds(List<string> sourcePendingSagaIds)
            {
                using var uowb = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Balance);
                _uowAccessor.Current = uowb;
                var missingIds = new List<string>();
                var sql = $@"
SELECT SagaId 
  FROM BalanceTransaction 
 WHERE sagaId IN @SagaIds
;";
                try
                {
                    var getResult = (await uowb.Connection.QueryAsync<string>(sql, new
                    {
                        @SagaIds = sourcePendingSagaIds
                    })).ToList();
                    // 排除法
                    missingIds = sourcePendingSagaIds.Except(getResult).ToList();
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                }

                return missingIds;
            }

            // 取得尚未執行統計-添加到 Purchase 的資料
            async Task<List<string>> GetNotPurchaseSagaIds(List<string> sourcePendingSagaIds)
            {
                using var uowm = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Member);
                _uowAccessor.Current = uowm;
                var missingIds = new List<string>();
                var sql = $@"
SELECT SagaId 
  FROM Purchase 
 WHERE sagaId IN @SagaIds
;";
                try
                {
                    var getResult = (await uowm.Connection.QueryAsync<string>(sql, new
                    {
                        @SagaIds = sourcePendingSagaIds
                    })).ToList();
                    // 排除法
                    missingIds = sourcePendingSagaIds.Except(getResult).ToList();
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex);
                }
                return missingIds;
            }
        }

        /// <summary>
        /// 1-2. 補償機制 -> 第二步執行前中斷 (寫入 Log 結束) -> 取消此筆訂單
        /// </summary>
        /// <returns></returns>
        private async Task CompensatoryNotDeduction(List<string> notDeductionSagaIds)
        {
            // 因為在 Balance 表中並未建立對應資料，沒有對實際的錢扣款，因此取消後續流程
            using var uow = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Log);
            _uowAccessor.Current = uow;
            try
            {
                await uow.BeginTransactionAsync();

                // 範例說明每筆皆會處理，實際上應改用 Bulk Update SQL 語法
                foreach (var sagaId in notDeductionSagaIds)
                {
                    await _logRepository.UpdateLogStatus(sagaId, "FAILED");
                }

                await uow.CommitAsync();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                await uow.RollbackAsync();
            }
        }

        /// <summary>
        /// 1-3. 補償機制 -> 第三步執行前中斷 (寫入 Log + 扣款 Balance 表 結束) -> 繼續處理，因為已經扣錢
        /// </summary>
        /// <returns></returns>
        private async Task CompensatoryNotPurchase(List<string> notPurchaseSagaIds)
        {
            using var uowb = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Balance);
            _uowAccessor.Current = uowb;
            var collectionItems = (await _balanceRepository.GetBalanceTransactionItems(notPurchaseSagaIds)).ToList();

            // 1. 繼續處理，因為已經扣錢
            using var uowm = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Member);
            _uowAccessor.Current = uowm;

            // 2. 處理 Member 庫
            try
            {
                
                await uowm.BeginTransactionAsync();

                // 範例說明每筆皆會處理，實際上應改用 Bulk Update SQL 語法
                foreach (var sagaId in notPurchaseSagaIds)
                {
                    var processItem = collectionItems.FirstOrDefault(item => item.SagaId == sagaId);

                    if (processItem != null)
                    {
                        var insertData = new PurchaseDao()
                        {
                            SagaId = sagaId,
                            Amount = processItem.Amount,
                            MemberId = processItem.MemberId,
                            ProductId = processItem.ProductId,
                            Status = SagaTransactionStatusEnum.COMPLETED.ToString(),
                        };

                        await _memberRespository.InsertPurchase(insertData);
                        await _memberRespository.UpdateMemberSpentMoney(insertData.MemberId, insertData.Amount);
                    }
                }

                await uowm.CommitAsync();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                await uowm.RollbackAsync();
            }
        }

        /// <summary>
        /// 1-4. 補償機制 -> 第四步執行前中斷(寫入 Log + 扣款 Balance 表 + 本地 Member 表 結束) -> 繼續處理，已經完成只差在標記
        /// </summary>
        /// <returns></returns>
        private async Task CompensatorynotMarkComplate(List<string> notMarkComplateSagaIds)
        {
            // 1. 繼續處理，已經完成只差在標記
            using var uow = await _uowFactory.CreateAsync(MysqlDbConnectionEnum.Log);
            _uowAccessor.Current = uow;
            try
            {
                await uow.BeginTransactionAsync();

                // 2. 範例說明每筆皆會處理，實際上應改用 Bulk Update SQL 語法
                foreach (var sagaId in notMarkComplateSagaIds)
                {
                    await _logRepository.UpdateLogStatus(sagaId, "COMPLETED");
                }

                await uow.CommitAsync();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
                await uow.RollbackAsync();
            }
        }

    }

第五部分：範例執行結果 DEMO

Step 1：啟動專案

啟動後，有以下 5 個按鈕

Step 2： Demo 執行按鈕 - 正常情況下，沒有任何異常的寫入

執行後，會完整生成一筆資訊， SagaId 會一致於 Log 庫 -> Balance 庫 -> Member 庫

Step 3：Demo 執行按鈕 - 第一步執行前中斷 (未執行)

執行後，因為未寫入 Log 資料庫，沒有 SagaId 因此，後續動作都執行無視，視為 Server 端與用戶交互異常
沒有真正進入資料業務寫入
如圖，Log 庫，未生成 SagaId：

Step 4：Demo 執行按鈕 - 第二步執行前中斷 (寫入 Log 結束) - 開始

執行後，有一筆 SagaId 在 Log 庫中，但是補償服務，檢查確認 沒有扣款

Step 5：Demo 執行按鈕 - 第二步執行前中斷 (寫入 Log 結束) - 補償方式:取消

最終將此筆 SagaId 取消，設定為 FAILED

Step 6：Demo 執行按鈕 - 第三步執行前中斷 (寫入 Log + 扣款 Balance 表 結束) - 開始

執行後，補償服務，檢查確認 有一筆 SagaId 在 Log 庫中 + 並且 Balance 庫該筆 SagaId 已經扣款會員金額 + ** Member 庫的 Purchase 沒有 SagaId 的消費紀錄**
因為已經有扣款，那麼合理的補償業務邏輯就是繼續完成後續工作 (寫 Member 消費紀錄 + 寫 Log 庫的標記更新)
※此階段若 Member 消費紀錄成功，但是 Log 庫寫入失敗(異常)，也不用擔心，會在下一個階段的補償處理， 實現可重試性

Step 7：Demo 執行按鈕 - 第三步執行前中斷 (寫入 Log + 扣款 Balance 表 結束) - 補償方式:繼續完成

最終將此筆 SagaId 在 Member 庫的 Purchase 新增資料，並且更新 Member 庫的 Member 表統計消費金額，並且將 Log 庫的 SagaId 標記為 “COMPLETED”

Step 8：Demo 執行按鈕 - 第四步執行前中斷(寫入 Log + 扣款 Balance 表 + 本地 Member 表 結束) - 開始

執行後，補償服務，檢查確認，三個庫的 SagaId 都有相關資訊存在，並且有處理，那麼只需要標記為 “COMPLETED”

Step 9：Demo 執行按鈕 - 第四步執行前中斷(寫入 Log + 扣款 Balance 表 + 本地 Member 表 結束) - 補償方式:繼續完成

最終將此筆 SagaId 於 Log 庫標記為 “COMPLETED”
至此，完成所有資料庫異常的處理 (補償機制)