Melhor maneira de repetir um personagem em c #

Qual é a melhor maneira de gerar uma string de \t em c #

Eu estou aprendendo C # e experimentando diferentes maneiras de dizer a mesma coisa.

Tabs(uint t) é uma function que retorna uma string com uma quantidade de \t s

Por exemplo, Tabs(3) retorna "\t\t\t"

Qual destas três formas de implementar Tabs(uint numTabs) é melhor?

Claro que isso depende do que “melhor” significa.

  1. A versão LINQ é apenas duas linhas, o que é legal. Mas as chamadas para Repetir e Agregar desnecessariamente consumem tempo / resources?

  2. A versão do StringBuilder é muito clara, mas a class StringBuilder é mais lenta?

  3. A versão de string é básica, o que significa que é fácil de entender.

  4. Isso não importa em tudo? Eles são todos iguais?

Estas são todas as perguntas para me ajudar a ter uma idéia melhor do C #.

 private string Tabs(uint numTabs) { IEnumerable 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; } 

O que sobre isso:

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

Onde n é o número de vezes que você deseja repetir a string.

Ou melhor:

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

Em todas as versões do .NET, você pode repetir uma string assim:

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

Para repetir um personagem, o new String('\t', count) é a sua melhor aposta. Veja a resposta por @CMS .

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

Retorna

“abab”

E

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

Retorna

“aa”

a partir de…

Existe uma function interna para repetir string ou char em .net?

A melhor versão é certamente usar o caminho embutido:

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

Das outras soluções, prefira o mais fácil; somente se isso for muito lento, busque uma solução mais eficiente.

Se você usar um StringBuilder e conhecer antecipadamente seu comprimento resultante, use também um construtor apropriado, isso é muito mais eficiente porque significa que apenas uma alocação demorada ocorre e nenhuma cópia desnecessária de dados. Bobagem: claro que o código acima é mais eficiente.

Métodos de extensão:

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

Que tal usar o método de extensão?


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

Você poderia então escrever:

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

Observe que um teste de desempenho do uso da versão de stringbuilder para caracteres simples, em vez de strings, fornece uma penalidade de desempenho principal: no meu computador, a diferença no desempenho medido é 1:20 entre: Debug.WriteLine ('-'. Repeat (1000000)) // versão char e
Debug.WriteLine ("-". Repeat (1000000)) // versão da string

Que tal agora:

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

Eu sei que essa questão já tem cinco anos, mas existe uma maneira simples de repetir uma string que até funciona no .net 2.0.

Para repetir uma string:

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

Retorna

“Ola Ola Ola, ”

Para repetir uma string como uma matriz:

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

Retorna

{“Ola Ola Ola”, “”}

Mantenha simples.

Vamos dizer que você quer repetir ‘\ t’ n número de vezes, você pode usar;

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

Seu primeiro exemplo que usa Enumerable.Repeat :

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

pode ser reescrito de forma mais compacta com o String.Concat :

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

Usando String.Concat e Enumerable.Repeat que será menos caro do que usar 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()); 

A resposta realmente depende da complexidade que você deseja. Por exemplo, quero delinear todos os meus recuos com uma barra vertical, para que minha sequência de indentação seja determinada da seguinte maneira:

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

Você pode criar um método de extensão

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

Então você pode usá-lo assim

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

E ainda outro método

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

Para mim está bem:

 public static class Utils { public static string LeftZerosFormatter(int zeros, string value) { value = value.Trim(); if (value == "") return ""; value = new string('0', zeros) + value; return value.Substring(value.Length - zeros, zeros); } } 

Sem dúvida, a resposta aceita é a melhor e mais rápida maneira de repetir um único personagem.

A resposta de Binoj Anthony é uma maneira simples e bastante eficiente de repetir uma string.

No entanto, se você não se importar com um pouco mais de código, poderá usar minha técnica de preenchimento de matriz para criar essas sequências de maneira eficiente ainda mais rapidamente. Nos meus testes de comparação, o código abaixo foi executado em aproximadamente 35% do tempo do código StringBuilder.Insert.

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

Para obter mais informações sobre essa técnica de preenchimento de matriz, consulte o modo mais rápido de preencher uma matriz com um único valor

Tente isto:

  1. Adicionar referência Microsoft.VisualBasic
  2. Use: String resultado = Microsoft.VisualBasic.Strings.StrDup (5, “hi”);
  3. Deixe-me saber se funciona para você.

Apesar de muito semelhante a uma sugestão anterior, gosto de simplificar e aplicar o seguinte:

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

Standard .Net realmente,