在C＃中重复字符的最佳方法

\t在C＃中生成字符串s 的最佳方法是什么

我正在学习C＃，并尝试用不同的方式说同一件事。

Tabs(uint t)是一个函数，它返回一个string带有t的量\t的

例如Tabs(3)回报"\t\t\t"

这三种实施方式中哪Tabs(uint numTabs)一种最佳？

当然，这取决于“最佳”的含义。

1. LINQ版本只有两行，这很好。但是，重复和聚合的调用是否不必要地浪费时间/资源？

2. 该StringBuilder版本是很清楚的，但是是StringBuilder类莫名其妙慢？

3. 该string版本是基本版本，这意味着它易于理解。

4. 没关系吗？他们都平等吗？

这些都是可以帮助我更好地理解C＃的问题。

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

private string Tabs(uint numTabs)
{
    StringBuilder sb = new StringBuilder();
    for (uint i = 0; i < numTabs; i++)
        sb.Append("\t");

    return sb.ToString();
}  

private string Tabs(uint numTabs)
{
    string output = "";
    for (uint i = 0; i < numTabs; i++)
    {
        output += '\t';
    }
    return output; 
}

那这个呢：

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

哪里n是您要重复字符串的次数。

或更好：

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

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

退货

“阿巴布”

和

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

退货

“ aa”

从...

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

在.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的答案。

最好的版本肯定是使用内置方式：

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

在其他解决方案中，首选最简单的解决方案。仅在证明速度太慢的情况下，才应寻求更有效的解决方案。

如果您使用a StringBuilder并事先知道其结果长度，然后还使用适当的构造函数，则效率会高得多，因为这意味着只会进行一次耗时的分配，而不会进行不必要的数据复制。 废话：当然，上面的代码更有效。

扩展方法：

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

使用扩展方法呢？

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））//字符串版本

这个怎么样：

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

我知道这个问题已经有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(',');

退货

{“你好你好你好”， ””}

把事情简单化。

假设您要重复n次，可以使用；

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

您的第一个示例使用Enumerable.Repeat：

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

可以使用以下命令更紧凑地重写String.Concat：

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

使用String.Concat，Enumerable.Repeat并且比使用便宜String.Join

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

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

答案确实取决于您想要的复杂性。例如，我想用竖线勾勒出所有缩进，因此我的缩进字符串确定如下：

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

还有另一种方法

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

对我来说很好：

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

您可以创建扩展方法

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

那你可以这样用

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

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

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

但是，如果您不介意更多代码，则可以使用我的数组填充技术来更快地有效创建这些字符串。在我的比较测试中，下面的代码执行时间大约是StringBuilder.Insert代码的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);
}

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

尝试这个：

1. 添加Microsoft.VisualBasic参考
2. 使用：字符串结果= Microsoft.VisualBasic.Strings.StrDup（5，“ hi”）;
3. 请让我知道这对你有没有用。

尽管与先前的建议非常相似，但我希望保持简单并应用以下内容：

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

真正的标准.Net