C# 如何在Microsoft企业库中编写的通用数据层中动态添加业务规则？

如何在Microsoft企业库中编写的通用数据层中动态添加业务规则

我开发了一个通用数据层。我正在使用企业库进行数据通信

这是我的密码

我的存储库

public sealed class DbRepository : IDbRepository
{
    private readonly SqlDatabase database;
    public DbRepository(Database database)
    {
        this.database = database as SqlDatabase;
    }
    public async Task<DbResponseBase<TResult>> GetResponseAsync<TResult, TOutput>(DbRequestBase request) where TResult : class
    {
        DbCommand cmd = database.GetStoredProcCommand(request.ProcedureName);

        SpParameterMapper<TOutput> parameterMapper = new SpParameterMapper<TOutput>();
        parameterMapper.AssignParameters(cmd, new object[] { request.InputJson });

        DbJsonResponseMapper responseMapper = null;
        TResult model = default;
        try
        {
            #region Execute Stored Procedure.
            switch (request.RequestType)
            {
                case DbRequestType.Insert:
                case DbRequestType.Update:
                case DbRequestType.Delete:
                    int returnValue = await Task<int>.Factory.FromAsync(database.BeginExecuteNonQuery, database.EndExecuteNonQuery, cmd, null);
                    break;
                case DbRequestType.Scalar:
                    model = (TResult)await Task<object>.Factory.FromAsync(database.BeginExecuteScalar, database.EndExecuteScalar, cmd, null);
                    break;
                case DbRequestType.Select:
                    responseMapper = await Task.Run(() =>
                            database
                                .ExecuteSprocAccessor<DbJsonResponseMapper>(
                                    request.ProcedureName,
                                    parameterMapper,
                                    new object[] { request.InputJson }
                                ).SingleOrDefault()
                        );
                    break;
                default:
                    break;
            }
            #endregion
        }
        catch (ArgumentNullException ex1) { throw ex1; }
        catch (ArgumentException ex2) { throw ex2; }
        catch (Exception ex) { throw new ApplicationException(ex.Message); }

        OutputParameter<TOutput> output = parameterMapper.GetOurputParameters();

        try
        {
            #region Prepare Result based on Output Parameter.
            switch (output.DataType)
            {
                case DataType.Scalar:
                    break;
                case DataType.Grid:
                    break;
                case DataType.Json:
                    model = responseMapper.Data?.To<TResult>();
                    break;
                default:
                    break;
            }
        }
        catch (Exception ex)
        {

             throw new ApplicationException(ex.Message); ;
        }
        #endregion

        return new DbResponse<TResult, TOutput>
        {
            OutPutParameters = output,
            Data = model
        };
    }
}

公共密封类DbRepository:IDBRository
{
专用只读数据库；
公共数据库存储库（数据库）
{
this.database=数据库作为SqlDatabase；
}
公共异步任务GetResponseAsync（DbRequestBase请求），其中TResult:class
{
DbCommand cmd=database.GetStoredProcCommand（request.ProcedureName）；
SpParameterMapper parameterMapper=新的SpParameterMapper（）；
parameterMapper.AssignParameters（cmd，新对象[]{request.InputJson}）；
DbJsonResponseMapper responseMapper=null；
TResult model=默认值；
尝试
{
#区域执行存储过程。
开关（request.RequestType）
{
案例DbRequestType。插入：
案例DbRequestType.Update：
案例DbRequestType。删除：
int returnValue=await Task.Factory.fromsync（database.beginexecutenquery，database.endexecutenquery，cmd，null）；
打破
案例DbRequestType.Scalar：
model=（TResult）wait Task.Factory.fromsync（database.BeginExecuteScalar，database.EndExecuteScalar，cmd，null）；
打破
案例DbRequestType。选择：
responseMapper=等待任务。运行（（）=>
数据库
.执行官(
request.ProcedureName，
参数apper，
新对象[]{request.InputJson}
).SingleOrDefault（）
);
打破
违约：
打破
}
#端区
}
catch（ArgumentNullException ex1）{throw ex1；}
catch（ArgumentException ex2）{throw ex2；}
catch（Exception ex）{抛出新的ApplicationException（ex.Message）；}
OutputParameter输出=parameterMapper.GetOurputParameters（）；
尝试
{
#区域根据输出参数准备结果。
开关（输出.数据类型）
{
案例数据类型。标量：
打破
案例数据类型。网格：
打破
case DataType.Json：
model=responseMapper.Data？.To（）；
打破
违约：
打破
}
}
捕获（例外情况除外）
{
抛出新的ApplicationException（例如Message）；
}
#端区
返回新的DbResponse
{
OutPutParameters=输出，
数据=模型
};
}
}

sqlparameterapper.cs

internal sealed class SpParameterMapper<T> : IParameterMapper
{
    DbCommand _cmd = null;

    public OutputParameter<T> GetOurputParameters()
    {
        try
        {
            return new OutputParameter<T>
            {
                RetVal = (int)_cmd.Parameters["@RetVal"].Value,
                DataType = (DataType)_cmd.Parameters["@DataType"].Value,
                ErrorNumber = _cmd.Parameters["@ErrorNumber"].Value == DBNull.Value ? 0 : (int)_cmd.Parameters["@ErrorNumber"].Value,
                ErrorMessage = _cmd.Parameters["@ErrorMessage"].Value == DBNull.Value ? string.Empty : (string)_cmd.Parameters["@ErrorMessage"].Value,
                JsonOutput = _cmd.Parameters["@JsonOutput"].Value == DBNull.Value ? default(T) : ((string)_cmd.Parameters["@JsonOutput"].Value).To<T>()
            };
        }
        catch (Exception)
        {
            throw new ApplicationException("Error Occured While reading Output Parameter of Stored Procedure.");
        }
    }

    public void AssignParameters(DbCommand command, object[] parameterValues)
    {
        if (parameterValues == null)
        {
            throw new ArgumentNullException();
        }
        if (parameterValues.Count() != 1)
        {
            throw new ArgumentException("Invalid Stored Procedure Parameter Count.");
        }

        _cmd = command;

        DbParameter[] parametersArray = new DbParameter[] {
            command.CreateParameter(),
            command.CreateParameter(),
            command.CreateParameter(),
            command.CreateParameter(),
            command.CreateParameter(),
            command.CreateParameter()
        };

        parametersArray[0].ParameterName = "@Json";
        parametersArray[0].Value = parameterValues[0];

        parametersArray[1].ParameterName = "@RetVal";
        parametersArray[1].DbType = DbType.Int32;
        parametersArray[1].Direction = ParameterDirection.Output;
        parametersArray[1].Size = Int32.MaxValue;
        parametersArray[1].Value = DBNull.Value;

        parametersArray[2].ParameterName = "@DataType";
        parametersArray[2].DbType = DbType.Int32;
        parametersArray[2].Direction = ParameterDirection.Output;
        parametersArray[2].Size = Int32.MaxValue;
        parametersArray[2].Value = DBNull.Value;

        parametersArray[3].ParameterName = "@ErrorNumber";
        parametersArray[3].DbType = DbType.Int32;
        parametersArray[3].Direction = ParameterDirection.Output;
        parametersArray[3].Size = Int32.MaxValue;
        parametersArray[3].Value = DBNull.Value;

        parametersArray[4].ParameterName = "@ErrorMessage";
        parametersArray[4].DbType = DbType.String;
        parametersArray[4].Size = 2000;
        parametersArray[4].Direction = ParameterDirection.Output;
        parametersArray[4].Value = DBNull.Value;

        parametersArray[5].ParameterName = "@JsonOutput";
        parametersArray[5].DbType = DbType.String;
        parametersArray[5].Size = 8000;
        parametersArray[5].Direction = ParameterDirection.Output;
        parametersArray[5].Value = DBNull.Value;

        command.Parameters.AddRange(parametersArray);
    }
}

内部密封类SpParameterMapper:IPParameterMapper
{
DbCommand _cmd=null；
公共输出参数GetOurputParameters（）
{
尝试
{
返回新的OutputParameter
{
RetVal=（int）_cmd.Parameters[“@RetVal”].Value，
数据类型=（数据类型）\命令参数[“@DataType”].Value，
ErrorNumber=_cmd.Parameters[“@ErrorNumber”].Value==DBNull.Value？0：（int）_cmd.Parameters[“@ErrorNumber”].Value，
ErrorMessage=_cmd.Parameters[“@ErrorMessage”].Value==DBNull.Value？string.Empty：（string）_cmd.Parameters[“@ErrorMessage”].Value，
JsonOutput=_cmd.Parameters[“@JsonOutput”].Value==DBNull.Value？默认值（T）：（（字符串）_cmd.Parameters[“@JsonOutput”].Value）.To（）
};
}
捕获（例外）
{
抛出新的ApplicationException（“读取存储过程的输出参数时出错。”）；
}
}
public void AssignParameters（DbCommand命令，object[]参数值）
{
if（参数值==null）
{
抛出新ArgumentNullException（）；
}
if（parameterValues.Count（）！=1）
{
抛出新ArgumentException（“无效的存储过程参数计数”）；
}
_cmd=命令；
DbParameter[]parametersArray=新的DbParameter[]{
command.CreateParameter（），
command.CreateParameter（），
command.CreateParameter（），
command.CreateParameter（），
command.CreateParameter（），
command.CreateParameter（）
};
parametersArray[0]。ParameterName=“@Json”；
parametersArray[0]。Value=parameterValues[0]；
parametersArray[1]。ParameterName=“@RetVal”；
参数数组[1].DbType=DbType.Int32；
parametersArray[1]。方向=ParameterDirection.Output；
参数数组[1]。大小=Int32.MaxValue；
参数数组[1]。Value=DBNull.Value；
parametersArray[2]。ParameterName=“@DataType”；
参数数组[2].DbType=DbType.Int32；
parametersArray[2]。方向=ParameterDirection.Output；
参数数组[2]。大小=Int32.MaxValue；
参数数组[2]。Value=DBNull.Value；
parametersArray[3]。ParameterName=“@ErrorNumber”；
参数数组[3].DbType=DbType.Int32；
parametersArray[3]。方向=ParameterDirection.Output；
参数数组[3]。大小=Int32.MaxValue；
参数数组[3]。Value=DBNull.Value；
parametersArray[4]。ParameterName=“@ErrorMessage”；
参数数组[4].DbType=DbType.String；
参数数组[4]。大小=2000；
parametersArray[4]。方向=ParameterDirection.Output；
参数数组[4]。值=DBNull.Va
[EnableCors(origins: "*", headers: "*", methods: "*")]
[RoutePrefix(RouteConstants.GroupRoutePrefix)]
public class GroupController : ApiController
{
    private readonly IDbContext dbContext = null;
    public GroupController(IDbContext dbContext)
    {
        this.dbContext = dbContext;
    }

    [HttpPost]
    [JWTAuthenticationFilter(Roles = "Admin,Coordinator")]
    [Route(RouteConstants.GroupList)]
    [ApiValidateModel]
    public async Task<HttpResponseMessage> List(DefaultDataTableFilterRequest model)
    {

        var identity = User.Identity as JWTAuthenticationIdentity;

        DbRequest request = new DbRequest
        {
            InputJson = model.ToJson(),
            ProcedureName = StoredProcedure.GroupList,
            RequestType = DbRequestType.Select
        };

        var dbResponse = (DbResponse<List<GroupListViewModel>, ListOutput>)
        (
            await (dbContext.DbRepository.GetResponseAsync<List<GroupListViewModel>, ListOutput>(request))
        );

        return dbResponse.CreateHttpResponse(Request, Configuration);
    }

    [HttpPost]
    [JWTAuthenticationFilter(Roles = "Admin,Coordinator")]
    [Route(RouteConstants.GroupDetails)]
    [ApiValidateModel]
    public async Task<HttpResponseMessage> Details(int ID)
    {
        DbRequest request = new DbRequest
        {
            InputJson = new { ID }.ToJson(),
            ProcedureName = StoredProcedure.GroupDetails,
            RequestType = DbRequestType.Select
        };

        var dbResponse = (DbResponse<GroupViewModel, object>)
        (
            await (dbContext.DbRepository.GetResponseAsync<GroupViewModel, object>(request))
        );

        return dbResponse.CreateHttpResponse(Request, Configuration);
    }

    [HttpPost]
    [JWTAuthenticationFilter(Roles = "Admin,Coordinator")]
    [Route(RouteConstants.GroupSave)]
    [ApiValidateModel]
    public async Task<HttpResponseMessage> Save(GroupViewModel model)
    {
        DbRequest request = new DbRequest
        {
            InputJson = model.ToJson(),
            ProcedureName = StoredProcedure.GroupSave,
            RequestType = DbRequestType.Insert
        };

        var dbResponse = (DbResponse<object, object>)
         (await (dbContext.DbRepository.GetResponseAsync<object, object>(
           request
         )));

        return dbResponse.CreateHttpResponse(Request, Configuration);
    }

    [HttpPost]
    [JWTAuthenticationFilter(Roles = "Admin")]
    [Route(RouteConstants.GroupDelete)]
    [ApiValidateModel]
    public async Task<HttpResponseMessage> Delete(int ID)
    {
        DbRequest request = new DbRequest
        {
            InputJson = new { ID, Status = 1 }.ToJson(),
            ProcedureName = StoredProcedure.GroupDelete,
            RequestType = DbRequestType.Scalar
        };

        var dbResponse = (DbResponse<object, object>)
        (await (dbContext.DbRepository.GetResponseAsync<object, object>(
          request
        )));

        return dbResponse.CreateHttpResponse(Request, Configuration);
    }
}