Posso "multiplicar" uma string (em C #)?

Suponha que eu tenha uma string, por exemplo,

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

Quero basicamente escrever várias vezes, dependendo de algum valor inteiro.

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

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

Edição: Eu sei que posso facilmente escrever minha própria função para implementar isso, eu só estava me perguntando se havia algum operador de string estranho que eu não sabia sobre

No .NET 4, você pode fazer isso:

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

Observe que se sua "string" é apenas um caractere, há uma sobrecarga do construtor de string para lidar com isso:

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

Infelizmente / felizmente, a classe string é selada para que você não possa herdar dela e sobrecarregar o operador *. Você pode criar um método de extensão:

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

Estou com o DrJokepu , mas se, por algum motivo, você quiser trapacear usando a funcionalidade incorporada, poderá fazer algo assim:

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

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

Ou, se você estiver usando o .NET 4:

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

Pessoalmente, eu não me incomodaria - um método de extensão personalizado é muito melhor.

Apenas por uma questão de integridade - aqui está outra maneira de fazer isso:

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

Acho que peguei esse no Stack Overflow há algum tempo, então não é minha ideia.

Você precisaria escrever um método - é claro, com o C # 3.0, poderia ser um método de extensão:

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

então:

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

Um pouco tarde (e apenas por diversão), se você realmente quiser usar o *operador para este trabalho, poderá fazer o seguinte:

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

E entao:

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

Note-se que, desde que você é capaz de encontrar um comportamento razoável para eles, você também pode lidar com outros operadores através de StringWrapclasse, como \, ^, %etc ...

PS:

Multiply()créditos de extensão para @DrJokepu todos os direitos reservados ;-)

Isso é muito mais conciso:

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

O espaço using System.Text;para nome deve ser importado nesse caso.

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

Se você possui .Net 3.5, mas não 4.0, pode usar o System.Linq

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

Como todo mundo está adicionando seus próprios exemplos do .NET4 / Linq, é melhor adicionar os meus. (Basicamente, DrJokepu's, reduzido a uma linha)

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

Ok, aqui está minha opinião sobre o assunto:

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

Estou sendo um pouco bobo, é claro, mas quando preciso ter tabulação nas classes geradoras de código, o Enumerable.Repeat faz isso por mim. E sim, a versão StringBuilder também está bem.

Aqui está minha opinião sobre isso apenas para referência 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));
    }