c# - metodo - extension method must be defined in a non-generic static class

¿Puedo "multiplicar" una cuerda(en C#)?

Question

Supongamos que tengo una cadena, por ejemplo,

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

Quiero básicamente escribirlo 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 puedo escribir fácilmente mi propia función para implementar esto, me preguntaba si había algún extraño operador de cadenas que no sabía

Answer 1

Aquí está mi opinión sobre esto solo para futuras referencias:

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

Como todos agregan sus propios ejemplos de .NET4 / Linq, también podría agregar los míos. (Básicamente, es DrJokepu, reducido a un solo 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();
}

Answer 3

De acuerdo, 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 las clases generadoras de código, Enumerable.Repeat lo hace por mí. Y sí, la versión de StringBuilder también está bien.

Answer 4

Desafortunadamente / afortunadamente, la clase de cadena está sellada por lo que no puede heredar de ella y sobrecargar el * operador. Puede crear un método de extensión, aunque:

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 5

En .NET 4 puedes hacer esto:

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

Answer 6

Esto es mucho más conciso:

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

El espacio de nombres using System.Text; debe ser importado en este caso.

Answer 7

Si tiene .Net 3.5 pero no 4.0, puede usar System.Linq''s

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

Answer 8

Solo por el hecho de estar completo, aquí hay 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 lo saqué de hace un tiempo, así que no es mi idea.

Answer 9

Tendría que escribir un método, por supuesto, con C # 3.0 podría ser un método de extensión:

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

entonces:

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

Answer 10

Tenga en cuenta que si su "cadena" es solo un carácter, hay una sobrecarga del constructor de cadena para manejarlo:

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

Answer 11

Un poco tarde (y solo por diversión), si realmente desea usar el operador * para este trabajo, 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 entonces:

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

Tenga en cuenta que, siempre que pueda encontrar un comportamiento razonable para ellos, también puede manejar otros operadores a través de la clase StringWrap , como / , ^ , % etc ...

PD:

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

Answer 12

Estoy con DrJokepu en este caso , pero si por alguna razón quieres hacer trampa usando la funcionalidad integrada, entonces podrías hacer algo como esto:

string snip = "</li></ul>";
int multiplier = 2;
string result = string.Join(snip, new string[multiplier + 1]);

O bien, si usa .NET 4:

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

Personalmente, no me molestaría, un método de extensión personalizado es mucho más agradable.

Answer 13

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