web-dev-qa-db-fra.com

Meilleure façon de répéter un caractère en C #

Quel est le meilleur moyen de générer une chaîne de \t en C #?

J'apprends le C # et expérimente différentes façons de dire la même chose. 

Tabs(uint t) est une fonction qui renvoie string avec t quantité de \t '

Par exemple, Tabs(3) renvoie "\t\t\t"

Laquelle de ces trois façons de mettre en œuvre Tabs(uint numTabs) est la meilleure?

Bien sûr, cela dépend de ce que «meilleur» signifie. 

  1. La version LINQ n’est que deux lignes, ce qui est Nice. Mais les appels à Répéter et Regrouper consomment-ils inutilement du temps ou des ressources?

  2. La version StringBuilder est très claire, mais la classe StringBuilder est-elle en quelque sorte plus lente?

  3. La version string est basique, ce qui signifie qu’elle est facile à comprendre. 

  4. Est-ce que ça n'a pas d'importance? Sont-ils tous égaux?

Ce sont toutes des questions qui m'aideront à mieux comprendre C #. 

private string Tabs(uint numTabs)
{
    IEnumerable<string> tabs = Enumerable.Repeat("\t", (int) numTabs);
    return (numTabs > 0) ? tabs.Aggregate((sum, next) => sum + next) : ""; 
}  

private string Tabs(uint numTabs)
{
    StringBuilder sb = new StringBuilder();
    for (uint i = 0; i < numTabs; i++)
        sb.Append("\t");

    return sb.ToString();
}  

private string Tabs(uint numTabs)
{
    string output = "";
    for (uint i = 0; i < numTabs; i++)
    {
        output += '\t';
    }
    return output; 
}
c#.netstring
667
Alex Baranosky

Et ça:

string tabs = new String('\t', n);

Où n est le nombre de fois que vous souhaitez répéter la chaîne.

Ou mieux:

static string Tabs(int n)
{
    return new String('\t', n);
}
1283
CMS
string.Concat(Enumerable.Repeat("ab", 2));

Résultats

"abab"

Et

string.Concat(Enumerable.Repeat("a", 2));

Résultats

"aa"

de...

Y a-t-il une fonction intégrée pour répéter une chaîne ou un caractère dans .net?

116
Carter Medlin

Dans toutes les versions de .NET, vous pouvez répéter une chaîne de la manière suivante:

public static string Repeat(string value, int count)
{
    return new StringBuilder(value.Length * count).Insert(0, value, count).ToString();
}

Pour répéter un caractère, new String('\t', count) est votre meilleur choix. Voir la réponse de @CMS .

113
Binoj Antony

La meilleure version est certainement d'utiliser la méthode intégrée:

string Tabs(int len) { return new string('\t', len); }

Parmi les autres solutions, préférez la plus facile; si cela s'avère trop lent, essayez d'obtenir une solution plus efficace.

Si vous utilisez une variable StringBuilder et que vous connaissez sa longueur à l'avance, utilisez également un constructeur approprié, ce qui est beaucoup plus efficace car cela signifie qu'une seule affectation chronophage a lieu et qu'aucune copie inutile de données n'est nécessaire. Nonsense: bien sûr, le code ci-dessus est plus efficace.

59
Konrad Rudolph

Méthodes d'extension: 

public static string Repeat(this string s, int n)
{
    return new String(Enumerable.Range(0, n).SelectMany(x => s).ToArray());
}

public static string Repeat(this char c, int n)
{
    return new String(c, n);
}
48
Rodrick Chapman

Qu'en est-il de l'utilisation de la méthode d'extension? 

public static class StringExtensions
{
   public static string Repeat(this char chatToRepeat, int repeat) {

       return new string(chatToRepeat,repeat);
   }
   public  static string Repeat(this string stringToRepeat,int repeat)
   {
       var builder = new StringBuilder(repeat*stringToRepeat.Length);
       for (int i = 0; i < repeat; i++) {
           builder.Append(stringToRepeat);
       }
       return builder.ToString();
   }
}

Vous pourriez alors écrire: 

Debug.WriteLine('-'.Repeat(100)); // For Chars  
Debug.WriteLine("Hello".Repeat(100)); // For Strings

Notez qu'un test de performance consistant à utiliser la version de Stringbuilder pour des caractères simples au lieu de chaînes vous donne une pénalité de préformance majeure: .Repeat (1000000)) // version char et
Debug.WriteLine ("-". Repeat (1000000)) // version de chaîne

40
Ronnie

Que dis-tu de ça:

//Repeats a character specified number of times
public static string Repeat(char character,int numberOfIterations)
{
    return "".PadLeft(numberOfIterations, character);
}

//Call the Repeat method
Console.WriteLine(Repeat('\t',40));
22
Denys Wessels

Je sais que cette question a déjà cinq ans, mais il existe un moyen simple de répéter une chaîne qui fonctionne même en .Net 2.0.

Pour répéter une chaîne:

string repeated = new String('+', 3).Replace("+", "Hello, ");

Résultats

"Bonjour bonjour bonjour, "

Pour répéter une chaîne sous forme de tableau:

// Two line version.
string repeated = new String('+', 3).Replace("+", "Hello,");
string[] repeatedArray = repeated.Split(',');

// One line version.
string[] repeatedArray = new String('+', 3).Replace("+", "Hello,").Split(',');

Résultats

{"Bonjour bonjour bonjour", ""}

Rester simple.

19
ChaimG

Supposons que vous souhaitiez répéter le nombre de fois que vous pouvez utiliser;

String.Empty.PadRight(n,'\t')
16
Amin

Votre premier exemple qui utilise Enumerable.Repeat:

private string Tabs(uint numTabs)
{
    IEnumerable<string> tabs = Enumerable.Repeat(
                                 "\t", (int) numTabs);
    return (numTabs > 0) ? 
            tabs.Aggregate((sum, next) => sum + next) : ""; 
}

peut être réécrit de manière plus compacte avec String.Concat:

private string Tabs(uint numTabs)
{       
    return String.Concat(Enumerable.Repeat("\t", (int) numTabs));
}
15
Ray Vega

Utiliser String.Concat et Enumerable.Repeat, ce qui coûtera moins cher .__ que d'utiliser String.Join

public static Repeat(this String pattern, int count)
{
    return String.Concat(Enumerable.Repeat(pattern, count));
}
14
bradgonesurfing
var str = new string(Enumerable.Repeat('\t', numTabs).ToArray());
8
w.b

La réponse dépend vraiment de la complexité que vous souhaitez. Par exemple, je veux mettre en évidence tous mes retraits avec une barre verticale, ainsi ma chaîne de retrait est déterminée comme suit:

return new string(Enumerable.Range(0, indentSize*indent).Select(
  n => n%4 == 0 ? '|' : ' ').ToArray());
4
Dmitri Nesteruk

Vous pouvez créer une méthode d'extension

static class MyExtensions
{
    internal static string Repeat(this char c, int n)
    {
        return new string(c, n);
    }
}

Ensuite, vous pouvez l'utiliser comme ça

Console.WriteLine('\t'.Repeat(10));
2
ivan

Sans aucun doute, la réponse acceptée est le moyen le plus rapide et le meilleur de répéter un seul caractère.

La réponse de Binoj Anthony est un moyen simple et très efficace de répéter une chaîne.

Cependant, si cela ne vous dérange pas un peu plus de code, vous pouvez utiliser ma technique de remplissage de tableau pour créer efficacement ces chaînes encore plus rapidement. Dans mes tests de comparaison, le code ci-dessous était exécuté environ 35% du temps du code StringBuilder.Insert. 

public static string Repeat(this string value, int count)
{
    var values = new char[count * value.Length];
    values.Fill(value.ToCharArray());
    return new string(values);
}

public static void Fill<T>(this T[] destinationArray, params T[] value)
{
    if (destinationArray == null)
    {
        throw new ArgumentNullException("destinationArray");
    }

    if (value.Length > destinationArray.Length)
    {
        throw new ArgumentException("Length of value array must not be more than length of destination");
    }

    // set the initial array value
    Array.Copy(value, destinationArray, value.Length);

    int copyLength, nextCopyLength;

    for (copyLength = value.Length; (nextCopyLength = copyLength << 1) < destinationArray.Length; copyLength = nextCopyLength)
    {
        Array.Copy(destinationArray, 0, destinationArray, copyLength, copyLength);
    }

    Array.Copy(destinationArray, 0, destinationArray, copyLength, destinationArray.Length - copyLength);
}

Pour plus d'informations sur cette technique de remplissage de tableau, voir Le moyen le plus rapide de remplir un tableau avec une seule valeur

1
Grax

Pour moi c'est bien:

public static class Utils
{
    public static string LeftZerosFormatter(int zeros, int val)
    {
        string valstr = val.ToString();

        valstr = new string('0', zeros) + valstr;

        return valstr.Substring(valstr.Length - zeros, zeros);
    }
}
1
Ángel Ibáñez

Et encore une autre méthode 

new System.Text.StringBuilder().Append('\t', 100).ToString()
1
Artyom

Essaye ça:

  1. Ajouter une référence Microsoft.VisualBasic
  2. Use: String result = Microsoft.VisualBasic.Strings.StrDup (5, "hi");
  3. Dites-moi si cela marche pour vous.
0
Toso Pankovski