C＃ - 用于迭代谓词的模式 [英] C# - Pattern for iterating over predicates

问题描述

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

如下：

 列表<元素> listOfPossibleResults = getAllPossibleResults（）; 
 
元素result = findResult（getFirstPriorityElements（listOfPossibleResults））; 
 if（result！= null）
 {
 return result; 
} 
 
 result = findResult（getSecondPriorityElements（listOfPossibleResults））; 
 if（result！= null）
 {
 return result; 
} 
 
 private元素findResult（List< Element> elements）{...}; 
 private List< Element> getFirstPriorityElements（List< Element> elements）{...}; 
 private List< Element> getSecondPriorityElements（List< Element> elements）{...}; 
  

等..

我根据几个规则创建子列表。创建子列表后，我尝试找到一个特定的元素。如果我找不到，我继续下一个优先事项，等等。

我想要一个解决方案，我可以迭代这些标准，直到我找到一个解决方案。但是我不知道如何让它们能够重复一个格式。

你能给我一个C＃的具体解决方案吗？

解决方案

正如@Lepijohnny所说，你可以使用责任链模式。例如：

 抽象类处理程序< TRequest，TResult> 
 {
 protected Handler< TRequest，TResult>接班人; 
 
 public void SetSuccessor（Handler< TRequest，TResult> successor）
 {
 this.successor = successor; 
} 
 
 public abstract TResult HandleRequest（TRequest request）; 
} 
 
 class FirstHandler：Handler< List< Element>元素> 
 {
 public override void HandleRequest（TRequest request）
 {
元素result = findResult（getFirstPriorityElements（request））; 
 if（result == null）
 {
 result = sucessor？.HandleRequest（request）; 
} 
返回结果; 
} 
 
 private元素findResult（List< Element> elements）{...}; 
 private List< Element> getFirstPriorityElements（List< Element> elements）{...}; 
} 
 
 class SecondHandler：Handler< List< Element>元素> 
 {
 public override void HandleRequest（TRequest request）
 {
元素result = findResult（getSecondPriorityElements（request））; 
 if（result == null）
 {
 result = sucessor？.HandleRequest（request）; 
} 
返回结果; 
} 
 
 private元素findResult（List< Element> elements）{...}; 
 private List< Element> getSecondPriorityElements（List< Element> elements）{...}; 
} 
  

用法：

  void Example（）
 {
 //设置责任链
 var h1 = new FirstHandler（）; 
 var h2 = new SecondHandler（）; 
 h1.SetSuccessor（h2）; 
 
 var result = h1.Handle（new List< Element>（））; 
} 
  

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

I made a pattern which i dont really like.

It is as the following:

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) {...};

etc..

Basically i'am creating sublists based on a couple of rules. After creating the sublist, i try and find a specific element in it. If i dont find, i move on to the next priority, and so on.

I would like a solution where i can iterate over these criterias, until i find a solution. But i dont know how to get them to a format which i can iterate over.

Can you guys give me a C# specific solution of the issue?

解决方案

As @Lepijohnny mentioned, you can use Chain of responsibility design pattern. For example:

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) {...};
}

Usage:

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

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

It's a just quick example. I think it describe how this pattern works and you will be able to adjust it for your needs.

这篇关于C＃ - 用于迭代谓词的模式的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！