Puis-je «multiplier» une chaîne (en C #)?

Supposons que j'ai une chaîne, par exemple,

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

Je veux essentiellement l'écrire plusieurs fois, en fonction d'une valeur entière.

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

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

EDIT: Je sais que je peux facilement écrire ma propre fonction pour implémenter cela, je me demandais juste s'il y avait un opérateur de chaîne étrange que je ne connaissais pas

Dans .NET 4, vous pouvez faire ceci:

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

Notez que si votre "chaîne" n'est qu'un seul caractère, il y a une surcharge du constructeur de chaîne pour la gérer:

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

Malheureusement / heureusement, la classe string est scellée, vous ne pouvez donc pas en hériter et surcharger l'opérateur *. Vous pouvez cependant créer une méthode d'extension:

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

Je suis avec DrJokepu sur celui-ci , mais si, pour une raison quelconque, vous voulez tricher en utilisant la fonctionnalité intégrée, vous pouvez faire quelque chose comme ceci:

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

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

Ou, si vous utilisez .NET 4:

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

Personnellement, je ne dérangerais pas - une méthode d'extension personnalisée est beaucoup plus agréable.

Juste pour être complet - voici une autre façon de procéder:

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

Je pense que j'ai tiré celui-là de Stack Overflow il y a quelque temps, donc ce n'est pas mon idée.

Vous devrez écrire une méthode - bien sûr, avec C # 3.0, cela pourrait être une méthode d'extension:

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

puis:

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

Un peu tard (et juste pour le plaisir), si vous voulez vraiment utiliser l' *opérateur pour ce travail, vous pouvez le faire:

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

Et donc:

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

Notez que, aussi longtemps que vous êtes en mesure de trouver un comportement raisonnable pour eux, vous pouvez également gérer d' autres opérateurs par StringWrapclasse, comme \, ^, %etc ...

PS:

Multiply()crédits d'extension à @DrJokepu tous droits réservés ;-)

C'est beaucoup plus concis:

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

L'espace de noms using System.Text;doit être importé dans ce cas.

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

Si vous avez .Net 3.5 mais pas 4.0, vous pouvez utiliser System.Linq's

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

Puisque tout le monde ajoute ses propres exemples .NET4 / Linq, je pourrais aussi bien ajouter les miens. (Fondamentalement, c'est DrJokepu, réduit à une seule ligne)

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

D'accord, voici mon avis sur la question:

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

Je suis un peu ridicule bien sûr, mais quand j'ai besoin d'avoir une tabulation dans des classes générant du code, Enumerable.Repeat le fait pour moi. Et oui, la version StringBuilder est bien aussi.

Voici mon avis à ce sujet juste pour référence future:

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