Question

可能重复：
Extension method for Enumerable.Intersperse?

我有List<string>这样：

"foo", "bar", "cat"

我希望它看起来像这样：

"foo", "-", "bar", "-", "cat"

是否有C＃方法可以做到这一点？

Answer 1

您可以制作一个返回带有散布项目的IEnumerable<T>的扩展程序：

public static class ListExtensions {

  public static IEnumerable<T> Intersperse<T>(this IEnumerable<T> items, T separator) {
    bool first = true;
    foreach (T item in items) {
      if (first) {
        first = false;
      } else {
        yield return separator;
      }
      yield return item;
    }
  }

}

这样做的好处是您不必使用额外的项目来混乱您的列表，您可以在返回时使用它：

List<string> words = new List<string>() { "foo", "bar", "cat" };

foreach (string s in words.Intersperse("-")) {
  Console.WriteLine(s);
}

如果您需要，您当然可以将结果作为列表获取：

words = words.Intersperse("-").ToList();

Answer 2

Here是我个人工具箱中的一个实现。它比你需要的更通用。

对于您的特定示例，您可以编写

var list = new List<string> { "foo", "bar", "cat" };
var result = list.InterleaveWith(Enumerable.Repeat("-", list.Count - 1));

<强> See it in action

Answer 3

是的，它是你要编写的自定义方法：

List<string> AddDashesToList(List<string> list)
{
    if(list.Count > 1)
    { 
        var newList = new List<string>();

        foreach(item in list)
        {
           newList.Add(item);
           newList.Add("-");
        }

        newList.RemoveAt(newList.Count-1);

        return newList;
    }
    else
    {
         return list;
    }
}

Answer 4

       public  List<string> GetNewList(List<string> list, string s)
    {
        var result = new List<string>();
        foreach (var l in list)
        {
            result.Add(l);
            result.Add(s);
        }
        result.RemoveAt(result.Count - 1);
        return result;
    }

您可以使用此方法获取列表

var result =   GetNewList(str,"-");

Answer 5

哈！我刚刚为此目的写了一些东西！

    public static IEnumerable<T> Interleave<T>(params IEnumerable<T>[] arrays)
    {
        var enumerators = arrays.Select(array => array.GetEnumerator()).ToArray();
        var finished = true;
        do
        {
            finished = true;
            foreach (var enumerator in enumerators)
            {
                if (enumerator.MoveNext())
                {
                    yield return enumerator.Current;
                    finished = false;
                }
            }
        } while (finished == false);
    }

这将按您选择的顺序交错指定的可枚举数。然后你只需用破折号填充一个枚举，然后将其与原始数组交错。它也可以做更复杂的事情。

Answer 6

前段时间我为这种事写了一个扩展方法：

public static IEnumerable<T> 
    Join<T>(this IEnumerable<T> src, Func<T> separatorFactory)
{
    var srcArr = src.ToArray();
    for (int i = 0; i < srcArr.Length; i++)
    {
        yield return srcArr[i];
        if(i<srcArr.Length-1)
        {
            yield return separatorFactory();
        }
    }
}

您可以按如下方式使用它：

myList.Join(() => "-").ToList()

Answer 7

修改

正如所指出的，我之前的代码导致字符串不是字符串数组。所以这是我编辑的代码：

var list = new List<string> { "foo", "bar", "cat" }; var result = string.Join("-", list.Select(x => x.ToString()).ToArray()); string pattern = "(-)"; string[] test = Regex.Split(result, pattern); foreach(var str in test) Console.WriteLine(str);

保留旧代码以进行比较：

var list = new List<string> { "foo", "bar", "cat" }; var result = string.Join("-", list.Select(x => x.ToString()).ToArray()); Console.WriteLine(result); // prints "foo-bar-cat

请参阅此post。干杯！

散布列表＆lt;＆gt;

7 个答案: