C# - 用于迭代谓词的模式

Question

我做了一个我不太喜欢的图案。

如下：

List<Element> listOfPossibleResults = getAllPossibleResults();

Element result = findResult(getFirstPriorityElements(listOfPossibleResults));
if (result!= null)
{
 return result;
}

result = findResult(getSecondPriorityElements(listOfPossibleResults));
if (result!= null)
{
 return result;
}

private Element findResult(List<Element> elements) {...};
private List<Element> getFirstPriorityElements(List<Element> elements) {...};
private List<Element> getSecondPriorityElements(List<Element> elements) {...};

等等。

基本上，我正在根据一些规则创建子列表。创建子列表后，我尝试在其中找到特定元素。如果我没有找到，我会转到下一个优先级，依此类推。

我想要一个可以迭代这些标准的解决方案，直到找到解决方案。但我不知道如何将它们变成我可以迭代的格式。

你们能给我这个问题的 C# 特定解决方案吗？

Answer 1

正如@Lepijohnny 提到的，您可以使用Chain of responsibility 设计模式。例如：

abstract class Handler<TRequest, TResult>
{
  protected Handler<TRequest, TResult> successor;

  public void SetSuccessor(Handler<TRequest, TResult> successor)
  {
    this.successor = successor;
  }

  public abstract TResult HandleRequest(TRequest request);
}

class FirstHandler : Handler<List<Element>, Element>
{
  public override void HandleRequest(TRequest request)
  {
    Element result = findResult(getFirstPriorityElements(request));
    if (result == null)
    {
      result = sucessor?.HandleRequest(request);
    }
    return result;
  }

  private Element findResult(List<Element> elements) {...};
  private List<Element> getFirstPriorityElements(List<Element> elements) {...};
}

class SecondHandler : Handler<List<Element>, Element>
{
  public override void HandleRequest(TRequest request)
  {
    Element result = findResult(getSecondPriorityElements(request));
    if (result == null)
    {
      result = sucessor?.HandleRequest(request);
    }
    return result;
  }

  private Element findResult(List<Element> elements) {...};
  private List<Element> getSecondPriorityElements(List<Element> elements) {...};
}

用法：

void Example()
{
  // Setup Chain of Responsibility
  var h1 = new FirstHandler();
  var h2 = new SecondHandler();
  h1.SetSuccessor(h2);

  var result = h1.Handle(new List<Element>());
}

这是一个简单的例子。我认为它描述了这种模式的工作原理，您可以根据需要对其进行调整。

Answer 2

在“结果”类中放置一个名为“Priority (int)”的属性，然后：

result = listOfPossibleResults.GroupBy(x => x.Priority).OrderBy(x => x.Key);

然后：

return result.FirstOrDefault(x => x.Count() > 0);

第一次检索时需要填写结果项的优先级。

附：我在这里输入了代码，如果某处有拼写错误，请见谅。

Answer 3

如果您可以将方法 getFirstPriorityElements(List list) 重构为单个 getPriorityElements(List list, int nr) 您可以执行以下操作

method IteratePredicates(List<> list, int nr = 0) 
{
    if (nr>maxpriority) return null;
    return findresult(getPriorityElements(list,nr)) ?? IteratePredicates(list,nr++);
}

在for循环中：

    method IteratePredicates(List<> list, int nr = 0)
    {
        for (int i = 0; i < maxpriority; i++)
        {
            var result = findresult(getPriorityElements(list, nr));
            if (result != null)
                return result;
        }
        return null;
    }

Answer 4

您的 get__PriorityElements 实际上是一个过滤器，我说得对吗？在这种情况下，这样处理它们更具声明性并且希望更具可读性：

Func<Element, bool> isFirstPriority = ...;
var firstPriorityElements = elements.Where(isFirstPriority);

现在您的总体目标是使用包含在findResult? 中的谓词从可能具有最高优先级的子序列中提取单个元素（或不提取）？所以用一个实际的谓词替换它

Func<Element, bool> isResult = ...;

像这样。现在您要查看所有第一优先级元素的isResult 匹配，如果没有找到所有第二优先级元素，等等。这听起来就像一个序列连接！所以我们最终得到了

var prioritisedSequence = elements
    .Where(isFirstPriority)
    .Concat(elements
        .Where(isSecondPriority))
    .Concat....;

最后是结果

var result = prioritisedSequence
    .FirstOrDefault(isResult);

由于Where 和Concat 是惰性枚举的，因此它的好处是它是声明性的，同时避免了不必要的工作，而且它是轻量级的并且也是“LINQy”。

如果您想进一步抽象它，并预计优先级的排列方式会发生变化，您实际上可以为这样的人制作一个更高顺序的列表：

IEnumerable<Func<Element, bool>> priorityFilters = new[]
{
    isFirstPriority,
    isSecondPriority,
    ...
};

然后可以将连接作为对该序列的聚合来执行：

var prioritisedSequence = priorityFilters
    .Aggregate(
        Enumerable.Empty<Element>(),
        (current, filter) => current.Concat(elements.Where(filter)));

此更改可能会更容易在将来添加新的优先级，或者您可能会认为它会混乱并隐藏代码的意图。

Answer 5

您可以使用Func<T, T> 将方法视为对象，然后您也可以将它们放入例如数组。然后就可以遍历数组，一个个调用方法，直到找到结果。

那么解决方案就变成了：

var methods = new Func<List<Element>, List<Element>>[]
    { getFirstPriorityElements, getSecondPriorityElements };

return methods
    .Select(method => findResult(method(listOfPossibleResults)))
    .Where(result => result != null)
    .FirstOrDefault();

这简短易读，无需更改您的方法或类型即可工作，并且无需仅为应用模式而添加类。

Answer 6

您可以使用规范模式
这是一个示例代码：
使用标准创建接口：

public interface ISpecification<T>
{
    Expression<Func<T, bool>> Criteria { get; }
}

然后创建一个包含查询规范的类：

public class GlobalSongSpecification : ISpecification<Song>
{
    public List<int> GenreIdsToInclude { get; set; } = new List<int>();
    public List<int> AlbumIdsToInclude { get; set; } = new List<int>();
    public List<string> ArtistsToInclude { get; set; } = new List<string>();
    public string TitleFilter { get; set; }
    public int MinRating { get; set; }

    [JsonIgnore]
    public Expression<Func<Song, bool>> Criteria
    {
        get
        {
            return s =>
                (!GenreIdsToInclude.Any() || s.Genres.Any(g => GenreIdsToInclude.Any(gId => gId == g.Id))) &&
                (!AlbumIdsToInclude.Any() || AlbumIdsToInclude.Contains(s.AlbumId)) &&
                (!ArtistsToInclude.Any() ||ArtistsToInclude.Contains(s.Artist)) &&
                (String.IsNullOrEmpty(this.TitleFilter) || s.Title.Contains(TitleFilter)) &&
                s.Rating >= MinRating;
        }
    }
}

使用公开接收 ISpecification 的方法创建存储库：

 public interface ISongRepository
{
    IEnumerable<Song> List(ISpecification<Song> specification);
    //IQueryable<Song> List();
    Song GetById(int id);
    void Add(Song song);
    IEnumerable<string> AllArtists();
    IEnumerable<Genre> AllGenres();
}

您的客户端代码调用 GlobalSongSpecification，填充它并将其传递到存储库，以便按条件过滤：

public ActionResult Index(List<int> selectedGenres = null, 
        List<string> selectedArtists = null, 
        string titleSearch = null,
        int minRating = 0,
        string filter = null,
        string save = null,
        string playlistName = null)
    {
        if (selectedArtists == null) { selectedArtists = new List<string>(); }
        if (selectedGenres == null) { selectedGenres = new List<int>(); }

        var spec = new GlobalSongSpecification();
        spec.ArtistsToInclude.AddRange(selectedArtists);
        spec.GenreIdsToInclude.AddRange(selectedGenres);
        spec.MinRating = minRating;
        spec.TitleFilter = titleSearch;

        var songs = _songRepository.List(spec);

        //You can work with the filtered data at this point
    }

然后您填充剃刀视图或将其公开为 Web api。 示例代码来自复数设计模式库课程Here(Specification Pattern module)