有没有一种简单的方法可以将字符串重复X次？

我正在尝试根据项目深度在字符串之前插入一定数量的缩进，并且我想知道是否有办法返回重复X次的字符串。例：

string indent = "---";
Console.WriteLine(indent.Repeat(0)); //would print nothing.
Console.WriteLine(indent.Repeat(1)); //would print "---".
Console.WriteLine(indent.Repeat(2)); //would print "------".
Console.WriteLine(indent.Repeat(3)); //would print "---------".

如果只打算重复相同的字符，则可以使用接受char和重复次数的字符串构造函数new String(char c, int count)。

例如，要重复五次破折号：

string result = new String('-', 5);
Output: -----

如果您使用的是.NET 4.0，则可以string.Concat与一起使用Enumerable.Repeat。

int N = 5; // or whatever
Console.WriteLine(string.Concat(Enumerable.Repeat(indent, N)));

否则我会选择亚当的答案。

我通常不建议使用Andrey的答案的原因仅仅是，该ToArray()调用会引入多余的开销，StringBuilder而Adam提出的方法可以避免这种开销。就是说，至少它不需要.NET 4.0就可以工作。而且它既快捷又容易（如果效率不是您所关注的重点，那也不会杀死您）。

public static class StringExtensions
{
    public static string Repeat(this string input, int count)
    {
        if (!string.IsNullOrEmpty(input))
        {
            StringBuilder builder = new StringBuilder(input.Length * count);

            for(int i = 0; i < count; i++) builder.Append(input);

            return builder.ToString();
        }

        return string.Empty;
    }
}

最有效的弦乐解决方案

string result = new StringBuilder().Insert(0, "---", 5).ToString();

在许多情况下，这可能是最简洁的解决方案：

public static class StringExtensions
{
    public static string Repeat(this string s, int n)
        => new StringBuilder(s.Length * n).Insert(0, s, n).ToString();
}

用法是：

text = "Hello World! ".Repeat(5);

这基于其他答案（尤其是@ c0rd的答案）。除了简单之外，它还具有以下功能，并非所讨论的所有其他技术都具有这些功能：

• 重复任意长度的字符串，不仅是字符（应OP的要求）。
• StringBuilder通过存储预分配有效地使用。

如果所需的字符串仅包含一个字符，请使用String.PadLeft。

public static string Indent(int count, char pad)
{
    return String.Empty.PadLeft(count, pad);
}

此处应付款

您可以重复您的字符串（以防它不是单个字符）并合并结果，如下所示：

String.Concat(Enumerable.Repeat("---", 5))

我会去找Dan Tao的答案，但是如果您不使用.NET 4.0，则可以执行以下操作：

public static string Repeat(this string str, int count)
{
    return Enumerable.Repeat(str, count)
                     .Aggregate(
                        new StringBuilder(),
                        (sb, s) => sb.Append(s))
                     .ToString();
}

        string indent = "---";
        string n = string.Concat(Enumerable.Repeat(indent, 1).ToArray());
        string n = string.Concat(Enumerable.Repeat(indent, 2).ToArray());
        string n = string.Concat(Enumerable.Repeat(indent, 3).ToArray());

我喜欢给出的答案。沿着相同的路线，虽然是我过去使用的：

“” .PadLeft（3 * Indent，'-'）

这将完成缩进，但从技术上讲，问题是重复字符串。如果字符串缩进是>-<之类的内容，则此以及已接受的答案均不起作用。在这种情况下，c0rd使用stringbuilder的解决方案看起来不错，尽管stringbuilder的开销实际上可能不会使其性能最高。一种选择是建立一个字符串数组，用缩进字符串填充它，然后进行连接。白衣：

int Indent = 2;

string[] sarray = new string[6];  //assuming max of 6 levels of indent, 0 based

for (int iter = 0; iter < 6; iter++)
{
    //using c0rd's stringbuilder concept, insert ABC as the indent characters to demonstrate any string can be used
    sarray[iter] = new StringBuilder().Insert(0, "ABC", iter).ToString();
}

Console.WriteLine(sarray[Indent] +"blah");  //now pretend to output some indented line

我们都喜欢一个聪明的解决方案，但有时候简单是最好的。

添加扩展方法我正在使用所有项目：

public static string Repeat(this string text, int count)
{
    if (!String.IsNullOrEmpty(text))
    {
        return String.Concat(Enumerable.Repeat(text, count));
    }
    return "";
}

希望有人可以使用它...

惊讶的是没人上过老派。我没有对这段代码提出任何要求，只是为了好玩：

public static string Repeat(this string @this, int count)
{
    var dest = new char[@this.Length * count];
    for (int i = 0; i < dest.Length; i += 1)
    {
        dest[i] = @this[i % @this.Length];
    }
    return new string(dest);
}

不知道这将如何执行，但这是一段简单的代码。（我可能使它看起来比实际更复杂。）

int indentCount = 3;
string indent = "---";
string stringToBeIndented = "Blah";
// Need dummy char NOT in stringToBeIndented - vertical tab, anyone?
char dummy = '\v';
stringToBeIndented.PadLeft(stringToBeIndented.Length + indentCount, dummy).Replace(dummy.ToString(), indent);

另外，如果您知道可以期望的最大级别数，则可以声明一个数组并对其进行索引。您可能希望将此数组设为静态或常量。

string[] indents = new string[4] { "", indent, indent.Replace("-", "--"), indent.Replace("-", "---"), indent.Replace("-", "----") };
output = indents[indentCount] + stringToBeIndented;      

我没有足够的代表评论亚当的答案，但是imo的最佳方法是这样的：

public static string RepeatString(string content, int numTimes) {
        if(!string.IsNullOrEmpty(content) && numTimes > 0) {
            StringBuilder builder = new StringBuilder(content.Length * numTimes);

            for(int i = 0; i < numTimes; i++) builder.Append(content);

            return builder.ToString();
        }

        return string.Empty;
    }

您必须检查numTimes是否大于零，否则将获得异常。

我没有看到这个解决方案。对于目前在软件开发中的位置，我发现它更简单：

public static void PrintFigure(int shapeSize)
{
    string figure = "\\/";
    for (int loopTwo = 1; loopTwo <= shapeSize - 1; loopTwo++)
    {
        Console.Write($"{figure}");
    }
}

对于一般用途，涉及StringBuilder类的解决方案最适合重复多字符字符串。它经过优化，可以处理简单的串联无法实现的大量字符串的组合，而手工连接将很难或不可能高效地进行。此处显示的StringBuilder解决方案使用O（N）迭代来完成，此固定比率与重复的次数成正比。

但是，对于大量重复，或必须从中挤出高效率的情况，一种更好的方法是执行类似于StringBuilder基本功能的操作，但要从目标而不是从原始字符串中产生其他副本，如下。

    public static string Repeat_CharArray_LogN(this string str, int times)
    {
        int limit = (int)Math.Log(times, 2);
        char[] buffer = new char[str.Length * times];
        int width = str.Length;
        Array.Copy(str.ToCharArray(), buffer, width);

        for (int index = 0; index < limit; index++)
        {
            Array.Copy(buffer, 0, buffer, width, width);
            width *= 2;
        }
        Array.Copy(buffer, 0, buffer, width, str.Length * times - width);

        return new string(buffer);
    }

这样，每次迭代都会使源/目标字符串的长度加倍，从而节省了每次通过原始字符串时重置计数器的开销，而无需平滑地读取并复制现在更长的字符串，这是现代处理器可以做的事情更有效率。

它使用以2为底的对数来查找需要将字符串长度加倍的次数，然后进行多次。由于现在要复制的其余部分小于要复制的总长度，因此它可以简单地复制已生成内容的子集。

我已经在使用StringBuilder时使用了Array.Copy（）方法，因为将StringBuilder的内容复制到自身中会产生开销，每次迭代都会产生一个包含该内容的新字符串。Array.Copy（）避免了这种情况，同时仍然以极高的效率运行。

该解决方案需要O（1 + log N）次迭代才能完成，该速率与重复次数成对数增加（重复次数增加一倍等于一个额外的迭代），与其他方法相比节省了大量资金，而其他方法则按比例增加。

另一种方法是考虑string作为 IEnumerable<char>和有一个通用的扩展方法，这将通过指定的系数乘以一个集合中的项目。

public static IEnumerable<T> Repeat<T>(this IEnumerable<T> source, int times)
{
    source = source.ToArray();
    return Enumerable.Range(0, times).SelectMany(_ => source);
}

因此，在您的情况下：

string indent = "---";
var f = string.Concat(indent.Repeat(0)); //.NET 4 required
//or
var g = new string(indent.Repeat(5).ToArray());

重复打印一行。

Console.Write(new string('=', 30) + "\n");

=============================

您可以创建一个ExtensionMethod来做到这一点！

public static class StringExtension
{
  public static string Repeat(this string str, int count)
  {
    string ret = "";

    for (var x = 0; x < count; x++)
    {
      ret += str;
    }

    return ret;
  }
}

或使用@Dan Tao解决方案：

public static class StringExtension
{
  public static string Repeat(this string str, int count)
  {
    if (count == 0)
      return "";

    return string.Concat(Enumerable.Repeat(indent, N))
  }
}