如何重写 bool TrySomething(List<T> items, out List<T> itemsThatFailed)

Question

我有这个功能：

bool TrySomething(IEnumerable<T> items, out List<T> listOfProblemItems)
{
    //...

    return listOfProblemItems != null && listOfProblemItems.Count > 0;
}

现在的工作方式与您对“TrySomething”模式的预期相反（例如TryParse）：

如果出现问题，它会返回true（表示out 参数已填充了信息）。所以我可以这样称呼它：

if(TrySomething(items, out problemItems))
{
   //handle problems
   //"but.. it returned 'true'! Why are there problems? I'm confused."
}

如果有问题返回true 并不直观，但如果我将其更改为false，那么out 参数将填充false 上的信息，从而打破“TrySomething”模式。

if(TrySomething(items, out problemItems) == false)
{
   //handle problems
   //"the 'out' parameter is used? but it returned false! I'm confused."
}

我不是抛出异常的替代方法，因为这是一个高性能部件，我需要一个明确定义的列表，列出哪些项目无论如何都失败了。

我可以将它返回问题列表并将其命名为TrySomethingAndReturnAnyProblems，但是这个名字很难看，调用代码必须检查返回的列表是否为空和计数，我' d 宁愿在函数中完成，因为无论如何它总是必须完成。

List<T> problems = TrySomethingAndReturnAnyProblems(items);
if(problems != null && problems.Count > 0)
{
    //ugly and introduces duplicate code every time the function is used.
}

如何在保持“TrySomething”模式的简洁性的同时将其变成可读的、自记录的函数定义？

Answer 1

编写一个扩展方法来简单地过滤掉有问题的项目怎么样？这样，您只能取回正常的项目，例如：

public static IEnumerable<T> ExceptProblematic(this IEnumerable<T> items)
{
  foreach (var item in items)
  {
    if (!IsProblematic(item))
      yield return item;
  }
}

这样你可以像这样使用它：

var validItems = items.ExceptProblematic();

或者，您可以编写一个查询以仅返回有问题的项目，然后进行另一个查询以将它们过滤掉，例如：

var problemItems = items.Where(item => IsProblematic(item));
var validItems = items.Except(problemItems);

然后相应地处理问题项：

if (problemItems.Any()) 
{
   // handle problem items
}

Answer 2

如何创建一个具有bool Success 和T Data 属性的Result<T> 类？

class Result<T>
{
     public bool Success {get; set;}
     public T Data {get; set;}
}

然后让TrySomething返回Result<List<T>>

Result<List<T>> result = TrySomething(enumerable);
if (!result.Success)
{
    List<T> problematicItems = result.Data;
    //...
}

Answer 3

我宁愿为结果创建一个特殊的类（参见 Ahmed KRAIEM 的回答） 但我会以一些不同的（精心设计的）方式来做：

  public sealed class SomeResultWithDescription<TItem>: IReadOnlyList<TItem> {
    private List<TItem> m_Problems;
    private Boolean m_Success = true; // <- the field may be redundant 

    // may be redundant: if there's no situation when the result is falure
    // even if there're no problems enlisted
    internal SomeResultWithDescription(List<TItem> problems, Boolean success)
      : this(problems) {

      m_Success = success;
    }

    internal SomeResultWithDescription(List<TItem> problems)
      : base() {

      if (Object.ReferenceEquals(null, problems))
        m_Problems = new List<TItem>();
      else
        m_Problems = problems;
    }

    public IReadOnlyList<TItem> Problems {
      get {
        return m_Problems;
      }
    }

    public Boolean Success {
      get {
        if (!m_Success)
          return false;
        else if (m_Problems.Count > 0)
          return false;

        return true;
      }
    }

    public Boolean ToBoolean() {
      return Success;
    }

    public static implicit operator Boolean(SomeResultWithDescription<TItem> value) {
      if (Object.ReferenceEquals(null, value))
        return false;

      return value.ToBoolean();
    }

    public TItem this[int index] {
      get {
        return m_Problems[index];
      }
    }

    public int Count {
      get {
        return m_Problems.Count;
      }
    }

    public IEnumerator<TItem> GetEnumerator() {
      return m_Problems.GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
      return m_Problems.GetEnumerator();
    }
  }

  ...

  // Your method will be
  SomeResultWithDescription<T> TrySomething(IEnumerable<T> items)
  {
    //...

    return new SomeResultWithDescription<T>(listOfProblemItems);
  }

  // So you can do
  // 1. Just do if no problems detected
  if (TrySomething(items)) { 
    ...
  }

  // 2. Do if no problems, analyze if there're problems
  var result = TrySomething(items);

  if (result) { 
    ... // no problems
  }
  else { // <- some problems to analyze
    foreach (var problem in result) {
      ...
    }
  }

Answer 4

如果你担心打破TryX 模式，你为什么不编一个：

public bool AntiTrySomething(IEnumerable<T> input, out IEnumerable<T> fails)
{
    // implement me - return true if fail
}

只要您在整个代码库中保持一致，我认为这样的事情就很清楚，并且足以将您与“标准”区分开来，在保持熟悉的同时不会与它发生冲突。