Best way to repeat a character in C#

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

Returns

"abab"

And

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

Returns

"aa"

from...

Is there a built-in function to repeat string or char in .net?

In all versions of .NET, you can repeat a string thus:

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

To repeat a character, new String('\t', count) is your best bet. See the answer by @CMS.

The best version is certainly to use the builtin way:

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

Of the other solutions, prefer the easiest; only if this is proving too slow, strive for a more efficient solution.

If you use a StringBuilder and know its resulting length in advance, then also use an appropriate constructor, this is much more efficient because it means that only one time-consuming allocation takes place, and no unnecessary copying of data. Nonsense: of course the above code is more efficient.

Extension methods:

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

Use an extension method:

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

You could then write:

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

Note that a performance test of using the StringBuilder version for simple characters instead of strings gives you a major performance penality:

On my computer the difference in measured performance is 1:20 between:

Debug.WriteLine('-'.Repeat(1000000)) // Char version 

and

Debug.WriteLine("-".Repeat(1000000)) // String version 

Let's say you want to repeat '\t' n number of times, you can use;

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

How about this:

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

There is a simple way to repeat a string that even works in .NET 2.0.

To repeat a string:

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

Returns

"Hello, Hello, Hello, "

To repeat a string as an array:

// 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(','); 

Returns

{"Hello", "Hello", "Hello", ""}

Keep it simple.

Your first example which uses Enumerable.Repeat:

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

can be rewritten more compactly with String.Concat:

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

Using String.Concat and Enumerable.Repeat which will be less expensive than using 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()); 

The answer really depends on the complexity you want. For example, I want to outline all my indents with a vertical bar, so my indent string is determined as follows:

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

And yet another method

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

You can create an extension method

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

Then you can use it like this

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

For me this is fine:

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

Without a doubt the accepted answer is the best and fastest way to repeat a single character.

Binoj Anthony's answer is a simple and quite efficient way to repeat a string.

However, if you don't mind a little more code, you can use my array fill technique to efficiently create these strings even faster. In my comparison tests, the code below executed in about 35% of the time of the StringBuilder.Insert code.

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

For more about this array fill technique, see Fastest way to fill an array with a single value

Albeit very similar to a previous suggestion, I like to keep it simple and apply the following:

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

It is standard .NET, really.

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

Output:

=aabbcc 

In case using spans are an option to be considered here, since the heap allocations will be reduced since we operate on the stack instead, here is a method for also doing char repeats using Span:

void Main() { if (numTabs < 0) { throw new ArgumentException($"{nameof(numTabs)} : Must be a positive number or zero"); } string eightTabs = Tabs(4); Console.WriteLine($"Here is your tabs:{eightTabs} . Did you like them?"); } private string Tabs(int numTabs){ Span<char> span = new Span<char>(new char[numTabs]); var tabSpan = "\t".AsSpan(); for (int i = 0; i < numTabs; i++) { tabSpan.CopyTo(span.Slice(i, 1)); } return span.ToString(); } 

This is however a more complex solution to a very trivial programming task that probably will not need such optimization. But in the case you would repeat tabs several tens of thousands of times, it could have its use.

One example with string extension:

/// <summary> /// Multiply text x times and return it as string array /// if merge enabled, merge array items in to one string /// <code> /// @example /// var arr = "ab".Repeat(3, false); > out: {"ab", "ab", "ab"}; /// var str = "ab".Repeat(3, true)[0]; > out: "ababab"; /// </code> /// </summary> public static string[] Repeat(this string str, int count, bool merge) { return merge ? new string[] { string.Concat(Enumerable.Repeat(str, count)) } : Enumerable.Repeat(str, count).ToArray(); } 

Try this:

1. Add the Microsoft.VisualBasic reference
2. Use: String result = Microsoft.VisualBasic.Strings.StrDup(5, "hi");