Existe-t-il un moyen simple de renvoyer une chaîne répétée X fois?

J'essaie d'insérer un certain nombre d'indentations avant une chaîne en fonction de la profondeur des éléments et je me demande s'il existe un moyen de renvoyer une chaîne répétée X fois. Exemple:

string indent = "---";
Console.WriteLine(indent.Repeat(0)); //would print nothing.
Console.WriteLine(indent.Repeat(1)); //would print "---".
Console.WriteLine(indent.Repeat(2)); //would print "------".
Console.WriteLine(indent.Repeat(3)); //would print "---------".

Si vous ne souhaitez répéter que le même caractère, vous pouvez utiliser le constructeur de chaîne qui accepte un caractère et le nombre de fois pour le répéter new String(char c, int count).

Par exemple, pour répéter un tiret cinq fois:

string result = new String('-', 5);
Output: -----

Si vous utilisez .NET 4.0, vous pouvez l'utiliser string.Concatavec Enumerable.Repeat.

int N = 5; // or whatever
Console.WriteLine(string.Concat(Enumerable.Repeat(indent, N)));

Sinon, j'irais avec quelque chose comme la réponse d'Adam .

La raison pour laquelle je ne conseillerais généralement pas d' utiliser la réponse d'Andrey est simplement que l' ToArray()appel introduit des frais généraux superflus qui sont évités avec l' StringBuilderapproche suggérée par Adam. Cela dit, au moins cela fonctionne sans nécessiter .NET 4.0; et c'est rapide et facile (et ne va pas vous tuer si l'efficacité n'est pas trop une préoccupation).

public static class StringExtensions
{
    public static string Repeat(this string input, int count)
    {
        if (!string.IsNullOrEmpty(input))
        {
            StringBuilder builder = new StringBuilder(input.Length * count);

            for(int i = 0; i < count; i++) builder.Append(input);

            return builder.ToString();
        }

        return string.Empty;
    }
}

solution la plus performante pour la chaîne

string result = new StringBuilder().Insert(0, "---", 5).ToString();

Pour de nombreux scénarios, c'est probablement la solution la plus intéressante:

public static class StringExtensions
{
    public static string Repeat(this string s, int n)
        => new StringBuilder(s.Length * n).Insert(0, s, n).ToString();
}

L'utilisation est alors:

text = "Hello World! ".Repeat(5);

Cela s'appuie sur d'autres réponses (en particulier @ c0rd's). En plus de la simplicité, il présente les caractéristiques suivantes, que toutes les autres techniques discutées ne partagent pas:

• Répétition d'une chaîne de n'importe quelle longueur, pas seulement d'un caractère (comme demandé par l'OP).
• Utilisation efficace de StringBuilderla préallocation via le stockage.

Utilisez String.PadLeft , si la chaîne souhaitée ne contient qu'un seul caractère.

public static string Indent(int count, char pad)
{
    return String.Empty.PadLeft(count, pad);
}

Crédit dû ici

Vous pouvez répéter votre chaîne (au cas où ce ne serait pas un seul caractère) et concaténer le résultat, comme ceci:

String.Concat(Enumerable.Repeat("---", 5))

J'irais pour la réponse de Dan Tao, mais si vous n'utilisez pas .NET 4.0, vous pouvez faire quelque chose comme ça:

public static string Repeat(this string str, int count)
{
    return Enumerable.Repeat(str, count)
                     .Aggregate(
                        new StringBuilder(),
                        (sb, s) => sb.Append(s))
                     .ToString();
}

        string indent = "---";
        string n = string.Concat(Enumerable.Repeat(indent, 1).ToArray());
        string n = string.Concat(Enumerable.Repeat(indent, 2).ToArray());
        string n = string.Concat(Enumerable.Repeat(indent, 3).ToArray());

J'aime la réponse donnée. Dans le même esprit, c'est ce que j'ai utilisé dans le passé:

"" .PadLeft (3 * tiret, '-')

Cela remplira la création d'un retrait, mais techniquement, la question était de répéter une chaîne. Si le retrait de la chaîne est quelque chose comme> - <alors cela ainsi que la réponse acceptée ne fonctionneraient pas. Dans ce cas, la solution de c0rd utilisant stringbuilder semble bonne, bien que la surcharge de stringbuilder puisse en fait ne pas en faire la plus performante. Une option consiste à créer un tableau de chaînes, à le remplir de chaînes de retrait, puis à le concaténer. Pour:

int Indent = 2;

string[] sarray = new string[6];  //assuming max of 6 levels of indent, 0 based

for (int iter = 0; iter < 6; iter++)
{
    //using c0rd's stringbuilder concept, insert ABC as the indent characters to demonstrate any string can be used
    sarray[iter] = new StringBuilder().Insert(0, "ABC", iter).ToString();
}

Console.WriteLine(sarray[Indent] +"blah");  //now pretend to output some indented line

Nous aimons tous une solution intelligente, mais parfois simple est préférable.

Ajout de la méthode d'extension que j'utilise partout dans mes projets:

public static string Repeat(this string text, int count)
{
    if (!String.IsNullOrEmpty(text))
    {
        return String.Concat(Enumerable.Repeat(text, count));
    }
    return "";
}

J'espère que quelqu'un pourra en profiter ...

Surpris, personne n'est allé à la vieille école. Je ne fais aucune réclamation sur ce code, mais juste pour le plaisir:

public static string Repeat(this string @this, int count)
{
    var dest = new char[@this.Length * count];
    for (int i = 0; i < dest.Length; i += 1)
    {
        dest[i] = @this[i % @this.Length];
    }
    return new string(dest);
}

Je ne sais pas comment cela fonctionnerait, mais c'est un morceau de code facile. (Je l'ai probablement rendu plus compliqué qu'il ne l'est.)

int indentCount = 3;
string indent = "---";
string stringToBeIndented = "Blah";
// Need dummy char NOT in stringToBeIndented - vertical tab, anyone?
char dummy = '\v';
stringToBeIndented.PadLeft(stringToBeIndented.Length + indentCount, dummy).Replace(dummy.ToString(), indent);

Alternativement, si vous connaissez le nombre maximum de niveaux auxquels vous pouvez vous attendre, vous pouvez simplement déclarer un tableau et l'indexer. Vous voudrez probablement rendre ce tableau statique ou constant.

string[] indents = new string[4] { "", indent, indent.Replace("-", "--"), indent.Replace("-", "---"), indent.Replace("-", "----") };
output = indents[indentCount] + stringToBeIndented;      

Je n'ai pas assez de représentant pour commenter la réponse d'Adam, mais la meilleure façon de le faire imo est comme ceci:

public static string RepeatString(string content, int numTimes) {
        if(!string.IsNullOrEmpty(content) && numTimes > 0) {
            StringBuilder builder = new StringBuilder(content.Length * numTimes);

            for(int i = 0; i < numTimes; i++) builder.Append(content);

            return builder.ToString();
        }

        return string.Empty;
    }

Vous devez vérifier pour voir si numTimes est supérieur à zéro, sinon vous obtiendrez une exception.

Je n'ai pas vu cette solution. Je trouve cela plus simple pour ma situation actuelle en développement logiciel:

public static void PrintFigure(int shapeSize)
{
    string figure = "\\/";
    for (int loopTwo = 1; loopTwo <= shapeSize - 1; loopTwo++)
    {
        Console.Write($"{figure}");
    }
}

Pour une utilisation générale, les solutions impliquant la classe StringBuilder sont les meilleures pour répéter des chaînes à plusieurs caractères. Il est optimisé pour gérer la combinaison d'un grand nombre de chaînes d'une manière que la concaténation simple ne peut pas et qui serait difficile ou impossible à faire plus efficacement à la main. Les solutions StringBuilder présentées ici utilisent O (N) itérations pour terminer, un taux forfaitaire proportionnel au nombre de répétitions.

Cependant, pour un très grand nombre de répétitions, ou lorsque des niveaux élevés d'efficacité doivent être éliminés, une meilleure approche consiste à faire quelque chose de similaire aux fonctionnalités de base de StringBuilder mais à produire des copies supplémentaires à partir de la destination, plutôt qu'à partir de la chaîne d'origine, comme ci-dessous.

    public static string Repeat_CharArray_LogN(this string str, int times)
    {
        int limit = (int)Math.Log(times, 2);
        char[] buffer = new char[str.Length * times];
        int width = str.Length;
        Array.Copy(str.ToCharArray(), buffer, width);

        for (int index = 0; index < limit; index++)
        {
            Array.Copy(buffer, 0, buffer, width, width);
            width *= 2;
        }
        Array.Copy(buffer, 0, buffer, width, str.Length * times - width);

        return new string(buffer);
    }

Cela double la longueur de la chaîne source / destination à chaque itération, ce qui évite la réinitialisation des compteurs à chaque fois qu'elle parcourt la chaîne d'origine, au lieu de cela de lire et de copier en douceur la chaîne désormais beaucoup plus longue, ce que les processeurs modernes peuvent faire beaucoup. plus efficacement.

Il utilise un logarithme en base 2 pour trouver le nombre de fois qu'il a besoin de doubler la longueur de la chaîne, puis continue de le faire autant de fois. Étant donné que le reste à copier est désormais inférieur à la longueur totale à partir de laquelle il copie, il peut alors simplement copier un sous-ensemble de ce qu'il a déjà généré.

J'ai utilisé la méthode Array.Copy () sur l'utilisation de StringBuilder, car une copie du contenu de StringBuilder en lui-même aurait pour surcharge de produire une nouvelle chaîne avec ce contenu à chaque itération. Array.Copy () évite cela, tout en fonctionnant avec un taux d'efficacité extrêmement élevé.

Cette solution prend O (1 + log N) pour terminer, un taux qui augmente logarithmiquement avec le nombre de répétitions (doubler le nombre de répétitions équivaut à une itération supplémentaire), une économie substantielle par rapport aux autres méthodes, qui augmentent proportionnellement.

Une autre approche consiste à considérer stringcomme IEnumerable<char>et ont une méthode d'extension générique qui multipliera les éléments d'une collection par le facteur spécifié.

public static IEnumerable<T> Repeat<T>(this IEnumerable<T> source, int times)
{
    source = source.ToArray();
    return Enumerable.Range(0, times).SelectMany(_ => source);
}

Donc dans votre cas:

string indent = "---";
var f = string.Concat(indent.Repeat(0)); //.NET 4 required
//or
var g = new string(indent.Repeat(5).ToArray());

Imprimez une ligne avec répétition.

Console.Write(new string('=', 30) + "\n");

==============================

Vous pouvez créer une ExtensionMethod pour ce faire!

public static class StringExtension
{
  public static string Repeat(this string str, int count)
  {
    string ret = "";

    for (var x = 0; x < count; x++)
    {
      ret += str;
    }

    return ret;
  }
}

Ou en utilisant la solution @Dan Tao:

public static class StringExtension
{
  public static string Repeat(this string str, int count)
  {
    if (count == 0)
      return "";

    return string.Concat(Enumerable.Repeat(indent, N))
  }
}