Melhor maneira de repetir um caractere em C #

Qual é a melhor maneira de gerar uma sequência de \t's em c #

Estou aprendendo c # e experimentando maneiras diferentes de dizer a mesma coisa.

Tabs(uint t)é uma função que retorna a stringcom tquantidade de \t's

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

Qual dessas três maneiras de implementar Tabs(uint numTabs)é a melhor?

Claro que isso depende do que "melhor" significa.

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

2. A StringBuilderversão é muito clara, mas a StringBuilderclasse é de alguma forma mais lenta?

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

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

Essas são perguntas para me ajudar a ter uma idéia melhor do 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; 
}

Que tal isso:

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

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

Ou melhor:

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

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

Devoluções

"abab"

E

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

Devoluções

"aa"

de...

Existe uma função interna para repetir string ou char no .net?

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

Repetir um personagem new String('\t', count)é a sua melhor aposta. Veja a resposta do @CMS .

A melhor versão é certamente usar da maneira integrada:

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

Das outras soluções, prefira as mais fáceis; somente se isso estiver muito lento, lute por uma solução mais eficiente.

Se você usa um StringBuildere conhece seu comprimento resultante com antecedência, também usa um construtor apropriado, isso é muito mais eficiente, pois 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ê pode 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 stringbuilder para caracteres simples em vez de seqüências de caracteres fornece uma grande penalidade de desempenho: no meu computador, a diferença no desempenho medido é 1:20 entre: Debug.WriteLine ('-'. Repeat (1000000)) // versão char e
Debug.WriteLine ("-". Repeat (1000000)) // string version

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 pergunta já tem cinco anos, mas existe uma maneira simples de repetir uma string que até funciona no .Net 2.0.

Para repetir uma sequência:

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

Devoluções

"Ola Ola Ola, "

Para repetir uma sequência 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(',');

Devoluções

{"Ola Ola Ola", ""}

Mantenha simples.

Digamos que você queira 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<string> tabs = Enumerable.Repeat(
                                 "\t", (int) numTabs);
    return (numTabs > 0) ? 
            tabs.Aggregate((sum, next) => sum + next) : ""; 
} 

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

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

Usando String.Concate Enumerable.Repeatque será mais barato do que usarString.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 cadeia de recuos seja determinada da seguinte maneira:

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

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, int val)
    {
        string valstr = val.ToString();

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

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

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

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

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

No entanto, se você não se importa com um pouco mais de código, pode usar minha técnica de preenchimento de matriz para criar essas seqüências com eficiência ainda mais rapidamente. Nos meus testes de comparação, o código abaixo é executado em cerca de 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<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);
}

Para saber mais sobre esta técnica de preenchimento de matriz, consulte Maneira mais rápida de preencher uma matriz com um único valor

Tente o seguinte:

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

Embora muito parecido com uma sugestão anterior, eu gosto de simplificar e aplicar o seguinte:

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

Standard .Net realmente,