Supongamos que tengo una cadena, por ejemplo,

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

Quiero básicamente, escribir varias veces, dependiendo de algún valor entero.

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

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

EDITAR:
Sé que tengo facilidad para escribir mi propia función para implementar esto, me preguntaba si había alguna extraña cadena de operador que no sabía acerca de la

InformationsquelleAutor inspite | 2009-02-10

13 Comentarios

  1. 216

    En .NET 4 usted puede hacer esto:

    String.Concat(Enumerable.Repeat("Hello", 4))
    • Y no mucho más .NET 3.5: String.Concat(Enumerable.Repetir(«Hola», 4).ToArray())
    • Yo no creo que sea elegante en todo. En python para ello, el código es: snip * multiplicador (no Es horrible.. pero tampoco es hermoso).
    • Sé que usted reconoce su propia demencia, pero incluso el sufrimiento como usted lo hace, usted podría ser capaz de ver que una de Python ejemplo no han hecho una muy buena respuesta a un C# pregunta… yo creo que la mayoría de nosotros puede ver que la selección del idioma es siempre un compromiso, y casi cualquier respuesta a cualquier pregunta podría ser al pie de la tabla con la promoción, ya sea a favor o en contra.
    • dean: me refería a Mateo Nichols declaración acerca de la elegancia del código que tienes ahí. Como lo que puedo decir que su código es elegante para C#, como se encuentra actualmente, para este problema. El punto que estoy tratando de hacer es: (creo) sería muy fácil (para microsoft, ya que las cadenas están sellados) para extender C# para sobrecargar el operador * para permitir int * cadena de multiplicación. Que pasaría a ser realmente elegante en algún sentido universal, en mi humilde opinión, no sólo elegante en el contexto de las limitaciones impuestas por C#, tal como existe en el momento.
    • A mí, que va en contra de lo binario operator* representa. A cada uno lo suyo, supongo.
    • Yeah.. I se puede apreciar que. Potencialmente se rompe fuerte de escribir… podría conducir a errores extraños si usted no es cuidadoso. (Todavía me gusta python gramática+stdlibs mucho mejor para la manipulación de cadenas).

  2. 90

    Tenga en cuenta que si su «cadena» es un solo personaje, hay una sobrecarga del constructor de cadena de manejarlo:

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

    Por desgracia /afortunadamente, la clase string es sellada de modo que no puede heredar de ella y se sobrecarga el operador*. Usted puede crear un método de extensión, sin 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);
    • Justo donde iba! Probablemente se puede optimizar mediante el uso de la fuente.Longitud * multiplicador en el StringBuilder cto r
    • Marc comentario fue solo cuando yo fue pasando 🙂
    • Usted necesita (de origen.Longitud * multiplicador), no sólo (multiplicador)
    • Marc: ¿estás seguro de que significa personajes y no de los artículos?
    • Lo siento, al parecer, es de los personajes.
    • Muy seguro. Se asigna una cadena (de longitud) detrás de las escenas, luego muta ella. No funciona como una Lista regular,<T> etc.
    • Método de extensión es ideal aquí.
    • Bonito, gracias chicos, yo estaba esperando algo como el pythonesque (@Vasil), pero esto va a hacer más bien que lo que iba a hacer 😀

  4. 11

    Estoy con DrJokepu en este, pero si por alguna razón te hiciste quieren engañar utilizando el construido en la funcionalidad, entonces usted podría 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));

    Personalmente no me molesta, aunque – un método de extensión personalizado es mucho más agradable.

    • Nunca supe que había una trampa como esta. =)
  5. 10

    Sólo en aras de la exhaustividad – aquí es otra forma 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 me sacó de que uno de Desbordamiento de Pila hace algún tiempo, por lo que no es mi idea.

  6. 9

    Habría que escribir un método de curso, 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);
    • Ni siquiera .NET3 han Enumerable.Repita?
    • 3 fue WCF y WPF, etc, por lo que no; que no existe en .NET 3.5, pero entonces tendría que string.Join es así – ¿por qué no acaba de bucle de n veces? Es mucho más directo.
    • Gracias – no podía pensar correctamente acerca de 3.0 vs 3.5. En cuanto a por qué no usar simplemente un bucle, sin duda esa es la esencia de la funcional vs imperativo debate? He publicado una .net 4 respuesta más baja de la que creo que no es demasiado malo en el funcional de la inteligencia’ vs ‘bucle evidencia del debate.
  7. 8

    Un poco tarde (y sólo por diversión), si usted 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;

    Nota de que, siempre y cuando usted es capaz de encontrar un comportamiento razonable para ellos, también puede controlar otros operadores a través de StringWrap clase, como el \ , ^ , % etc…

    P. S.:

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

  8. 6

    Esto es mucho más concisa:

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

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

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

    Si usted tiene .Net 3.5, pero no 4.0, puede utilizar el Sistema.Linq

    String.Concat(Enumerable.Range(0, 4).Select(_ => "Hello").ToArray())
    • Para obtener una sola cadena que todavía sea necesario String.Concat, y en 3.5 necesarios también .ToArray(). No es la solución más elegante, me temo.
  11. 2

    Ya que todo el mundo es la adición de su propio .NET4/Linq ejemplos, que bien podría agregar mi cuenta. (Básicamente, DrJokepu es, reducido 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();
    }
  12. 0

    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 necesito tener tabulación en el código de generación de clases, Enumerable.Repita lo hace por mí. Y sí, el StringBuilder versión está bien, también.

  13. 0

    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));
        }
    • Espero que realmente no uso ParallelEnumerable en situaciones como esta. string.Join necesidades utilizando los elementos en orden, así que la paralelización de su generación, está fuera de lugar.
    • Ya que los elementos son los mismos y en realidad solo son copias de thisString, no hay necesidad de preocuparse por el orden aquí, supongo.
    • Estoy de acuerdo con muchos de los maestros en el campo es que por lo general es bueno para el código de decir lo que quieres decir. No hay ningún beneficio para decir que desea que este paralelo y sólo en secreto a pensar «Bueno, sé que no será paralelo en este caso particular, de todos modos»
    • Creo que lo que es paralelo hace que sea más rápido, o que por favor me ilumine. Es por eso que me estoy convirtiendo esta a ParallelEnumerable, por lo tanto creo que el código de decir lo que quiero decir… Gracias.

Dejar respuesta

Please enter your comment!
Please enter your name here