Dapr Dotnet

API Patterns

创建yaml文件

// .dapr/components/pubsub.yaml
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: pubsub
spec:
  type: pubsub.redis
  version: v1
  metadata:
  - name: redisHost
    value: localhost:6379
  - name: redisPassword
    value: ""

// .dapr/components/statestore.yaml
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: statestore
spec:
  type: state.redis
  version: v1
  metadata:
  - name: redisHost
    value: localhost:6379
  - name: redisPassword
    value: ""
  - name: actorStateStore
    value: "true"

// .dapr/config/config.yaml
apiVersion: dapr.io/v1alpha1
kind: Configuration
metadata:
  name: daprConfig
spec:
  tracing:
    samplingRate: "1"
    zipkin:
      endpointAddress: http://localhost:9411/api/v2/spans
  nameResolution:
    component: "consul"
    configuration:
      client:
        address: "localhost:8500"
      selfRegister: true

Basic

// Api/Controllers/BaseController.cs
/// <summary>
/// 控制器基类
/// </summary>
[ApiController]
public class BaseController : ControllerBase
{
    
}

// Api/Extensions/ApiVersionInfo.cs
/// <summary>
/// api版本号
/// </summary>
public class ApiVersionInfo
{
    /// <summary>
    /// 版本：v1
    /// </summary>
    public static string v1;
}

// Api/Extensions/CustomExtensions.cs
/// <summary>
/// 
/// </summary>
public static class CustomExtensions
{
    public static void MapCustomHealthChecks(this WebApplication app)
    {
        app.MapHealthChecks("/dapr", new HealthCheckOptions()
        {
            Predicate = _ => true,
            ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse,
        });
        app.MapHealthChecks("/app");
    }
}

// Api/Extensions/DaprHealthCheck.cs
/// <summary>
/// 
/// </summary>
public class DaprHealthCheck : IHealthCheck
{
    private readonly DaprClient _daprClient;

    public DaprHealthCheck(DaprClient daprClient)
    {
        _daprClient = daprClient;
    }

    public async Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken cancellationToken = default)
    {
        var healthy = await _daprClient.CheckHealthAsync(cancellationToken);

        if (healthy)
        {
            return HealthCheckResult.Healthy("Dapr sidecar is healthy.");
        }

        return HealthCheckResult.Unhealthy("Dapr sidecar is unhealthy.");
    }
}

// Api/Extensions/ProgramExtensions.cs
/// <summary>
/// 
/// </summary>
public static class ProgramExtensions
{
    private const string appName = "API";
    public static void AddCustomServices(this WebApplicationBuilder builder)
    {
        builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
        builder.Services.AddMemoryCache(options =>
        {
            options.CompactionPercentage = 0.5; // 设置压缩百分比
        });
    }

    public static void AddCustomDaprdProcess(this WebApplicationBuilder builder)
    {
        var vConfigurationManager = builder.Configuration;
        var appId = vConfigurationManager.GetValue("AppProfile:AppId", "jytplatformequpmentapi");
        var appPort = vConfigurationManager.GetValue("AppProfile:AppPort", 8118);
        var daprHttpPort = vConfigurationManager.GetValue("AppProfile:DaprHttpPort", 18118);
        var daprGrpcPort = vConfigurationManager.GetValue("AppProfile:DaprGrpcPort", 28118);
        var otherDaprConfig = $"--config .dapr/config/config.yaml --resources-path .dapr/components --log-as-json";

#if DEBUG
        BaseHelper.AddDaprdProcess(appId, appPort, daprHttpPort, daprGrpcPort, otherDaprConfig);

        builder.Services.AddControllers().AddDapr(config =>
        {
            config.UseHttpEndpoint($"http://localhost:{daprHttpPort}");
            config.UseGrpcEndpoint($"http://localhost:{daprGrpcPort}");
        });
#else
    builder.Services.AddControllers().AddDapr();
#endif
    }

    public static void AddCustomAutofac(this WebApplicationBuilder builder)
    {
        builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
        builder.Host.ConfigureContainer<ContainerBuilder>(builder =>
        {
            builder.RegisterModule<AutofacModule>();
        });
    }

    public static void AddCustomLog(this WebApplicationBuilder builder)
    {
        builder.Host.UseSerilog((hostingContext, loggerConfiguration) =>
        {
            const string vOutputTemplate = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level}] {Message}{NewLine}{Exception}";

            loggerConfiguration.MinimumLevel.Information()
                .MinimumLevel.Override("Default", LogEventLevel.Information)
                .MinimumLevel.Override("Microsoft", LogEventLevel.Error)
                .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
                .Enrich.FromLogContext()
                .WriteTo.Console(outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}", theme: Serilog.Sinks.SystemConsole.Themes.AnsiConsoleTheme.Code)
                .WriteTo.File(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Logs", "log-.txt"),
                                rollingInterval: RollingInterval.Hour,
                                outputTemplate: vOutputTemplate,
                                retainedFileCountLimit: 100)
                .WriteTo.Logger(s => s.Filter.ByIncludingOnly(e => e.Level >= LogEventLevel.Warning)
                .WriteTo.File(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Logs", "errors", "log-.txt"),
                                rollingInterval: RollingInterval.Day,
                                outputTemplate: vOutputTemplate,
                                retainedFileCountLimit: 100));

            var esUrl = hostingContext.Configuration.GetSection("ElasticSearchUrl").Value;

            var indexFormat = $"{appName}" + "-{0:yyyy.MM}";

            if (!string.IsNullOrWhiteSpace(esUrl))
            {
                loggerConfiguration.WriteTo.Elasticsearch(new ElasticsearchSinkOptions(new Uri(esUrl))
                {
                    MinimumLogEventLevel = LogEventLevel.Information,
                    AutoRegisterTemplate = true,
                    IndexFormat = indexFormat
                });
            }
        });
    }

    public static void AddCustomMVC(this WebApplicationBuilder builder)
    {
        builder.Services.AddControllers()
        .AddJsonOptions(options =>
        {
            //数据格式原样输出
            options.JsonSerializerOptions.PropertyNamingPolicy = null;
            //取消Unicode编码
            options.JsonSerializerOptions.Encoder = JavaScriptEncoder.Create(UnicodeRanges.All);
            //允许额外符号
            options.JsonSerializerOptions.AllowTrailingCommas = true;
        });

        builder.Services.AddCors(options =>
        {
            options.AddPolicy("CorsPolicy", policy =>
            {
                var withOrigins = builder.Configuration["WithOrigins"];
                if (!string.IsNullOrWhiteSpace(withOrigins) && withOrigins.Split(';').Length > 0)
                    policy.WithOrigins(withOrigins.Split(';'));
                else
                    policy.SetIsOriginAllowed((host) => true);

                policy.AllowAnyMethod();
                policy.AllowAnyHeader();
                policy.AllowCredentials();
            });
        });
    }

        public static void AddCustomDbContext(this WebApplicationBuilder builder)
        {
            AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
            AppContext.SetSwitch("Npgsql.DisableDateTimeInfinityConversions", true);
            var vDbType = builder.Configuration["CurrentDbType"];
            IocDbType vIocDbType = IocDbType.SqlServer;
            switch (vDbType)
            {
                case "SqlServer":
                    vIocDbType = IocDbType.SqlServer;
                    break;

                case "MySql":
                    vIocDbType = IocDbType.MySql;
                    break;

                case "PostgreSQL":
                    vIocDbType = IocDbType.PostgreSQL;
                    break;
            }
            builder.Services.AddSqlSugar(new IocConfig()
            {
                ConfigId = "EquipmentAPI",
                ConnectionString = builder.Configuration[$"DataBase:{vIocDbType}:Database_ConnString"],
                DbType = vIocDbType,
                IsAutoCloseConnection = true
            });
            //AOP 统一配置  禁止循环，只能声名一次
            builder.Services.ConfigurationSugar(db =>
            {
                //里面可以循环
                db.GetConnection("API").Aop.OnLogExecuting = (sql, p) =>
                {
#if DEBUG
                    //ConsoleColor currentForeColor = Console.ForegroundColor;
                    //Console.ForegroundColor = ConsoleColor.Blue;
                    //Console.WriteLine(sql);
                    //Console.ForegroundColor = currentForeColor;
#endif
                };
                //里面可以循环
                db.GetConnection("API").Aop.OnError = (exp) =>
                {
#if DEBUG
                    ConsoleColor currentForeColor = Console.ForegroundColor;
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"{exp.Message}：{exp.Sql}");
                    Console.ForegroundColor = currentForeColor;
#endif
                };
            });
        }

    public static void AddCustomSwagger(this WebApplicationBuilder builder)
    {
        builder.Services.AddSwaggerGen(options =>
        {
            foreach (FieldInfo fileld in typeof(ApiVersionInfo).GetFields())
            {
                options.SwaggerDoc(fileld.Name, new OpenApiInfo
                {
                    Version = fileld.Name,
                    Title = $"API {fileld.Name} 接口文档",
                    Description = $"API {fileld.Name} 接口文档"
                });
            }
            var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
            options.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename));
        });
    }

    public static void AddCustomHealthChecks(this WebApplicationBuilder builder)
    {
        builder.Services.AddHealthChecks()
            .AddCheck(appName, () => HealthCheckResult.Healthy())
            .AddCheck<DaprHealthCheck>("dapr");
    }
}

public class AutofacModule : Autofac.Module
{
    protected override void Load(ContainerBuilder builder)
    {
        // 定义需要注册的程序集列表
        var vAssemblies = new[]
        {
            Assembly.Load("Domain"),
            Assembly.Load("Infrastructure"),
            Assembly.Load("Common"),
            Assembly.Load("Application")
        };

        // 注册所有实现了接口的类型，每个依赖关系创建一个新的实例
        foreach (var vAssembly in vAssemblies)
        {
            builder.RegisterAssemblyTypes(vAssembly)
                   .AsImplementedInterfaces()
                   .InstancePerDependency();
        }
    }
}

Program.cs Setup

CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("zh-CN", true) { DateTimeFormat = { ShortDatePattern = "yyyy-MM-dd", FullDateTimePattern = "yyyy-MM-dd HH:mm:ss", LongTimePattern = "HH:mm:ss" } };
var builder = WebApplication.CreateBuilder(args);
builder.Services.Configure<KestrelServerOptions>(k => k.AllowSynchronousIO = true)
    .Configure<IISServerOptions>(k => k.AllowSynchronousIO = true);
var app = builder.Build();
builder.AddCustomDaprdProcess();
builder.AddCustomAutofac();
builder.AddCustomLog();
builder.AddCustomMVC();
builder.AddCustomServices();
builder.AddCustomDbContext();
builder.AddCustomSwagger();
builder.AddCustomHealthChecks();
builder.Services.AddHttpClient();

var appPort = app.Configuration["AppProfile:AppPort"].ToString();
app.Urls.Add($"http://*:{appPort}");
if (app.Environment.IsDevelopment())
{
    app.UseSwagger().UseSwaggerUI(s =>
    {
        foreach (FieldInfo field in typeof(ApiVersionInfo).GetFields())
        {
            s.SwaggerEndpoint($"/swagger/{field.Name}/swagger.json", $"API {field.Name} 版本");
        }
    });
}
app.Use(
    (context, next) =>
    {
        context.Request.EnableBuffering();
        return next(context);
    });
app.UseCloudEvents();
app.UseRouting();
app.UseCors("CorsPolicy");
app.MapDefaultControllerRoute();
app.MapControllers();
app.MapSubscribeHandler();
app.MapCustomHealthChecks();
try
{    
    app.Logger.LogInformation("==============Starting API WebHost==============");
    app.Run();
}
catch (Exception e)
{
    app.Logger.LogError(e, "==============Host terminated unexpectedly==============");
}
finally
{
    Log.CloseAndFlush();
}

Result Pattern

API Result

// Common/ApiResult.cs
public class BaseResult
{
    /// <summary>
    /// 响应码
    /// </summary>
    [NotNull]
    public virtual HttpStatusCode Code { get; set; }


    /// <summary>
    /// 响应成功
    /// </summary>
    /// <returns></returns>
    public virtual void Success()
    {
        Code = HttpStatusCode.OK;
    }

    /// <summary>
    /// 响应失败
    /// </summary>
    /// <param name="message"></param>
    public virtual void Failed()
    {
        Code = HttpStatusCode.InternalServerError;
    }
}

/// <summary>
/// API返回结果结构
/// </summary>
public class ApiResult : BaseResult
{
    public ApiResult()
    {
        Success();
    }

    private string _Message = string.Empty;
    private string _Data = string.Empty;
    private byte[] _Base64Data;
    private string _ModelType = string.Empty;

    /// <summary>
    /// 消息提示
    /// </summary>
    public string Message { get => _Message; set => _Message = value; }
    /// <summary>
    /// 数据源
    /// </summary>
    public string Data { get => _Data; set => _Data = value; }
    /// <summary>
    /// 数据源模型
    /// </summary>
    public string ModelType { get => _ModelType; set => _ModelType = value; }
    /// <summary>
    /// Base64数据源
    /// </summary>
    public byte[] Base64Data { get => _Base64Data; set => _Base64Data = value; }


    /// <summary>
    /// 响应成功
    /// </summary>
    /// <param name="message">消息</param>
    public void Success(string message)
    {
        base.Success();
        _Message = message;
    }

    /// <summary>
    /// 响应成功
    /// </summary>
    /// <param name="data">数据</param>
    public void Success(dynamic data)
    {
        base.Success();

        _Data = JsonSerializer.Serialize(data, new JsonSerializerOptions
        {
            Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
        });

        _ModelType = GetDataType(data);
    }


    /// <summary>
    /// 响应成功
    /// </summary>
    /// <param name="data">数据</param>
    /// <param name="message">消息</param>
    public void Success(dynamic data, string message)
    {
        base.Success();
        _Message = message;
        _Data = JsonSerializer.Serialize(data, new JsonSerializerOptions
        {
            Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
        });
        _ModelType = GetDataType(data);
    }


    /// <summary>
    /// 响应成功
    /// </summary>
    /// <param name="dataList">数据</param>
    public void Success<T>(List<T> dataList)
    {
        base.Success();

        if (dataList != null && dataList.Any())
        {
            _Data = JsonSerializer.Serialize(dataList, new JsonSerializerOptions
            {
                Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
            });
            _ModelType = GetDataType(dataList);
        }
        else
        {
            _Data = string.Empty;
            _ModelType = string.Empty;
        }
    }

    /// <summary>
    /// 响应成功
    /// </summary>
    /// <param name="dataList">数据</param>
    /// <param name="message">消息</param>
    public void Success<T>(List<T> dataList, string message)
    {
        base.Success();
        _Message = message;
        if (dataList != null && dataList.Any())
        {
            _Data = JsonSerializer.Serialize(dataList, new JsonSerializerOptions
            {
                Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
            });
            _ModelType = GetDataType(dataList);
        }
        else
        {
            _Data = string.Empty;
            _ModelType = string.Empty;
        }
    }

    /// <summary>
    /// 响应失败
    /// </summary>
    /// <param name="message"></param>
    public void Failed(string message)
    {
        base.Failed();
        _Message = message;
    }

    /// <summary>
    /// 响应失败
    /// </summary>
    /// <param name="ex"></param>
    public void Failed(Exception ex)
    {
        base.Failed();
        _Message = ex.Message.ToString();
    }

    /// <summary>
    /// 响应失败
    /// </summary>
    /// <param name="ex"></param>
    public void Failed(HttpStatusCode httpStatusCode, string message)
    {
        Code = httpStatusCode;
        _Message = message;
    }


    /// <summary>
    /// 成功
    /// </summary>
    /// <param name="dataSource">数据源</param>
    /// <param name="code">状态码</param>
    /// <param name="message">消息提示</param>
    /// <param name="isSerialize">是否需要序列化</param>
    public static ApiResult Success(dynamic dataSource, string message = "操作成功", HttpStatusCode code = HttpStatusCode.OK, bool isSerialize = true)
    {
        return new ApiResult(dataSource, code, message, isSerialize);
    }

    /// <summary>
    /// 成功
    /// </summary>
    /// <param name="dataSourceList">数据源</param>
    /// <param name="code">状态码</param>
    /// <param name="message">消息提示</param>
    /// <param name="isSerialize">是否需要序列化</param>
    public static ApiResult Success<T>(List<T> dataSourceList, string message = "操作成功", HttpStatusCode code = HttpStatusCode.OK, bool isSerialize = true)
    {
        if (dataSourceList != null && dataSourceList.Any())
        {
            return new ApiResult(dataSourceList, code, message, isSerialize);
        }
        else
        {
            return new ApiResult(string.Empty, code, message, isSerialize);
        }
    }

    /// <summary>
    /// 失败
    /// </summary>
    /// <param name="code">状态码</param>
    /// <param name="message">消息提示</param>
    public static ApiResult Failed(string message = "操作失败", HttpStatusCode code = HttpStatusCode.InternalServerError)
    {
        return new ApiResult(string.Empty, code, message, false);
    }

    /// <summary>
    /// 响应模型
    /// </summary>
    /// <param name="dataSource">数据源</param>
    /// <param name="code">状态码</param>
    /// <param name="message">消息提示</param>
    /// <param name="isSerialize">是否需要序列化</param>
    private ApiResult(dynamic dataSource, HttpStatusCode code, string message, bool isSerialize)
    {
        if (dataSource != null && dataSource.GetType() == typeof(byte[]) && !isSerialize)
        {
            _Base64Data = dataSource;
        }
        else if (dataSource != null && dataSource?.GetType() != typeof(string) && isSerialize)
        {
            _Data = JsonSerializer.Serialize(dataSource, new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                NumberHandling = JsonNumberHandling.WriteAsString,
                Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
            });
        }
        else
        {
            _Data = dataSource;
        }
        Code = code;
        _Message = message;
        _ModelType = GetDataType(dataSource);
    }



    /// <summary>
    /// 获取返回模型的所有属性
    /// </summary>
    /// <param name="data"></param>
    /// <returns></returns>
    private static string GetDataType(dynamic data)
    {
        var str = string.Empty;

        System.Reflection.PropertyInfo[] properties = data.GetType().GetProperties();

        foreach (System.Reflection.PropertyInfo property in properties)
        {
            string propertyName = property.Name;
            string propertyType = property.PropertyType.Name;

            str += $"{propertyName} ({propertyType}),";
        }

        return !string.IsNullOrWhiteSpace(str) ? str[..^1] : str;
    }
}

/// <summary>
/// 泛型类型返回体
/// </summary>
/// <typeparam name="T"></typeparam>
public class ApiResult<T> : ApiResult
{
    /// <summary>
    /// 数据
    /// </summary>
    public T TData { get; set; }

    /// <summary>
    /// 列表的记录数
    /// </summary>
    public int Total { get; set; }
}

Application

// Application/IServices/IBaseService.cs
public interface IBaseService<T> where T : class, new()
{
    /// <summary>
    /// 添加
    /// </summary>
    /// <param name="AEntity"></param>
    /// <returns></returns>
    bool Insert(T AEntity);

    /// <summary>
    /// 添加
    /// </summary>
    /// <param name="AEntity"></param>
    /// <returns></returns>
    Task<bool> InsertAsync(T AEntity);

    /// <summary>
    /// 批量添加
    /// </summary>
    /// <param name="AList"></param>
    /// <returns></returns>
    Task<bool> InsertRangeAsync(List<T> AList);

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="AId"></param>
    /// <returns></returns>
    bool Delete(T AEntity);

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="AId"></param>
    /// <returns></returns>
    Task<bool> DeleteAsync(dynamic AId);

    /// <summary>
    /// 批量删除
    /// </summary>
    /// <param name="AIds"></param>
    /// <returns></returns>
    Task<bool> DeleteByIdsAsync(dynamic[] AIds);

    /// <summary>
    /// 更新
    /// </summary>
    /// <param name="AEntity"></param>
    /// <returns></returns>
    bool Update(T AEntity);

    /// <summary>
    /// 更新
    /// </summary>
    /// <param name="AEntity"></param>
    /// <returns></returns>
    Task<bool> UpdateAsync(T AEntity);

    /// <summary>
    /// 批量更新
    /// </summary>
    /// <param name="AList"></param>
    /// <returns></returns>
    Task<bool> UpdateRangeAsync(List<T> AList);

    /// <summary>
    /// 查询
    /// </summary>
    /// <param name="func"></param>
    /// <returns></returns>
    T Find(Expression<Func<T, bool>> func);

    /// <summary>
    /// 根据ID查询
    /// </summary>
    /// <param name="AId"></param>
    /// <returns></returns>
    Task<T> FindAsync(dynamic AId);

    /// <summary>
    /// 查询
    /// </summary>
    /// <param name="func"></param>
    /// <returns></returns>
    Task<T> FindAsync(Expression<Func<T, bool>> func);

    /// <summary>
    /// 查询
    /// </summary>
    /// <returns></returns>
    List<T> Query();

    /// <summary>
    /// 自定义查询
    /// </summary>
    /// <param name="func"></param>
    /// <returns></returns>
    List<T> Query(Expression<Func<T, bool>> func);

    /// <summary>
    /// 查询
    /// </summary>
    /// <returns></returns>
    Task<List<T>> QueryAsync();

    /// <summary>
    /// 自定义查询
    /// </summary>
    /// <param name="func"></param>
    /// <returns></returns>
    Task<List<T>> QueryAsync(Expression<Func<T, bool>> func);

    /// <summary>
    /// 分页查询
    /// </summary>
    /// <param name="APageIndex"></param>
    /// <param name="APageSize"></param>
    /// <param name="ATotal"></param>
    /// <returns></returns>
    Task<List<T>> QueryAsync(int APageIndex, int APageSize, RefAsync<int> ATotal);

    /// <summary>
    /// 自定义条件分页查询
    /// </summary>
    /// <param name="func"></param>
    /// <param name="APageIndex"></param>
    /// <param name="APageSize"></param>
    /// <param name="ATotal"></param>
    /// <returns></returns>
    Task<List<T>> QueryAsync(Expression<Func<T, bool>> func, int APageIndex, int APageSize, RefAsync<int> ATotal);

    /// <summary>
    /// 自定义条件分页查询
    /// </summary>
    /// <param name="func"></param>
    /// <param name="APageIndex"></param>
    /// <param name="APageSize"></param>
    /// <param name="ATotal"></param>
    /// <returns></returns>
    Task<List<T>> QueryAsync(Expression<Func<T, bool>> func, string orderByFields, int APageIndex, int APageSize, RefAsync<int> ATotal);

    /// <summary>
    /// 自定义条件分页查询
    /// </summary>
    /// <param name="whereExpression"></param>
    /// <param name="orderByExpression"></param>
    /// <param name="order"></param>
    /// <param name="APageIndex"></param>
    /// <param name="APageSize"></param>
    /// <param name="ATotal"></param>
    /// <returns></returns>
    Task<List<T>> QueryAsync(Expression<Func<T, bool>> whereExpression, Expression<Func<T, object>> orderByExpression, OrderByType order, int APageIndex, int APageSize, RefAsync<int> ATotal);

    /// <summary>
    /// 开始事务
    /// </summary>
    void BeginTran();

    /// <summary>
    /// 提交
    /// </summary>
    void CommitTran();

    /// <summary>
    /// 回滚
    /// </summary>
    void RollbackTran();

    #region 执行sql

    /// <summary>
    /// 获取DataTable数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataTable</returns>
    DataTable GetDataTable(string sql, object parameters);

    /// <summary>
    /// 获取DataTable数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataTable</returns>
    DataTable GetDataTable(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 获取DataTable数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataTable</returns>
    DataTable GetDataTable(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 获取DataTable数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataTable</returns>
    Task<DataTable> GetDataTableAsync(string sql, object parameters);

    /// <summary>
    /// 获取DataTable数据
    /// </summary>
    /// <param name="ASql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataTable</returns>
    Task<DataTable> GetDataTableAsync(string ASql, params SugarParameter[] parameters);

    /// <summary>
    /// 获取DataTable数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataTable</returns>
    Task<DataTable> GetDataTableAsync(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 获取DataSet数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataSet</returns>
    DataSet GetDataSetAll(string sql, object parameters);

    /// <summary>
    /// 获取DataSet数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataSet</returns>
    DataSet GetDataSetAll(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 获取DataSet数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataSet</returns>
    DataSet GetDataSetAll(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 获取DataSet数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataSet</returns>
    Task<DataSet> GetDataSetAllAsync(string sql, object parameters);

    /// <summary>
    /// 获取DataSet数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataSet</returns>
    Task<DataSet> GetDataSetAllAsync(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 获取DataSet数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataSet</returns>
    Task<DataSet> GetDataSetAllAsync(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 获取DataReader数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>IDataReader</returns>
    IDataReader GetDataReader(string sql, object parameters);

    /// <summary>
    /// 获取DataReader数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>IDataReader</returns>
    IDataReader GetDataReader(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 获取DataReader数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>IDataReader</returns>
    IDataReader GetDataReader(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 获取DataReader数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>IDataReader</returns>
    Task<IDataReader> GetDataReaderAsync(string sql, object parameters);

    /// <summary>
    /// 获取DataReader数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>IDataReader</returns>
    Task<IDataReader> GetDataReaderAsync(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 获取DataReader数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>IDataReader</returns>
    Task<IDataReader> GetDataReaderAsync(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 获取object数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>object</returns>
    object GetScalar(string sql, object parameters);

    /// <summary>
    /// 获取object数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>object</returns>
    object GetScalar(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 获取object数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>object</returns>
    object GetScalar(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 获取object数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>object</returns>
    Task<object> GetScalarAsync(string sql, object parameters);

    /// <summary>
    /// 获取object数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>object</returns>
    Task<object> GetScalarAsync(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 获取object数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>object</returns>
    Task<object> GetScalarAsync(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 执行sql返回整型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>int</returns>
    int ExecuteCommandWithGo(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 执行sql返回整型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>int</returns>
    int ExecuteCommand(string sql, object parameters);

    /// <summary>
    /// 执行sql返回整型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>int</returns>
    int ExecuteCommand(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 执行sql返回整型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>int</returns>
    int ExecuteCommand(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 执行sql返回整型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>int</returns>
    Task<int> ExecuteCommandAsync(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 执行sql返回整型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>int</returns>
    Task<int> ExecuteCommandAsync(string sql, object parameters);

    /// <summary>
    /// 执行sql返回整型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>int</returns>
    Task<int> ExecuteCommandAsync(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 执行SQL返回自定义实体
    /// </summary>
    /// <typeparam name="T">实体对象</typeparam>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    List<T> SqlQuery<T>(string sql, object parameters = null);

    /// <summary>
    /// 执行SQL返回自定义实体
    /// </summary>
    /// <typeparam name="T">实体对象</typeparam>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    List<T> SqlQuery<T>(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 执行SQL返回自定义实体
    /// </summary>
    /// <typeparam name="T">实体对象</typeparam>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    List<T> SqlQuery<T>(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 执行SQL返回自定义实体
    /// </summary>
    /// <typeparam name="T">实体对象</typeparam>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    Task<List<T>> SqlQueryAsync<T>(string sql, object parameters = null);

    /// <summary>
    /// 执行SQL返回自定义实体
    /// </summary>
    /// <typeparam name="T">实体对象</typeparam>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    Task<List<T>> SqlQueryAsync<T>(string sql, List<SugarParameter> parameters);

    /// <summary>
    /// 执行SQL返回自定义实体
    /// </summary>
    /// <typeparam name="T">实体对象</typeparam>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    Task<List<T>> SqlQueryAsync<T>(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 执行SQL返回自定义实体
    /// </summary>
    /// <typeparam name="T">实体对象</typeparam>
    /// <param name="sql"></param>
    /// <param name="whereObj"></param>
    /// <returns></returns>
    T SqlQuerySingle<T>(string sql, object whereObj = null);

    /// <summary>
    /// 执行SQL返回自定义实体
    /// </summary>
    /// <typeparam name="T">实体对象</typeparam>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    T SqlQuerySingle<T>(string sql, params SugarParameter[] parameters);

    /// <summary>
    /// 执行SQL返回自定义实体
    /// </summary>
    /// <typeparam name="T">实体对象</typeparam>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    T SqlQuerySingle<T>(string sql, List<SugarParameter> parameters);

    #endregion
}

// Application/IServices/ITestService.cs
public interface ITestService : IBaseService<Test>
{
}

// Application/IServices/BaseService.cs.cs
public class BaseService<T> : IBaseService<T> where T : class, new()
{
    protected IBaseRepository<T> _BaseRepository;

    public bool Delete(T AEntity)
    {
        return _BaseRepository.Delete(AEntity);
    }

    public async Task<bool> DeleteAsync(dynamic AId)
    {
        return await _BaseRepository.DeleteAsync(AId);
    }

    public async Task<bool> DeleteByIdsAsync(dynamic[] AIds)
    {
        return await _BaseRepository.DeleteByIdsAsync(AIds);
    }

    public T Find(Expression<Func<T, bool>> func)
    {
        return _BaseRepository.Find(func);
    }

    public async Task<T> FindAsync(dynamic AId)
    {
        return await _BaseRepository.FindAsync(AId);
    }

    public async Task<T> FindAsync(Expression<Func<T, bool>> func)
    {
        return await _BaseRepository.FindAsync(func);
    }

    public bool Insert(T AEntity)
    {
        return _BaseRepository.Insert(AEntity);
    }

    public async Task<bool> InsertAsync(T AEntity)
    {
        return await _BaseRepository.InsertAsync(AEntity);
    }

    public async Task<bool> InsertRangeAsync(List<T> AList)
    {
        return await _BaseRepository.InsertRangeAsync(AList); ;
    }

    /// <summary>
    /// 查询
    /// </summary>
    /// <returns></returns>
    public List<T> Query()
    {
        return _BaseRepository.Query();
    }

    /// <summary>
    /// 自定义查询
    /// </summary>
    /// <param name="func"></param>
    /// <returns></returns>
    public List<T> Query(Expression<Func<T, bool>> func)
    {
        return _BaseRepository.Query(func);
    }

    public async Task<List<T>> QueryAsync()
    {
        return await _BaseRepository.QueryAsync();
    }

    public async Task<List<T>> QueryAsync(Expression<Func<T, bool>> func)
    {
        return await _BaseRepository.QueryAsync(func);
    }

    public async Task<List<T>> QueryAsync(int APageIndex, int APageSize, RefAsync<int> ATotal)
    {
        return await _BaseRepository.QueryAsync(APageIndex, APageSize, ATotal);
    }

    public async Task<List<T>> QueryAsync(Expression<Func<T, bool>> func, int APageIndex, int APageSize, RefAsync<int> ATotal)
    {
        return await _BaseRepository.QueryAsync(func, APageIndex, APageSize, ATotal);
    }

    /// <summary>
    /// 自定义条件分页查询
    /// </summary>
    /// <param name="func"></param>
    /// <param name="APageIndex"></param>
    /// <param name="APageSize"></param>
    /// <param name="ATotal"></param>
    /// <returns></returns>
    public async Task<List<T>> QueryAsync(Expression<Func<T, bool>> func, string orderByFields, int APageIndex, int APageSize, RefAsync<int> ATotal)
    {
        return await _BaseRepository.QueryAsync(func, orderByFields, APageIndex, APageSize, ATotal);
    }

    /// <summary>
    /// 自定义条件分页查询
    /// </summary>
    /// <param name="whereExpression"></param>
    /// <param name="orderByExpression"></param>
    /// <param name="order"></param>
    /// <param name="APageIndex"></param>
    /// <param name="APageSize"></param>
    /// <param name="ATotal"></param>
    /// <returns></returns>
    public async Task<List<T>> QueryAsync(Expression<Func<T, bool>> whereExpression, Expression<Func<T, object>> orderByExpression, OrderByType order, int APageIndex, int APageSize, RefAsync<int> ATotal)
    {
        return await _BaseRepository.QueryAsync(whereExpression, orderByExpression, order, APageIndex, APageSize, ATotal);
    }

    public bool Update(T AEntity)
    {
        return _BaseRepository.Update(AEntity);
    }

    public async Task<bool> UpdateAsync(T AEntity)
    {
        return await _BaseRepository.UpdateAsync(AEntity);
    }

    public async Task<bool> UpdateRangeAsync(List<T> AList)
    {
        return await _BaseRepository.UpdateRangeAsync(AList);
    }

    /// <summary>
    /// 开始事务
    /// </summary>
    /// <exception cref="NotImplementedException"></exception>
    public void BeginTran()
    {
        _BaseRepository.BeginTran();
    }

    /// <summary>
    /// 提交事务
    /// </summary>
    /// <exception cref="NotImplementedException"></exception>
    public void CommitTran()
    {
        _BaseRepository.CommitTran();
    }

    /// <summary>
    /// 回滚事务
    /// </summary>
    /// <exception cref="NotImplementedException"></exception>
    public void RollbackTran()
    {
        _BaseRepository.RollbackTran();
    }

    #region 执行sql

    /// <summary>
    /// 获取DataTable数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataTable</returns>
    public DataTable GetDataTable(string sql, object parameters)
    {
        return _BaseRepository.GetDataTable(sql, parameters);
    }

    /// <summary>
    /// 获取DataTable数据
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="parameters"></param>
    /// <returns>DataTable</returns>
    public DataTable GetDataTable(string sql, params SugarParameter[] parameters)
    {
        return _BaseRepository.Ge

…(truncated)