c# - 如何迭代数组/集合/列表中的 "between"项？

Question

这个问题困扰了我很多年，当有更好的解决方案时，我总是觉得自己想出了一个 hack。当您想对列表中的所有项目执行某项操作，然后在这些项目之间 添加一些内容时，就会出现手头的问题。简而言之，我想:

• 对列表中的每个 项目做一些事情。
• 对列表中的除最后一项 做一些其他事情(实际上，在列表中的各项“之间”做一些事情)。

---

例如，假设我有一个名为 Equation 的类:

public class Equation
{
    public string LeftSide { get; set; }
    public string Operator { get; set; }
    public string RightSide { get; set; }
}

我想遍历 Equation 的列表并返回一个将这些项格式化在一起的字符串；类似于以下内容:

public string FormatEquationList(List<Equation> listEquations)
{
    string output = string.Empty;
    foreach (Equation e in listEquations)
    {
        //format the Equation
        string equation = "(" + e.LeftSide + e.Operator + e.RightSide + ")";

        //format the "inbetween" part
        string inbetween = " and ";

        //concatenate the Equation and "inbetween" part to the output
        output += equation + inbetween;
    }
    return ouput;
}

上述代码的问题在于它将在返回字符串的末尾包含 和 。我知道我可以一起破解一些代码，将 foreach 替换为 for 循环，并仅在 inbetween 元素不是最后一个时才添加它元素;但这似乎是一个黑客。

是否有处理此类问题的标准方法？

Answer 1

处理这类问题基本上有几种不同的策略:

1. 处理循环外的第一个(或最后一个)项目。
2. 执行工作，然后“撤消”多余的步骤。
3. 检测您正在处理循环内的第一项或最后一项。
4. 使用更高级别的抽象来避免这种情况。

这些选项中的任何一个都可以是实现“项目之间”风格算法的合法方式。您选择哪一个取决于以下因素:

• 你喜欢哪种风格
• “撤消工作”有多昂贵
• 每个“加入”步骤的成本是多少
• 有无副作用

除其他事项外。对于字符串的特定情况，我个人更喜欢使用 string.Join()，因为我发现它最清楚地说明了意图。此外，对于字符串，如果您不使用 string.Join()，您应该尝试使用 StringBuilder 以避免创建太多临时字符串(结果字符串在 .Net 中是不可变的)。

以字符串连接为例，不同的选项分解为如下示例。 (为简单起见，假设 Equation 的 ToString() 为:"("+ LeftSide + Operator + RightSide + ")"

public string FormatEquation( IEnumerable<Equation> listEquations )
{
    StringBuilder sb = new StringBuilder();

    if( listEquations.Count > 0 )
        sb.Append( listEquations[0].ToString() );
    for( int i = 1; i < listEquations.Count; i++ )
        sb.Append( " and " + listEquations[i].ToString() );
    return sb.ToString();
}

第二个选项看起来像:

public string FormatEquation( IEnumerable<Equation> listEquations )
{
    StringBuilder sb = new StringBuilder();
    const string separator = " and ";
    foreach( var eq in listEquations )
        sb.Append( eq.ToString() + separator );
    if( listEquations.Count > 1 )
        sb.Remove( sb.Length, separator.Length );
}

第三个看起来像:

public string FormatEquation( IEnumerable<Equation> listEquations )
{
    StringBuilder sb = new StringBuilder();
    const string separator = " and ";
    foreach( var eq in listEquations )
    {
        sb.Append( eq.ToString() );
        if( index == list.Equations.Count-1 )
            break;
        sb.Append( separator );
    }
}

最后一个选项在 .NET 中可以采用多种形式，使用 String.Join 或 Linq:

public string FormatEquation( IEnumerable<Equation> listEquations )
{
    return string.Join( " and ", listEquations.Select( eq => eq.ToString() ).ToArray() );
}

或:

public string FormatEquation( IEnumerable<Equation> listEquations ) 
{
    return listEquations.Aggregate((a, b) => a.ToString() + " and " + b.ToString() );
}

就个人而言，我避免使用 Aggregate() 进行字符串连接，因为它会产生许多中间的、被丢弃的字符串。它也不是将一堆结果“连接”在一起的最明显的方法 - 它主要用于以某种任意的、调用者定义的方式从集合中计算“标量”结果。