C# 散布一份清单<&燃气轮机；

可能重复：

我有这样一个

列表

：

“foo”、“bar”、“cat”

我希望它看起来像这样：

“foo”、“-”、“bar”、“-”、“cat”

---

有没有一种C#方法可以做到这一点？

是的，这是一种自定义方法，您可以编写：

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;
    }
}

List AddDashesToList（列表列表）
{
如果（list.Count>1）
{ 
var newList=新列表（）；
foreach（列表中的项目）
{
新建列表。添加（项）；
新列表。添加（“-”）；
}
newList.RemoveAt（newList.Count-1）；
返回newList；
}
其他的
{
退货清单；
}
}

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

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

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

var list=新列表{“foo”、“bar”、“cat”}；
var result=list.InterleaveWith（Enumerable.Repeat（“-”，list.Count-1））；

---

哈哈！我只是为了这个目的写了一些东西

       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;
    }

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

公共静态IEnumerable交织（params IEnumerable[]数组）
{
var enumerators=arrays.Select（array=>array.GetEnumerator（））.ToArray（）；
var finished=true；
做
{
完成=正确；
foreach（枚举器中的变量枚举器）
{
if（枚举数.MoveNext（））
{
产生返回枚举数。当前；
完成=错误；
}
}
}while（finished==false）；
}

这将按照您选择的顺序交错指定的枚举。

---

然后用破折号填充一个可枚举项，并将其与原始数组交错。它还可以做更复杂的事情。

不久前，我为这类事情编写了一个扩展方法：

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();
        }
    }
}

---

您可以创建一个扩展，该扩展返回带有散布项的

IEnumerable

：

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;
    }
  }

}

编辑：

如前所述，我前面的代码生成的是字符串，而不是字符串数组。下面是我编辑的代码：

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=新列表{“foo”、“bar”、“cat”}；
var result=string.Join（“-”，list.Select（x=>x.ToString（））.ToArray（））；
字符串模式=（-）；
string[]test=Regex.Split（结果、模式）；
foreach（测试中的var str）
控制台写入线（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

var list=新列表{“foo”、“bar”、“cat”}；
var result=string.Join（“-”，list.Select（x=>x.ToString（））.ToArray（））；
Console.WriteLine（结果）；//打印“foo-bar-cat”

---

参考这个。干杯！

看前面的问题-[1]：不，你必须自己写。为什么需要这个？你想用-来打印值吗？那么可能有更简单的方法。@PoweRoy:因为我喜欢将字符串函数链接在一行中，比如

string.Trim（）.Split（'，'）[0]。点缀（“-”）

@Paige该链接包含优于此问题的答案和列表末尾的额外破折号：）另一点：如果

list

method参数为空

foreach

将被忽略，但

RemoveAt（-1）

将引发异常？；）再次感谢。My bad.Fixed。很抱歉，当Items.Coutn==1时，方法仍返回额外的破折号？再次更正。现在应修复=）这将生成字符串，而不是数组strings@MerickOWA代码更新。谢谢你纠正我。

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

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

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

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