Puis-je “multiplier” une chaîne de caractères (en C#)?

Supposons que j'ai une chaîne de caractères, par exemple,

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

Je veux essentiellement de l'écrire plusieurs fois, selon certaines valeur de type entier. 

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 mettre en œuvre la présente, je me demandais juste si il y avait un peu bizarre opérateur chaîne que je ne connaissais pas

InformationsquelleAutor inspite | 2009-02-10
  1. 211

    Dans .NET 4 vous pouvez le faire:

    String.Concat(Enumerable.Repeat("Hello", 4))
    • Et ce n'est pas beaucoup plus .NET 3.5: String.Concat(Énumérable.Répéter("Bonjour", 4).ToArray())
    • Je ne pense pas que c'est élégant du tout. En python, le code de le faire est: snip * multiplicateur (C'est pas horrible.. mais ce n'est pas beau).
    • Je sais que vous reconnaissez votre propre démence, mais même la souffrance comme vous le faites, vous pourriez être en mesure de voir qu'un exemple Python n'aurait pas eu une très bonne réponse C# question... je pense que la plupart d'entre nous peut voir que la sélection de la langue est toujours un compromis, et à peu près tout, de répondre à toute question pourrait être, en ajoutant une note à la défense, que ce soit pour ou contre.
    • dean: j'étais juste en se référant à Matthew Nichols déclaration sur l'élégance du code que vous avez là. Aussi loin que je peux dire à votre code est à la fois élégante pour C#, tel qu'il est actuellement, pour ce problème. Le point que je essaie de faire est: (je crois), il serait très facile (pour microsoft, comme des chaînes de caractères sont scellés) pour étendre le C# pour la surcharge de l'opérateur * pour permettre int * string multiplication. Qui serait alors réellement être élégant dans certains sens universel, à mon humble avis, pas seulement élégant, dans le cadre des contraintes imposées par le C# comme il existe pour le moment.
    • Pour moi, cela va à l'encontre de ce binaire operator* représente. À chacun son propre, je suppose.
    • Ouais.. je peux le comprendre. Potentiellement sauts de taper fort... pourrait conduire à des erreurs étranges si vous n'êtes pas prudent. (J'aime toujours python grammaire+stdlibs beaucoup mieux pour la manipulation de chaînes).

    InformationsquelleAutor Will Dean
  2. 88

    Notez que si votre "chaîne" est un seul caractère, il y a une surcharge de la chaîne constructeur pour le manipuler:

    int multipler = 10;
string TenAs = new string ('A', multipler);
    InformationsquelleAutor James Curran
  3. 60

    Malheureusement /heureusement, la classe string est scellé de sorte que vous ne pouvez pas hériter d'elle et la surcharge de l'opérateur*. Vous pouvez créer une méthode d'extension si:

    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);
    • Juste à l'endroit où j'allais! Vous pourriez probablement optimisation à l'aide de la source.Longueur * multiplicateur dans le StringBuilder ctor
    • Marc commentaire était juste où I a été va 🙂
    • Vous avez besoin d' (source.Longueur * multiplicateur), non pas seulement (multiplicateur)
    • Marc: Êtes-vous sûr que cela signifie personnages et non les éléments?
    • Désolé, apparemment c'est les personnages.
    • Très sûr. Il alloue une chaîne (de longueur) en coulisses, alors il mute. Cela ne fonctionne pas comme une Liste<T> etc.
    • Méthode d'Extension est idéal ici.
    • Nice, merci les gars, je m'attendais à quelque chose comme le pythonesque (@Vasil) mais cela va faire plus de bien que ce que j'avais à faire 😀

    InformationsquelleAutor Tamas Czinege
  4. 11

    Je suis avec DrJokepu sur celui-ci, mais si pour une raison quelconque vous ne voulez tricher à l'aide intégrée dans les fonctionnalités, alors vous pourriez faire quelque chose comme ceci:

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

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

    Ou, si vous êtes en utilisant .NET 4:

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

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

    • Je n'ai jamais su qu'il y avait un cheat comme ça. =)
    InformationsquelleAutor LukeH
  5. 10

    Juste par souci d'exhaustivité - voici une autre façon de faire:

    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é que l'un de Débordement de Pile il y a quelques temps, de sorte qu'il n'est pas mon idée.

    InformationsquelleAutor user51710
  6. 9

    Vous deviez écrire une méthode de cours, avec C# 3.0, il pourrait être une méthode d'extension:

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

    alors:

    string bar = "abc";
string foo = bar.Repeat(2);
    • N'a pas même pas .NET3 ont Énumérable.Répéter?
    • 3 a été WCF, WPF/etc, donc pas; il n'existe pas dans .NET 3.5, mais alors vous devrez string.Join ainsi - pourquoi ne pas simplement de la boucle n fois? Beaucoup plus directe.
    • Merci - je ne pensais pas correctement sur 3.0 vs 3.5. Pourquoi ne pas simplement utiliser une boucle, certes, c'est l'essence même de la fonctionnelle vs impératif débat? J'ai posté une .net 4 réponse plus bas, ce qui je pense n'est pas trop mauvais dans le fonctionnement de l'habileté' vs 'boucle évidence de débat.
    InformationsquelleAutor Marc Gravell
  7. 7

    Un peu de retard (et juste pour le fun), si vous voulez vraiment utiliser le * opérateur pour ce travail, vous pouvez faire ceci :

    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;

    Noter que, tant que vous êtes en mesure de trouver un comportement raisonnable pour eux, vous pouvez également gérer d'autres opérateurs à travers StringWrap classe, comme \ , ^ , % etc...

    P. S.:

    Multiply() extension des crédits à @DrJokepu tous droits réservés 😉

    InformationsquelleAutor digEmAll
  8. 6

    C'est beaucoup plus concis: 

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

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

    InformationsquelleAutor user734119
  9. 2
    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();
}
    InformationsquelleAutor Chris Ballance
  10. 2

    Si vous en avez .Net 3.5, mais pas la version 4.0, vous pouvez utiliser le Système.Linq

    String.Concat(Enumerable.Range(0, 4).Select(_ => "Hello").ToArray())
    • Pour obtenir une seule chaîne que vous souhaitez toujours besoin String.Concat, et sur 3.5 vous auriez également besoin d' .ToArray(). Pas la solution la plus élégante, je le crains.
    InformationsquelleAutor Frank Schwieterman
  11. 2

    Puisque tout le monde est d'ajouter leur propre .NET4/Linq des exemples, je pourrais tout aussi bien ajouter mon propre. (En gros, il DrJokepu est, réduit à un one-liner)

    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();
}
    InformationsquelleAutor James Curran
  12. 0

    Ok, voici mon point de vue 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 idiot, bien sûr, mais quand j'ai besoin d'avoir la tabulation dans le code de génération de classes Énumérables.Répétez le fait pour moi. Et ouais, la classe StringBuilder version est très bien, aussi.

    InformationsquelleAutor Dmitri Nesteruk
  13. 0

    Voici mon point de vue sur ce seulement pour l'avenir, référence:

        ///<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));
    }
    • J'espère que vous n'avez pas vraiment utiliser ParallelEnumerable dans des situations de ce genre. string.Join doit utiliser les éléments dans l'ordre, donc de la parallélisation de leur génération est déplacée.
    • Puisque les éléments sont les mêmes et sont vraiment juste des copies de thisString, il n'y a pas besoin de s'inquiéter à propos de la commande ici, je suppose.
    • Je suis d'accord avec beaucoup d'enseignants dans le domaine qu'il est généralement est bon de code pour dire ce que tu veux dire. Il est inutile de dire que vous voulez que ce parallèle et seulement secrètement penser "Bien, je sais qu'il ne sera pas en parallèle dans ce cas particulier, de toute façon"
    • Je pense faire de parallèle le rend plus rapide, ou s'il vous plaît m'éclairer. C'est pourquoi je suis à la conversion de ce à ParallelEnumerable, donc je pense que je code pour dire ce que je veux dire... Merci.
    InformationsquelleAutor Jronny