Castle. Dynamic proxy implements transaction unit control

using System;
using System.Collections.Generic;
using System.Text;

namespace Initial.Extensions
{
    /// <summary>
    ///  The unit of work 
    ///  Only for property marking  
    /// </summary>
    public class UnitOfWorkAttribute : Attribute
    {

    }
}

using Castle.DynamicProxy;
using Microsoft.AspNetCore.Http;
using DataCommon.UnitOfWork;
using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;

namespace Initial
{
    public class UnitOfWorkIInterceptor : IInterceptor
    {
        #region  necessary 
        private readonly ILogger _logger;
        private readonly IUnitOfWork _unitOfWork;
        private readonly IHttpContextAccessor _httpContextAccessor;
        private readonly HttpContext _httpContext;
        #endregion

        public UnitOfWorkIInterceptor(
             ILogger logger,
             IUnitOfWork unitOfWork,
             IHttpContextAccessor httpContextAccessor
            )
        {
            _logger = logger;
            _unitOfWork = unitOfWork;
            _httpContextAccessor = httpContextAccessor;
            _httpContext = httpContextAccessor.HttpContext;
        }
        public void Intercept(IInvocation invocation)
        {
            MethodInfo methodInfo = invocation.MethodInvocationTarget;
            if (methodInfo == null)
                methodInfo = invocation.Method;

            UnitOfWorkAttribute transaction = methodInfo.GetCustomAttributes<UnitOfWorkAttribute>(true).FirstOrDefault();
            // If it's marked  [UnitOfWork], And not in transaction nesting .
            if (transaction != null)
            {
                try
                {
                    // Open transaction 
                    _unitOfWork.BeginTransaction();
                    invocation.Proceed();
                    // Commit transaction 
                    var result = ((Task<bool>)invocation.ReturnValue).Result;
                    _unitOfWork.Commit();
                }
                catch (Exception ex)
                {
                    // Roll back 
                    _unitOfWork.Rollback();
                    _logger.Info($"[{(_httpContextAccessor.HttpContext ?? _httpContext)?.TraceIdentifier}]" +
                        $"_{methodInfo.Name} Perform abnormal {ex.ToString()}");
                    throw new BusinessException(" Submit exception ");
                }
            }
            else
            {
                // If there is no sign [UnitOfWork], Direct execution method 
                invocation.Proceed();
            }
        }
    }
}

using Castle.Core;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Repository
{
    [Interceptor(typeof(UnitOfWorkIInterceptor))]
    public class TemplateRepository : ITemplateRepository
    {
        #region  necessary 
        private readonly ILogger _logger;
        private readonly IDBInstance _IDBInstance;
        #endregion

        public TemplateRepository(
           ILogger logger,
           IDBInstance IDBInstance
           )
        {
            _logger = logger;
            _IDBInstance = IDBInstance;

        }

        #region  Specification for addition, deletion, modification and query of single table 
        #endregion
     
 
 
        #region  Multi meter operation 

        [UnitOfWork]
        public async Task<bool> AddTepWithLogAsync(MSE_RPT_TEMPLATE mSE_RPT_TEMPLATE,
            MSE_RPT_TEMPLATE_LOG mSE_RPT_TEMPLATE_LOG)
        {
            await _IDBInstance.DBOperation.InsertAsync(mSE_RPT_TEMPLATE);
            await _IDBInstance.DBOperation.InsertAsync(mSE_RPT_TEMPLATE_LOG);
            return true;
       }

        [UnitOfWork]
        public async Task<bool> UpdateTepWithLogAsync(MSE_RPT_TEMPLATE mSE_RPT_TEMPLATE,
            MSE_RPT_TEMPLATE_LOG mSE_RPT_TEMPLATE_LOG)
        {
            await _IDBInstance.DBOperation.UpdateAsync(mSE_RPT_TEMPLATE);
            await _IDBInstance.DBOperation.InsertAsync(mSE_RPT_TEMPLATE_LOG);
            return true;
        }

        #endregion

    }
}

1、 The first code block is mainly for marking the methods that need transactions

2、 The second code block mainly controls the transaction ;