那么这个呢:

string tabs = new string('\t', n);

其中n是你想要重复字符串的次数。

或更好:

static string Tabs(int n)
{
    return new string('\t', n);
}

最好的版本当然是使用内置的方式:

string Tabs(int len) { return new string('\t', len); }

在其他解决方案中，选择最简单的;只有当这被证明太慢的时候，努力寻找一个更有效的解决方案。

如果您使用StringBuilder并提前知道其结果长度，那么还可以使用适当的构造函数，这将更加高效，因为这意味着只进行一次耗时的分配，并且没有不必要的数据复制。 废话:当然上面的代码更有效。

使用扩展方法怎么样?

public static class StringExtensions
{
   public static string Repeat(this char chatToRepeat, int repeat) {

       return new string(chatToRepeat,repeat);
   }
   public  static string Repeat(this string stringToRepeat,int repeat)
   {
       var builder = new StringBuilder(repeat*stringToRepeat.Length);
       for (int i = 0; i < repeat; i++) {
           builder.Append(stringToRepeat);
       }
       return builder.ToString();
   }
}

你可以这样写:

Debug.WriteLine('-'.Repeat(100)); // For Chars  
Debug.WriteLine("Hello".Repeat(100)); // For Strings

注意，使用stringbuilder版本来处理简单字符而不是字符串的性能测试会给你带来很大的性能损失: 在我的电脑上，测量的性能差异是1:20: Debug.WriteLine('-'.Repeat(1000000)) //char版本 Debug.WriteLine("-".Repeat(1000000)) //字符串版本

在所有版本的。net中，你都可以这样重复一个字符串:

public static string Repeat(string value, int count)
{
    return new StringBuilder(value.Length * count).Insert(0, value, count).ToString();
}

要重复一个字符，new String('\t'， count)是最好的选择。请看@CMS的回答。

答案取决于你想要的复杂度。例如，我想用竖条勾勒出我所有的缩进，所以我的缩进字符串是这样确定的:

return new string(Enumerable.Range(0, indentSize*indent).Select(
  n => n%4 == 0 ? '|' : ' ').ToArray());

扩展方法:

public static string Repeat(this string s, int n)
{
    return new String(Enumerable.Range(0, n).SelectMany(x => s).ToArray());
}

public static string Repeat(this char c, int n)
{
    return new String(c, n);
}

第一个使用Enumerable的例子。重复一遍:

private string Tabs(uint numTabs)
{
    IEnumerable<string> tabs = Enumerable.Repeat(
                                 "\t", (int) numTabs);
    return (numTabs > 0) ? 
            tabs.Aggregate((sum, next) => sum + next) : ""; 
} 

可以用String更紧凑地重写。合并多个数组:

private string Tabs(uint numTabs)
{       
    return String.Concat(Enumerable.Repeat("\t", (int) numTabs));
}

这个怎么样:

//Repeats a character specified number of times
public static string Repeat(char character,int numberOfIterations)
{
    return "".PadLeft(numberOfIterations, character);
}

//Call the Repeat method
Console.WriteLine(Repeat('\t',40));

string.Concat(Enumerable.Repeat("ab", 2));

返回

“阿巴”

And

string.Concat(Enumerable.Repeat("a", 2));

返回

“啊”

从…

.net中是否有重复字符串或char的内置函数?

使用字符串。Concat和Enumerable。重复这样做会更便宜 而不是使用String。加入

public static Repeat(this String pattern, int count)
{
    return String.Concat(Enumerable.Repeat(pattern, count));
}

假设你想重复'\t' n次，你可以使用;

String.Empty.PadRight(n,'\t')

var str = new string(Enumerable.Repeat('\t', numTabs).ToArray());

我知道这个问题已经存在5年了，但是有一种简单的方法可以重复一个字符串，甚至在。net 2.0中也可以工作。

重复一个字符串:

string repeated = new String('+', 3).Replace("+", "Hello, ");

返回

“你好，你好，你好。”

将字符串作为数组重复使用:

// Two line version.
string repeated = new String('+', 3).Replace("+", "Hello,");
string[] repeatedArray = repeated.Split(',');

// One line version.
string[] repeatedArray = new String('+', 3).Replace("+", "Hello,").Split(',');

返回

{"Hello"， "Hello"， "Hello"， ""}

保持简单。

试试这个:

加入微软。VisualBasic参考 String result = Microsoft.VisualBasic.Strings.StrDup(5，"hi"); 如果对你有用，请告诉我。

还有另一种方法

new System.Text.StringBuilder().Append('\t', 100).ToString()

您可以创建一个扩展方法

static class MyExtensions
{
    internal static string Repeat(this char c, int n)
    {
        return new string(c, n);
    }
}

然后你可以这样使用它

Console.WriteLine('\t'.Repeat(10));

对我来说很好:

public static class Utils
{
    public static string LeftZerosFormatter(int zeros, int val)
    {
        string valstr = val.ToString();

        valstr = new string('0', zeros) + valstr;

        return valstr.Substring(valstr.Length - zeros, zeros);
    }
}

毫无疑问，公认的答案是重复单个字符的最佳和最快的方法。

Binoj Anthony的答案是一种简单而有效的重复字符串的方法。

但是，如果您不介意多写一些代码，您可以使用我的数组填充技术来高效地更快地创建这些字符串。在我的比较测试中，下面的代码只执行了StringBuilder 35%的时间。插入的代码。

public static string Repeat(this string value, int count)
{
    var values = new char[count * value.Length];
    values.Fill(value.ToCharArray());
    return new string(values);
}

public static void Fill<T>(this T[] destinationArray, params T[] value)
{
    if (destinationArray == null)
    {
        throw new ArgumentNullException("destinationArray");
    }

    if (value.Length > destinationArray.Length)
    {
        throw new ArgumentException("Length of value array must not be more than length of destination");
    }

    // set the initial array value
    Array.Copy(value, destinationArray, value.Length);

    int copyLength, nextCopyLength;

    for (copyLength = value.Length; (nextCopyLength = copyLength << 1) < destinationArray.Length; copyLength = nextCopyLength)
    {
        Array.Copy(destinationArray, 0, destinationArray, copyLength, copyLength);
    }

    Array.Copy(destinationArray, 0, destinationArray, copyLength, destinationArray.Length - copyLength);
}

有关此数组填充技术的更多信息，请参见用单个值填充数组的最快方法

虽然与之前的建议非常相似，但我喜欢保持简单，并应用以下内容:

string MyFancyString = "*";
int strLength = 50;
System.Console.WriteLine(MyFancyString.PadRight(strLength, "*");

标准的。net，

用6435个z填满屏幕 $str = [System.Linq.]::Repeat([string]::new("z"， 143)， 45)

$str

        string input = "abc"
        string output = "";
        for (int i = 0; i < input.Length; i++)
        {
            output += input[i].ToString() + input[i].ToString();
         
       }
        Console.WriteLine( output);

/ /输出= aabbcc