C中处理“循环初始化”的其他方法#

对于您的具体示例,有一个标准解决方案: string.Join

如果您真的想自己写这篇文章,您可以使用以下方法:

string delimiter = "";
foreach (var element in array)
{
    append(delimiter);
    append(element);
    delimiter = ",";
}

就我个人而言,我喜欢Mark Byer的选项,但您可以为此编写自己的通用方法:

public static void IterateWithSpecialFirst<T>(this IEnumerable<T> source,
    Action<T> firstAction,
    Action<T> subsequentActions)
{
    using (IEnumerator<T> iterator = source.GetEnumerator())
    {
        if (iterator.MoveNext())
        {
            firstAction(iterator.Current);
        }
        while (iterator.MoveNext())
        {
            subsequentActions(iterator.Current);
        }
    }
}

这相对简单。。。给一个特别的 最后的 行动稍难:

public static void IterateWithSpecialLast<T>(this IEnumerable<T> source,
    Action<T> allButLastAction,
    Action<T> lastAction)
{
    using (IEnumerator<T> iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
        {
            return;
        }            
        T previous = iterator.Current;
        while (iterator.MoveNext())
        {
            allButLastAction(previous);
            previous = iterator.Current;
        }
        lastAction(previous);
    }
}

编辑:由于您的评论关注的是这个问题的表现,我将在下面的回答中重申我的评论:虽然这个普遍的问题是相当常见的,但它是 不 确切地 代码需要做什么。

不过,总的来说,我重视可读性和可重用性 许多的

        using (var enumerator = array.GetEnumerator()) {
            if (enumerator.MoveNext()) {
                for (;;) {
                    append(enumerator.Current);
                    if (!enumerator.MoveNext()) break;
                    append(delimiter);
                }
            }
        }

你当然可以创造一个 goto null 支票):

string Join(string[] array, string delimiter) {
  var sb = new StringBuilder();
  var enumerator = array.GetEnumerator();
  if (enumerator.MoveNext()) {
    goto start;
    loop:
      sb.Append(delimiter);
      start: sb.Append(enumerator.Current);
      if (enumerator.MoveNext()) goto loop;
  }
  return sb.ToString();
}

为了你的 具体的 例如,在我看来,这看起来非常简单(这是您描述的解决方案之一):

string Join(string[] array, string delimiter) {
  var sb = new StringBuilder();
  foreach (string element in array) {
    sb.Append(element);
    sb.Append(delimiter);
  }
  if (sb.Length >= delimiter.Length) sb.Length -= delimiter.Length;
  return sb.ToString();
}

string Join(string[] array, string delimiter) {
  return array.Aggregate((left, right) => left + delimiter + right);
}

StringBuilder ,所以你可能想滥用 Aggregate

string Join(string[] array, string delimiter) {
  var sb = new StringBuilder();
  array.Aggregate((left, right) => {
    sb.Append(left).Append(delimiter).Append(right);
    return "";
  });
  return sb.ToString();
}

或者你也可以用这个(借用其他答案):

string Join(string[] array, string delimiter) {
  return array.
    Skip(1).
    Aggregate(new StringBuilder(array.FirstOrDefault()),
      (acc, s) => acc.Append(delimiter).Append(s)).
    ToString();
}

.First() 和 .Skip(1) 为了处理这个。。。这可以提供一个相对干净(并且非常可读)的解决方案。

append(array.First());
foreach(var x in array.Skip(1))
{
  append(delimiter);
  append (x);
}

[这假设数组中至少有一个元素,如果要避免的话,可以添加一个简单的测试。]

使用F#将是另一个建议:-)

有很多方法可以绕过双重代码,但是在大多数情况下,重复的代码比可能的解决方案要简单得多。你引用的“goto”解决方案在我看来并不是一种改进——我真的认为你并没有通过使用它获得任何显著的好处(紧凑性、可读性或效率),同时你增加了程序员在代码生命周期的某个时候出错的风险。

• 第一次(或最后一次)行动的特例
• 循环其他操作。

这消除了每次检查循环是否在第一次迭代中所带来的低效,而且非常容易理解。对于非常重要的情况,使用委托或助手方法应用操作可以最大限度地减少代码重复。

或者我有时在效率不重要的情况下使用的另一种方法:

这可以写得比goto方法更紧凑、更可读,并且不需要任何额外的变量/存储/测试来检测“特殊情况”iteraiton。

但我认为马克·拜尔斯的方法对于你的例子来说是一个很好的解决方案。

我更喜欢 first Length 把它和零比较。适用于 StringBuilder .

为什么不处理循环外的第一个元素呢?

StringBuilder sb = new StrindBuilder()
sb.append(array.first)
foreach (var elem in array.skip(1)) {
  sb.append(",")
  sb.append(elem)
}

如果你想走功能路线,你可以定义字符串。连接就像LINQ构造一样,它可以跨类型重用。

就我个人而言,我几乎总是追求代码的清晰性,而不是节省一些操作码执行。

如:

namespace Play
{
    public static class LinqExtensions {
        public static U JoinElements<T, U>(this IEnumerable<T> list, Func<T, U> initializer, Func<U, T, U> joiner)
        {
            U joined = default(U);
            bool first = true;
            foreach (var item in list)
            {
                if (first)
                {
                    joined = initializer(item);
                    first = false;
                }
                else
                {
                    joined = joiner(joined, item);
                }
            }
            return joined;
        }
    }

    class Program
    {

        static void Main(string[] args)
        {
            List<int> nums = new List<int>() { 1, 2, 3 };
            var sum = nums.JoinElements(a => a, (a, b) => a + b);
            Console.WriteLine(sum); // outputs 6

            List<string> words = new List<string>() { "a", "b", "c" };
            var buffer = words.JoinElements(
                a => new StringBuilder(a), 
                (a, b) => a.Append(",").Append(b)
                );

            Console.WriteLine(buffer); // outputs "a,b,c"

            Console.ReadKey();
        }

    }
}