Existe uma maneira fácil de retornar uma sequência X repetida várias vezes?

Estou tentando inserir um certo número de indentações antes de uma seqüência de caracteres com base na profundidade de itens e estou me perguntando se existe uma maneira de retornar uma sequência de vezes X repetidas. Exemplo:

string indent = "---";
Console.WriteLine(indent.Repeat(0)); //would print nothing.
Console.WriteLine(indent.Repeat(1)); //would print "---".
Console.WriteLine(indent.Repeat(2)); //would print "------".
Console.WriteLine(indent.Repeat(3)); //would print "---------".

Se você deseja repetir apenas o mesmo caractere, pode usar o construtor de cadeias que aceita um caractere e o número de vezes para repeti-lonew String(char c, int count) .

Por exemplo, para repetir um traço cinco vezes:

string result = new String('-', 5);
Output: -----

Se você estiver usando o .NET 4.0, poderá usar string.Concatjunto com Enumerable.Repeat.

int N = 5; // or whatever
Console.WriteLine(string.Concat(Enumerable.Repeat(indent, N)));

Caso contrário, eu usaria algo como a resposta de Adam .

A razão pela qual geralmente não aconselho usar a resposta de Andrey é simplesmente que a ToArray()ligação introduz uma sobrecarga supérflua que é evitada com a StringBuilderabordagem sugerida por Adam. Dito isto, pelo menos funciona sem a necessidade do .NET 4.0; e é rápido e fácil (e não vai te matar se a eficiência não for muito preocupante).

public static class StringExtensions
{
    public static string Repeat(this string input, int count)
    {
        if (!string.IsNullOrEmpty(input))
        {
            StringBuilder builder = new StringBuilder(input.Length * count);

            for(int i = 0; i < count; i++) builder.Append(input);

            return builder.ToString();
        }

        return string.Empty;
    }
}

solução de melhor desempenho para string

string result = new StringBuilder().Insert(0, "---", 5).ToString();

Para muitos cenários, esta é provavelmente a solução mais limpa:

public static class StringExtensions
{
    public static string Repeat(this string s, int n)
        => new StringBuilder(s.Length * n).Insert(0, s, n).ToString();
}

O uso é então:

text = "Hello World! ".Repeat(5);

Isso se baseia em outras respostas (principalmente no @ c0rd). Além da simplicidade, possui os seguintes recursos, que nem todas as outras técnicas discutidas compartilham:

• Repetição de uma sequência de qualquer tamanho, não apenas de um caractere (conforme solicitado pelo OP).
• Uso eficiente de StringBuilderpré-alocação de armazenamento.

Use String.PadLeft , se a sequência desejada contiver apenas um único caractere.

public static string Indent(int count, char pad)
{
    return String.Empty.PadLeft(count, pad);
}

Crédito devido aqui

Você pode repetir sua string (caso não seja um único caractere) e concatinar o resultado, assim:

String.Concat(Enumerable.Repeat("---", 5))

Gostaria de ir para a resposta de Dan Tao, mas se você não estiver usando o .NET 4.0, poderá fazer algo assim:

public static string Repeat(this string str, int count)
{
    return Enumerable.Repeat(str, count)
                     .Aggregate(
                        new StringBuilder(),
                        (sb, s) => sb.Append(s))
                     .ToString();
}

        string indent = "---";
        string n = string.Concat(Enumerable.Repeat(indent, 1).ToArray());
        string n = string.Concat(Enumerable.Repeat(indent, 2).ToArray());
        string n = string.Concat(Enumerable.Repeat(indent, 3).ToArray());

Eu gosto da resposta dada. Na mesma linha, porém, é o que eu usei no passado:

"" .PadLeft (3 * Recuo, '-')

Isso criará um recuo, mas tecnicamente a questão era repetir uma string. Se o recuo da string for algo como> - <, isso e a resposta aceita não funcionariam. Nesse caso, a solução da c0rd usando stringbuilder parece boa, embora a sobrecarga do stringbuilder possa de fato não torná-lo o mais eficiente. Uma opção é criar uma matriz de cadeias, preenchê-la com cadeias de indentação e concatenar isso. Para whit:

int Indent = 2;

string[] sarray = new string[6];  //assuming max of 6 levels of indent, 0 based

for (int iter = 0; iter < 6; iter++)
{
    //using c0rd's stringbuilder concept, insert ABC as the indent characters to demonstrate any string can be used
    sarray[iter] = new StringBuilder().Insert(0, "ABC", iter).ToString();
}

Console.WriteLine(sarray[Indent] +"blah");  //now pretend to output some indented line

Todos nós gostamos de uma solução inteligente, mas às vezes simples é melhor.

Adicionando o método de extensão que estou usando em todos os meus projetos:

public static string Repeat(this string text, int count)
{
    if (!String.IsNullOrEmpty(text))
    {
        return String.Concat(Enumerable.Repeat(text, count));
    }
    return "";
}

Espero que alguém possa usá-lo ...

Surpreso, ninguém foi à moda antiga. Não estou fazendo nenhuma reivindicação sobre esse código, mas apenas por diversão:

public static string Repeat(this string @this, int count)
{
    var dest = new char[@this.Length * count];
    for (int i = 0; i < dest.Length; i += 1)
    {
        dest[i] = @this[i % @this.Length];
    }
    return new string(dest);
}

Não tenho certeza de como isso funcionaria, mas é um código fácil. (Eu provavelmente fiz parecer mais complicado do que é.)

int indentCount = 3;
string indent = "---";
string stringToBeIndented = "Blah";
// Need dummy char NOT in stringToBeIndented - vertical tab, anyone?
char dummy = '\v';
stringToBeIndented.PadLeft(stringToBeIndented.Length + indentCount, dummy).Replace(dummy.ToString(), indent);

Como alternativa, se você souber o número máximo de níveis que pode esperar, basta declarar uma matriz e indexá-la. Você provavelmente desejaria tornar essa matriz estática ou constante.

string[] indents = new string[4] { "", indent, indent.Replace("-", "--"), indent.Replace("-", "---"), indent.Replace("-", "----") };
output = indents[indentCount] + stringToBeIndented;      

Não tenho representante suficiente para comentar a resposta de Adam, mas a melhor maneira de fazê-lo é:

public static string RepeatString(string content, int numTimes) {
        if(!string.IsNullOrEmpty(content) && numTimes > 0) {
            StringBuilder builder = new StringBuilder(content.Length * numTimes);

            for(int i = 0; i < numTimes; i++) builder.Append(content);

            return builder.ToString();
        }

        return string.Empty;
    }

Você deve verificar se numTimes é maior que zero, caso contrário, você receberá uma exceção.

Eu não vi essa solução. Acho mais simples para onde atualmente estou no desenvolvimento de software:

public static void PrintFigure(int shapeSize)
{
    string figure = "\\/";
    for (int loopTwo = 1; loopTwo <= shapeSize - 1; loopTwo++)
    {
        Console.Write($"{figure}");
    }
}

Para uso geral, as soluções que envolvem a classe StringBuilder são melhores para repetir seqüências de vários caracteres. É otimizado para lidar com a combinação de um grande número de strings de uma maneira que a concatenação simples não pode e que seria difícil ou impossível fazer com mais eficiência manualmente. As soluções StringBuilder mostradas aqui usam iterações O (N) para concluir, uma taxa fixa proporcional ao número de vezes que é repetida.

No entanto, para um número muito grande de repetições ou onde altos níveis de eficiência devem ser extraídos, uma abordagem melhor é fazer algo semelhante à funcionalidade básica do StringBuilder, mas produzir cópias adicionais a partir do destino, e não da sequência original, como abaixo.

    public static string Repeat_CharArray_LogN(this string str, int times)
    {
        int limit = (int)Math.Log(times, 2);
        char[] buffer = new char[str.Length * times];
        int width = str.Length;
        Array.Copy(str.ToCharArray(), buffer, width);

        for (int index = 0; index < limit; index++)
        {
            Array.Copy(buffer, 0, buffer, width, width);
            width *= 2;
        }
        Array.Copy(buffer, 0, buffer, width, str.Length * times - width);

        return new string(buffer);
    }

Isso dobra o comprimento da cadeia de origem / destino a cada iteração, o que economiza a sobrecarga de redefinir os contadores toda vez que ela passa pela cadeia original, em vez de ler e copiar facilmente a cadeia agora muito mais longa, algo que os processadores modernos podem fazer mais eficientemente.

Ele usa um logaritmo de base 2 para descobrir quantas vezes ele precisa dobrar o comprimento da string e, em seguida, continua fazendo isso várias vezes. Como o restante a ser copiado agora é menor que o tamanho total do qual está copiando, ele pode simplesmente copiar um subconjunto do que já gerou.

Eu usei o método Array.Copy () sobre o uso de StringBuilder, pois uma cópia do conteúdo do StringBuilder em si teria a sobrecarga de produzir uma nova string com esse conteúdo a cada iteração. Array.Copy () evita isso, enquanto ainda opera com uma taxa extremamente alta de eficiência.

Essa solução leva para que as iterações O (1 + log N) sejam concluídas, uma taxa que aumenta logaritmicamente com o número de repetições (dobrar o número de repetições equivale a uma iteração adicional), uma economia substancial em relação aos outros métodos, que aumentam proporcionalmente.

Outra abordagem é considerar stringcomo IEnumerable<char>e ter um método de extensão genérico que multiplicará os itens de uma coleção pelo fator especificado.

public static IEnumerable<T> Repeat<T>(this IEnumerable<T> source, int times)
{
    source = source.ToArray();
    return Enumerable.Range(0, times).SelectMany(_ => source);
}

Então, no seu caso:

string indent = "---";
var f = string.Concat(indent.Repeat(0)); //.NET 4 required
//or
var g = new string(indent.Repeat(5).ToArray());

Imprima uma linha com repetição.

Console.Write(new string('=', 30) + "\n");

==============================

Você pode criar um ExtensionMethod para fazer isso!

public static class StringExtension
{
  public static string Repeat(this string str, int count)
  {
    string ret = "";

    for (var x = 0; x < count; x++)
    {
      ret += str;
    }

    return ret;
  }
}

Ou usando a solução @Dan Tao:

public static class StringExtension
{
  public static string Repeat(this string str, int count)
  {
    if (count == 0)
      return "";

    return string.Concat(Enumerable.Repeat(indent, N))
  }
}