设计模式实现Web API的DRY原则

Question

我的控制器中有以下两个操作方法。两者都采用相同的参数，并对模型进行相同的验证。它只在调用服务方法的一行有所不同。

有没有更好的方法来重构这些代码？

[HttpPost]
public async Task<IActionResult> Search([FromBody]AggregateSearchCriteria criteria)
{
if (criteria == null || !criteria.Aggregates.Any())
{
return BadRequest();
}
var providers = Request.Headers["providers"];
if (providers.Equals(StringValues.Empty))
return BadRequest();
criteria.Providers = providers.ToString().Split(',').ToList();
ModelState.Clear();
TryValidateModel(criteria);
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var result = await _searchService.Search(criteria);
return Ok(result);
}
[HttpPost("rulebreak")]
public async Task<IActionResult> SearchRuleBreak([FromBody]AggregateSearchCriteria criteria)
{
if (criteria == null || !criteria.Aggregates.Any())
{
return BadRequest();
}
var providers = Request.Headers["providers"];
if (providers.Equals(StringValues.Empty))
return BadRequest();
criteria.Providers = providers.ToString().Split(',').ToList();
ModelState.Clear();
TryValidateModel(criteria);
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var result = await _searchService.SearchRuleBreak(criteria);
return Ok(result);
}

Answer 1

这样的事情可能是一个开始。

[HttpPost]
public async Task<IActionResult> Search([FromBody]AggregateSearchCriteria criteria)
{
return await Common(criteria, c => _searchService.Search(c));
}
public async Task<IActionResult> SearchRuleBreak([FromBody]AggregateSearchCriteria criteria)
{
return await Common(criteria, c => _searchService.SearchRuleBreak(c));
}
private async Task<IActionResult> Common(AggregateSearchCriteria criteria, Func<List<string>, Task<???>> action)
{
if (criteria == null || !criteria.Aggregates.Any())
{
return BadRequest();
}
var providers = Request.Headers["providers"];
if (providers.Equals(StringValues.Empty))
return BadRequest();
criteria.Providers = providers.ToString().Split(',').ToList();
ModelState.Clear();
TryValidateModel(criteria);
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var result = await action.Invoke(criteria);
return Ok(result);
}

Answer 2

在这种情况下，模板模式是可行的。但与验证无关。您还必须注意控制器的依赖性。请注意，如果没有一些更改，下面的代码将无法自动工作。

public abstract class BaseSearch
{
public Task<IActionResult> Apply(AggregateSearchCriteria criteria)
{
if (criteria == null || !criteria.Aggregates.Any())
{
return BadRequest();
}
var providers = Request.Headers["providers"];
if (providers.Equals(StringValues.Empty))
return BadRequest();
criteria.Providers = providers.ToString().Split(',').ToList();
ModelState.Clear();
TryValidateModel(criteria);
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var result = await ServiceCall(criteria);
return Ok(result);
}
protected abstract async IActionResult ServiceCall(AggregateSearchCriteria criteria);
}
public class Search : BaseSearch
{
protected async Task<IActionResult> ServiceCall(AggregateSearchCriteria criteria)
{
return await _searchService.Search(criteria);
}
}
public class SearchRuleBreak : BaseSearch
{
protected async Task<IActionResult> ServiceCall(AggregateSearchCriteria criteria)
{
return await _searchService.SearchRuleBreak(criteria);
}
}

然后在呼叫时：

[HttpPost]
public async Task<IActionResult> Search([FromBody]AggregateSearchCriteria criteria)
{
return await new Search().Apply(criteria);
}
[HttpPost("rulebreak")]
public async Task<IActionResult> SearchRuleBreak([FromBody]AggregateSearchCriteria criteria)
{
return await new SearchRuleBreak().Apply(criteria);
}

注意：正如@stuartd所建议的，随着当今语言越来越实用，"将函数作为参数发送"方法也是一种有效的方法。

Answer 3

您可以为模型AggregateSearchCriteria实现IValidatableObject，并在其中移动所有验证逻辑。对于提供者，您可以将其添加到模型中，并编写一个自定义数据绑定器，该绑定器将绑定头中的值。您还可以编写一个昏迷数组绑定器，将您的值拆分为一个数组。

public class AggregateSearchCriteria : IValidatableObject
{
[FromHeader]
public IList<string> Providers { get; set; } = new List<string>();
public IList<string> Aggregates { get; set; } = new List<string>();
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
var result = new List<ValidationResult>();
if (!Providers.Any())
{
result.Add(new ValidationResult("No Providers", new[] { nameof(AggregateSearchCriteria.Providers) }));
}
if (!Aggregates.Any())
{
result.Add(new ValidationResult("No Aggregates", new[] { nameof(AggregateSearchCriteria.Aggregates) }));
}
return result;
}
}
[HttpPost]
public async Task<IActionResult> Search([FromBody]AggregateSearchCriteria criteria)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var result = await _searchService.Search(criteria);
return Ok(result);
}