What it's the best way to generate a string of \t's in C#
I am learning C# and experimenting with different ways of saying the same thing.
Tabs(uint t) is a function that returns a string with t amount of \t's
For example Tabs(3) returns "\t\t\t"
Which of these three ways of implementing Tabs(uint numTabs) is best?
Of course that depends on what "best" means.
The LINQ version is only two lines, which is nice. But are the calls to Repeat and Aggregate unnecessarily time/resource consuming?
The StringBuilder version is very clear but is the StringBuilder class somehow slower?
The string version is basic, which means it is easy to understand.
Does it not matter at all? Are they all equal?
These are all questions to help me get a better feel for 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;
}
For me 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);
}
}
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, "*");
Standard .Net really,
And yet another method
new System.Text.StringBuilder().Append('\t', 100).ToString()
What about using 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 preformance penality :
on my computer the difference in mesured performance is 1:20 between:
Debug.WriteLine('-'.Repeat(1000000)) //char version and
Debug.WriteLine("-".Repeat(1000000)) //string version
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));
Let's say you want to repeat '\t' n number of times, you can use;
String.Empty.PadRight(n,'\t')
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
Nonsense: of course the above code is more efficient.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.
What about using 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 preformance penality :
on my computer the difference in mesured performance is 1:20 between:
Debug.WriteLine('-'.Repeat(1000000)) //char version and
Debug.WriteLine("-".Repeat(1000000)) //string version
Fill the screen with 6,435 z's $str = [System.Linq.Enumerable]::Repeat([string]::new("z", 143), 45)
$str
And yet another method
new System.Text.StringBuilder().Append('\t', 100).ToString()
I know that this question is five years old already but 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.
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
Nonsense: of course the above code is more efficient.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.
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.
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));
}
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, "*");
Standard .Net really,
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));
}
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));
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?
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());
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
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);
}
What about using 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 preformance penality :
on my computer the difference in mesured performance is 1:20 between:
Debug.WriteLine('-'.Repeat(1000000)) //char version and
Debug.WriteLine("-".Repeat(1000000)) //string version
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));
}
var str = new string(Enumerable.Repeat('\t', numTabs).ToArray());
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));
}
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));
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
Nonsense: of course the above code is more efficient.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.
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());
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
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);
}
Try this:
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
Nonsense: of course the above code is more efficient.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.
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?
Let's say you want to repeat '\t' n number of times, you can use;
String.Empty.PadRight(n,'\t')
Fill the screen with 6,435 z's $str = [System.Linq.Enumerable]::Repeat([string]::new("z", 143), 45)
$str
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.
var str = new string(Enumerable.Repeat('\t', numTabs).ToArray());
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));
What about using 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 preformance penality :
on my computer the difference in mesured performance is 1:20 between:
Debug.WriteLine('-'.Repeat(1000000)) //char version and
Debug.WriteLine("-".Repeat(1000000)) //string version
I know that this question is five years old already but 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.
Try this:
Source: Stackoverflow.com