¿Puedo "multiplicar" una cadena (en C#)?

Question

Supongamos que tengo una cadena, por ejemplo,

string snip = "</li></ul>"; 

Quiero escribir básicamente varias veces, en función de un valor entero.

string snip = "</li></ul>"; 
int multiplier = 2; 

// TODO: magic code to do this 
// snip * multiplier = "</li></ul></li></ul>"; 

EDIT: sé que puedo escribir fácilmente mi propia función para implementar esto, me estaba preguntando si había algún operador de cadena raro que yo no sabía nada de

Answer 1

En .NET 4 se puede hacer esto:

String.Concat(Enumerable.Repeat("Hello", 4)) 

Answer 2

Lamentablemente/afortunadamente, el la clase de cadena está sellada, por lo que no puede heredar de ella y sobrecargar el operador *. Puede crear un método de extensión embargo:

public static string Multiply(this string source, int multiplier) 
{ 
    StringBuilder sb = new StringBuilder(multiplier * source.Length); 
    for (int i = 0; i < multiplier; i++) 
    { 
     sb.Append(source); 
    } 

    return sb.ToString(); 
} 

string s = "</li></ul>".Multiply(10); 

Answer 3

que tendría que escribir un método - por supuesto, con C# 3.0 Podría ser un método de extensión:

public static string Repeat(this string, int count) { 
    /* StringBuilder etc */ } 

a continuación:

string bar = "abc"; 
string foo = bar.Repeat(2); 

Answer 4

string Multiply(string input, int times) 
{ 
    StringBuilder sb = new StringBuilder(input.length * times); 
    for (int i = 0; i < times; i++) 
    { 
      sb.Append(input); 
    } 
    return sb.ToString(); 
} 

Answer 5

I'm with DrJokepu on this one, pero si por alguna razón desea hacer trampas con la funcionalidad incorporada, entonces puede ld hacer algo como esto:

string snip = "</li></ul>"; 
int multiplier = 2; 

string result = string.Join(snip, new string[multiplier + 1]); 

O, si usted está utilizando .NET 4:

string result = string.Concat(Enumerable.Repeat(snip, multiplier)); 

En lo personal no me molestaría sin embargo - un método de extensión personalizada es mucho más agradable.

Answer 6

Bueno, aquí está mi opinión sobre el asunto:

public static class ExtensionMethods { 
    public static string Multiply(this string text, int count) 
    { 
    return new string(Enumerable.Repeat(text, count) 
     .SelectMany(s => s.ToCharArray()).ToArray()); 
    } 
} 

estoy siendo un poco tonto, por supuesto, pero cuando tengo que tener la tabulación en las clases de la generación de código, Enumerable.Repeat lo hace por mí . Y sí, la versión de StringBuilder también está bien.

Answer 7

Tenga en cuenta que si su "cadena" es un solo carácter, hay una sobrecarga del constructor de cadena para manejarlo:

int multipler = 10; 
string TenAs = new string ('A', multipler); 

Answer 8

Sólo por el bien de la exhaustividad - aquí es otra manera de hacer esto :

public static string Repeat(this string s, int count) 
{ 
    var _s = new System.Text.StringBuilder().Insert(0, s, count).ToString(); 
    return _s; 
} 

Creo que lo saqué de Stack Overflow hace un tiempo, así que no es mi idea.

Answer 9

Aquí está mi opinión sobre esto sólo para referencia futura:

/// <summary> 
    /// Repeats a System.String instance by the number of times specified; 
    /// Each copy of thisString is separated by a separator 
    /// </summary> 
    /// <param name="thisString"> 
    /// The current string to be repeated 
    /// </param> 
    /// <param name="separator"> 
    /// Separator in between copies of thisString 
    /// </param> 
    /// <param name="repeatTimes"> 
    /// The number of times thisString is repeated</param> 
    /// <returns> 
    /// A repeated copy of thisString by repeatTimes times 
    /// and separated by the separator 
    /// </returns> 
    public static string Repeat(this string thisString, string separator, int repeatTimes) { 
     return string.Join(separator, ParallelEnumerable.Repeat(thisString, repeatTimes)); 
    } 

Answer 10

Si tiene .Net 3.5, pero no 4.0, puede utilizar de System.Linq

String.Concat(Enumerable.Range(0, 4).Select(_ => "Hello").ToArray()) 

Answer 11

Puesto que cada uno está agregando sus propios ejemplos .NET4/LINQ, que bien podría añadir mi propia.(Básicamente, es DrJokepu, reducidos a una sola línea)

public static string Multiply(this string source, int multiplier) 
{ 
    return Enumerable.Range(1,multiplier) 
      .Aggregate(new StringBuilder(multiplier*source.Length), 
        (sb, n)=>sb.Append(source)) 
      .ToString(); 
} 

Answer 12

Un poco tarde (y sólo por diversión), si realmente desea utilizar el operador * para este trabajo, se puede hacer esto:

public class StringWrap 
{ 
    private string value; 
    public StringWrap(string v) 
    { 
     this.value = v; 
    } 
    public static string operator *(StringWrap s, int n) 
    { 
     return s.value.Multiply(n); // DrJokepu extension 
    } 
} 

Y así:

var newStr = new StringWrap("TO_REPEAT") * 5; 

Tenga en cuenta que, siempre y cuando usted es capaz de encontrar un comportamiento razonable para ellos, también puede manejar otros operadores a través de StringWrap clase, como \, ^, % etc ...

PS:

Multiply() créditos de extensión a @DrJokepu todos los derechos reservados ;-)

Answer 13

Esto es mucho más concisa:

new StringBuilder().Insert(0, "</li></ul>", count).ToString() 

El espacio de nombre using System.Text; se debe importar en este caso.