¿Hay una manera fácil de devolver una cadena repetida X veces?

Estoy tratando de insertar un cierto número de hendiduras antes de una cadena basada en la profundidad de un elemento y me pregunto si hay una manera de devolver una cadena repetida X veces. Ejemplo:

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 "---------".

Si solo tiene la intención de repetir el mismo carácter, puede usar el constructor de cadenas que acepta un carácter y la cantidad de veces que lo repite new String(char c, int count).

Por ejemplo, para repetir un guión cinco veces:

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

Si usa .NET 4.0, puede usarlo string.Concatjunto con Enumerable.Repeat.

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

De lo contrario, iría con algo como la respuesta de Adam .

La razón por la que generalmente no recomendaría usar la respuesta de Andrey es simplemente que la ToArray()llamada introduce una sobrecarga superflua que se evita con el StringBuilderenfoque sugerido por Adam. Dicho esto, al menos funciona sin requerir .NET 4.0; y es rápido y fácil (y no te va a matar si la eficiencia no es una gran preocupación).

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

solución más eficaz para cadena

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

Para muchos escenarios, esta es probablemente la mejor solución:

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

El uso es entonces:

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

Esto se basa en otras respuestas (particularmente @ c0rd's). Además de la simplicidad, tiene las siguientes características, que no todas las otras técnicas discutidas comparten:

• Repetición de una cadena de cualquier longitud, no solo un carácter (según lo solicitado por el OP).
• Uso eficiente de StringBuilderla preasignación a través del almacenamiento.

Use String.PadLeft , si su cadena deseada contiene solo un carácter.

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

Crédito adeudado aquí

Puede repetir su cadena (en caso de que no sea un solo carácter) y concat el resultado, de esta manera:

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

Buscaría la respuesta de Dan Tao, pero si no estás usando .NET 4.0 puedes hacer algo así:

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

Me gusta la respuesta dada. Sin embargo, a lo largo de las líneas de sames es lo que he usado en el pasado:

"". PadLeft (3 * Sangría, '-')

Esto cumplirá creando una sangría, pero técnicamente la pregunta era repetir una cadena. Si la sangría de la cadena es algo así como> - <entonces esto, así como la respuesta aceptada, no funcionaría. En este caso, la solución de c0rd usando stringbuilder se ve bien, aunque la sobrecarga de stringbuilder puede no ser la más eficiente. Una opción es construir una matriz de cadenas, llenarla con cadenas de sangría y luego concatenarla. A 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 amamos una solución inteligente, pero a veces lo mejor es simple

Agregar el método de extensión que estoy usando en todos mis proyectos:

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

Espero que alguien pueda usarlo ...

Sorprendido, nadie fue a la vieja escuela. No estoy haciendo ninguna afirmación sobre este código, pero solo por diversión:

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

No estoy seguro de cómo funcionaría esto, pero es un código fácil. (Probablemente lo he hecho parecer más complicado de lo que es).

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

Alternativamente, si conoce la cantidad máxima de niveles que puede esperar, puede declarar una matriz e indexarla. Probablemente quiera hacer esta matriz estática o constante.

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

No tengo suficiente representante para comentar la respuesta de Adam, pero la mejor manera de hacerlo es así:

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

Debe verificar si numTimes es mayor que cero, de lo contrario obtendrá una excepción.

No vi esta solución. Me resulta más simple para el lugar donde estoy actualmente en el desarrollo de software:

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

Para uso general, las soluciones que involucran la clase StringBuilder son las mejores para repetir cadenas de caracteres múltiples. Está optimizado para manejar la combinación de grandes cantidades de cadenas de una manera que la concatenación simple no puede y eso sería difícil o imposible de hacer de manera más eficiente a mano. Las soluciones de StringBuilder que se muestran aquí usan iteraciones O (N) para completar, una tarifa plana proporcional al número de veces que se repite.

Sin embargo, para un gran número de repeticiones, o donde se deben extraer altos niveles de eficiencia, un mejor enfoque es hacer algo similar a la funcionalidad básica de StringBuilder pero producir copias adicionales desde el destino, en lugar de desde la cadena original, como a continuación.

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

Esto duplica la longitud de la cadena de origen / destino con cada iteración, lo que ahorra la sobrecarga de restablecer contadores cada vez que atraviesa la cadena original, en lugar de leer y copiar sin problemas la cadena ahora mucho más larga, algo que los procesadores modernos pueden hacer mucho más eficientemente

Utiliza un logaritmo de base 2 para encontrar cuántas veces necesita duplicar la longitud de la cadena y luego lo hace tantas veces. Dado que el resto a copiar ahora es menor que la longitud total desde la que está copiando, puede simplemente copiar un subconjunto de lo que ya ha generado.

He usado el método Array.Copy () sobre el uso de StringBuilder, ya que una copia del contenido del StringBuilder en sí mismo tendría la sobrecarga de producir una nueva cadena con ese contenido con cada iteración. Array.Copy () evita esto, mientras sigue funcionando con una tasa de eficiencia extremadamente alta.

Esta solución toma O (1 + log N) iteraciones para completar, una tasa que aumenta logarítmicamente con el número de repeticiones (duplicar el número de repeticiones es igual a una iteración adicional), un ahorro sustancial sobre los otros métodos, que aumentan proporcionalmente.

Otro enfoque es considerar stringcomo IEnumerable<char>y tienen un método de extensión genérica que multiplicará los elementos de una colección por el factor especificado.

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

Entonces en tu caso:

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

Imprime una línea con repetición.

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

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

¡Puedes crear un ExtensionMethod para hacer eso!

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

O usando la solución @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))
  }
}