Posso "moltiplicare" una stringa (in C#)?

Question

Supponiamo che io sono una stringa, ad esempio,

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

voglio scrivere in fondo è più volte, a seconda di un certo valore intero.

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

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

EDIT: So che posso facilmente scrivere il mio funzione per implementare questo, mi stavo chiedendo se ci fosse qualche strano operatore stringa che io non conoscevo

Answer 1

In .NET 4 si può fare questo:

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

Answer 2

Purtroppo/per fortuna, il la classe string è sigillata, quindi non puoi ereditarla e sovraccaricare l'operatore *. È possibile creare un metodo di estensione però:

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

che avrebbe dovuto scrivere un metodo - naturalmente, con C# 3.0 potrebbe essere un metodo di estensione:

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

poi:

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, ma se per qualche motivo si desiderava imbrogliare utilizzando la funzionalità integrata, quindi si ld fare qualcosa di simile:

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

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

Oppure, se si sta utilizzando .NET 4:

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

Personalmente non mi preoccuperei se - un metodo di estensione personalizzata è molto più bello.

Answer 6

Okay, ecco il mio prendere sulla questione:

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

devo essere un po 'sciocco, naturalmente, ma quando ho bisogno di avere tabulazione nelle classi di codici che generano, Enumerable.Repeat lo fa per me . E sì, anche la versione StringBuilder va bene.

Answer 7

Nota che se il "stringa" è solo un singolo carattere, v'è un sovraccarico del costruttore stringa per gestirlo:

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

Answer 8

Solo per amor di completezza - qui è un altro modo di fare questo :

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

penso ho tirato quella di Stack Overflow qualche tempo fa, quindi non è la mia idea.

Answer 9

Ecco il mio prendere su questo solo per riferimento futuro:

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

Se si dispone di .Net 3.5, ma non 4.0, è possibile utilizzare System.Linq's

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

Answer 11

Poiché tutti aggiungono i propri esempi .NET4/Linq, potrei aggiungere il mio.(In sostanza, DrJokepu di, ridotti ad una battuta)

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 po 'in ritardo (e solo per divertimento), se davvero si vuole utilizzare l'operatore * per questo lavoro, si può fare questo:

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 così:

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

si noti che, finché si è in grado di trovare un comportamento ragionevole per loro, è possibile gestire anche altri operatori attraverso StringWrap di classe, come \, ^, % ecc ...

PS:

Multiply() crediti estensione a @DrJokepu tutti i diritti riservati ;-)

Answer 13

Questo è molto più conciso:

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

Il namespace using System.Text; dovrebbe essere importato in questo caso.