Comment tronquer une chaîne .NET?


406

Je voudrais tronquer une chaîne de telle sorte que sa longueur ne dépasse pas une valeur donnée. J'écris dans une table de base de données et je veux m'assurer que les valeurs que j'écris respectent la contrainte du type de données de la colonne.

Par exemple, ce serait bien si je pouvais écrire ce qui suit:

string NormalizeLength(string value, int maxLength)
{
    return value.Substring(0, maxLength);
}

Malheureusement, cela déclenche une exception car maxLengthdépasse généralement les limites de la chaîne value. Bien sûr, je pouvais écrire une fonction comme la suivante, mais j'espérais que quelque chose comme ça existe déjà.

string NormalizeLength(string value, int maxLength)
{
    return value.Length <= maxLength ? value : value.Substring(0, maxLength);
} 

Où est l'API insaisissable qui effectue cette tâche? Est-ce qu'il y a un?


24
Pour mémoire, les chaînes sont immuables, vous ne pouvez pas les tronquer, vous ne pouvez en renvoyer qu'une copie tronquée. Nitpicky, je sais.
John Weldon

2
@John Weldon: C'est probablement pourquoi la fonction membre n'existe pas - elle ne suit pas la sémantique du type de données. Sur une note latérale, StringBuildervous permet de tronquer en raccourcissant la longueur, mais vous devez toujours effectuer la vérification de la longueur pour éviter d'élargir la chaîne.
Steve Guidi

1
Quelle que soit la solution que vous choisissez, assurez-vous d'ajouter une vérification pour une chaîne nulle avant d'appeler Substring ou d'accéder à la propriété Length.
Ray

3
@SteveGuidi - Si tel était le cas, il n'y aurait pas de fonctions comme Trim ou Replace, qui rencontrent des problèmes sémantiques similaires
Chris Rogers

1
@JohnWeldon Plus concis que Microsoft eux-mêmes le sont constamment, comme cela se produit - ils sont heureux de documenter, par exemple, .Trim()d'une manière qui donne un son trompeur comme s'il mute la chaîne: "Supprime tous les caractères d'espaces blancs de début et de fin du objet String actuel. "
Mark Amery

Réponses:


620

Il n'y a Truncate()malheureusement pas de méthode sur la chaîne. Vous devez écrire ce genre de logique vous-même. Ce que vous pouvez faire, cependant, c'est envelopper cela dans une méthode d'extension afin que vous n'ayez pas à le dupliquer partout:

public static class StringExt
{
    public static string Truncate(this string value, int maxLength)
    {
        if (string.IsNullOrEmpty(value)) return value;
        return value.Length <= maxLength ? value : value.Substring(0, maxLength); 
    }
}

Maintenant, nous pouvons écrire:

var someString = "...";
someString = someString.Truncate(2);

5
Excellente solution, mais rappelez-vous que cela ne fonctionne que dans NET 3.5 et versions ultérieures. Ne l'essayez pas dans NET2.0.
Jedi Master Spooky

7
Tant que vous êtes dans VS 2008, et probablement VS 2010, vous pouvez toujours le faire même si vous ciblez .Net 2.0. danielmoth.com/Blog/…
Mark

4
Cela échouera lorsque la maxLengthvaleur est négative.
Bernard

42
@Bernard, cela est censé échouer si maxLength est négatif. Tout autre comportement serait inattendu.
bojingo

12
Vous pouvez appeler des méthodes d'extension sur des valeurs nulles.
Joel Malone

127

Ou au lieu de l'opérateur ternaire, vous pouvez utiliser Math.min

public static class StringExt
{
    public static string Truncate( this string value, int maxLength )
    {
        if (string.IsNullOrEmpty(value)) { return value; }

        return value.Substring(0, Math.Min(value.Length, maxLength));
    }
}

10
Intelligent! Et l'expression suivante est optimisé pour renvoyer une référence à la chaîne d' origine: value.Substring(0, value.Length).
Steve Guidi

4
Malheureusement, il n'est pas optimisé pour les cas où value.Length est inférieur à MaxLength, ce qui peut être un cas courant dans certaines données. La propriété Longueur de la chaîne doit également être mise en majuscule.
jpierson

1
Cela échouera lorsque la maxLengthvaleur est négative.
Bernard

7
@Bernard, il en sera beaucoup de choses dans le cadre ... mais si je vérifier ... J'ai soit par défaut maxLengthà 0ou value.Length; ou j'ai besoin de lancer un ArgumentOutOfRangeException... qui a plus de sens dans ce cas, et qui est déjà lancé de Substringtoute façon.
CaffGeek

2
Un peu plus court:return string.IsNullOrEmpty(value) ? value : value.Substring(0, Math.Min(value.Length, maxLength));
user1127860

43

J'ai pensé que je mettrais ma mise en œuvre car je pense qu'elle couvre tous les cas qui ont été abordés par les autres et le fait d'une manière concise qui est toujours lisible.

public static string Truncate(this string value, int maxLength)
{
    if (!string.IsNullOrEmpty(value) && value.Length > maxLength)
    {
        return value.Substring(0, maxLength);
    }

    return value;
}

Cette solution s'appuie principalement sur la solution de Ray et ouvre la méthode à utiliser comme méthode d'extension en utilisant le mot-clé this, tout comme LBushkin le fait dans sa solution.


Cela échouera lorsque maxLength valeur est négative.
Bernard

15
@Bernard - Je recommanderais de ne pas passer une valeur négative pour l'argument maxLength car c'est une valeur inattendue. La méthode Substring adopte la même approche, il n'y a donc aucune raison d'améliorer l'exception qu'elle lève.
jpierson

Je ne pense pas que la vérification IsNullOrEmpty soit nécessaire? (1) Si la valeur est nulle, il ne devrait y avoir aucun moyen d'appeler cette méthode d'extension dessus. (2) Si valeur est la chaîne vide, la vérification value.Length> maxLength échouera.
Jon Schneider

8
@JonSchneider, IsNullOrEmpty est requis car il s'agit d'une méthode d'extension. Si une variable de type chaîne a été affectée d'une valeur null, le compilateur n'insère pas de vérification null avant d'appeler cette méthode. Techniquement, il s'agit toujours d'une méthode statique de la classe statique. Donc: stringVar.Truncate (2) Compile comme: StringExt.Truncate (stringVar, 2);
Jeff B

40

Parce que les tests de performances sont amusants: (en utilisant les méthodes d'extension linqpad )

var val = string.Concat(Enumerable.Range(0, 50).Select(i => i % 10));

foreach(var limit in new[] { 10, 25, 44, 64 })
    new Perf<string> {
        { "newstring" + limit, n => new string(val.Take(limit).ToArray()) },
        { "concat" + limit, n => string.Concat(val.Take(limit)) },
        { "truncate" + limit, n => val.Substring(0, Math.Min(val.Length, limit)) },
        { "smart-trunc" + limit, n => val.Length <= limit ? val : val.Substring(0, limit) },
        { "stringbuilder" + limit, n => new StringBuilder(val, 0, Math.Min(val.Length, limit), limit).ToString() },
    }.Vs();

La truncateméthode était "significativement" plus rapide. #microoptimisation

De bonne heure

  • truncate10 5788 ticks écoulés (0,5788 ms) [en 10 000 répétitions, 5,788E-05 ms par]
  • smart-trunc10 8206 ticks écoulés (0,8206 ms) [en 10 000 répétitions, 8,206E-05 ms par]
  • stringbuilder10 10557 ticks écoulés (1,0557 ms) [en 10 000 répétitions, 0,00010557 ms par]
  • concat10 45495 ticks écoulés (4,5495 ms) [en 10 000 répétitions, 0,00045495 ms par]
  • newstring10 72535 ticks écoulés (7,2535 ms) [en 10 000 répétitions, 0,00072535 ms par]

En retard

  • truncate44 8835 ticks écoulés (0,8835 ms) [en 10 000 répétitions, 8,835E-05 ms par]
  • stringbuilder44 13106 ticks écoulés (1,3106 ms) [en 10 000 répétitions, 0,00013106 ms par]
  • smart-trunc44 14821 ticks écoulés (1,4821 ms) [en 10 000 répétitions, 0,00014821 ms par]
  • newstring44 144324 ticks écoulés (14,4324 ms) [en 10 000 répétitions, 0,00144324 ms par]
  • concat44 174610 ticks écoulés (17,461 ms) [en 10 000 répétitions, 0,0017461 ms par]

Trop long

  • smart-trunc64 6944 ticks écoulés (0,6944 ms) [en 10 000 répétitions, 6,944E-05 ms par]
  • truncate64 7686 ticks écoulés (0,7686 ms) [en 10 000 répétitions, 7,686E-05 ms par]
  • stringbuilder64 13314 ticks écoulés (1,3314 ms) [en 10 000 répétitions, 0,00013314 ms par]
  • newstring64 177481 ticks écoulés (17,7481 ms) [en 10 000 répétitions, 0,00177481 ms par]
  • concat64 241601 ticks écoulés (24.1601 ms) [en 10 000 répétitions, 0,00241601 ms par]

Merci pour tous les repères utiles! ... et Linkpad est génial!
Sunsetquest

jamais fait attention à ce que linqpad puisse faire ces choses
jefissu

38

Dans .NET 4.0, vous pouvez utiliser la Takeméthode:

string.Concat(myString.Take(maxLength));

Non testé pour l'efficacité!


27

Vous pouvez utiliser LINQ ... cela élimine le besoin de vérifier la longueur des chaînes. Certes, ce n'est peut-être pas le plus efficace, mais c'est amusant.

string result = string.Join("", value.Take(maxLength)); // .NET 4 Join

ou

string result = new string(value.Take(maxLength).ToArray());

2
pourquoi n'est-ce pas la réponse acceptée? Qu'est-ce qui est le plus simple, écrire votre propre méthode d'extension que vous devez maintenir / documenter, ou utiliser quelque chose INTÉGRÉ comme .Prenez
Don Cheadle

9
@mmcrae Linq est peut-être plus simple, mais c'est aussi beaucoup plus lent. Mon benchmark indique ~ 400 ms pour Linq et seulement ~ 24 ms pour Substring pour 1 million d'itérations.
Hein Andre Grønnestad

Cette solution ne doit jamais être utilisée. Comme indiqué dans deux commentaires ci-dessus, il y a toujours une allocation de mémoire, même lorsque la chaîne existante n'est pas plus grande que la longueur maximale. C'est aussi très lent.
Kamarey

15

J'ai fait le mien sur une ligne un peu comme ça

value = value.Length > 1000 ? value.Substring(0, 1000) : value;

2
-1; cela n'ajoute rien du tout qui n'était pas déjà dans la réponse acceptée.
Mark Amery

2
@markamery est une alternative plus courte avec moins de code à écrire et à mettre à jour lorsque vous en avez besoin. Vous ne l'aimez pas? Ne l'utilisez pas
SeanMC

Rapide, simple et rapide. Voilà ce dont j'avais besoin. Merci!
Peter

14

Apparemment, personne n'a encore posté ceci:

public static class StringExt
{
    public static string Truncate(this string s, int maxLength)
    {
        return s != null && s.Length > maxLength ? s.Substring(0, maxLength) : s;
    }
}

L'utilisation de l'opérateur && le rend légèrement meilleur que la réponse acceptée.


13

Le .NET Framework possède une API pour tronquer une chaîne comme celle-ci:

Microsoft.VisualBasic.Strings.Left(string, int);

Mais dans une application C #, vous préférerez probablement rouler la vôtre plutôt que de dépendre de Microsoft.VisualBasic.dll, dont la principale raison d'être est la compatibilité descendante.


"Le .NET Framework a une API" vous vous contredisez. C'est une API VB.NET
Camilo Terevinto

9
@CamiloTerevinto - c'est une API livrée avec le .NET Framework, et peut être appelée à partir de n'importe quel langage managé.
Joe

1
La DLL VB contient beaucoup de bonnes choses. Pourquoi tant de développeurs c # s'y opposent-ils?
Michael Z.

Pas de support .NET Core actuellement, malheureusement. En effet, l'ensemble des Microsoft.VisualBasic.Stringsmodules de .NET Core est assez vide .
Mark Amery

1
Bien que je sois d'accord avec le commentaire de Joe, je ne me sens toujours pas bien d'appeler quelque chose de spécifique pour VB à partir d'autres langues. S'il y a tellement de bonnes choses dans "DLL VB", pourquoi ne pas les mettre dans un endroit partagé? Qui sait ce que Microsoft fera de ces choses demain? Arrêtez le support ou quelque chose ..
Kamarey


6

Je sais que c'est une vieille question, mais voici une bonne solution:

public static string Truncate(this string text, int maxLength, string suffix = "...")
{
    string str = text;
    if (maxLength > 0)
    {
        int length = maxLength - suffix.Length;
        if (length <= 0)
        {
            return str;
        }
        if ((text != null) && (text.Length > maxLength))
        {
            return (text.Substring(0, length).TrimEnd(new char[0]) + suffix);
        }
    }
    return str;
}

var myString = "hello world"
var myTruncatedString = myString.Truncate(4);

Retours: bonjour ...


@SarjanWebDev Ce caractère spécial apparaît comme "." dans cmd.exe
Neal Ehardt

5

Une variante similaire avec l'opérateur de propagation Null de C # 6

public static string Truncate(this string value, int maxLength)
{
    return value?.Length <= maxLength ? value : value?.Substring(0, maxLength);
}

Veuillez noter que nous vérifions essentiellement si la valeur valueest nulle deux fois ici.


5

Toujours pas de méthode Truncate en 2016 pour les chaînes C #. Mais - Utilisation de la syntaxe C # 6.0:

public static class StringExtension
{
  public static string Truncate(this string s, int max) 
  { 
    return s?.Length > max ? s.Substring(0, max) : s ?? throw new ArgumentNullException(s); 
  }
}

Il fonctionne comme un charme:

"Truncate me".Truncate(8);
Result: "Truncate"

4

Prendre @CaffGeek et le simplifier:

public static string Truncate(this string value, int maxLength)
    {
        return string.IsNullOrEmpty(value) ? value : value.Substring(0, Math.Min(value.Length, maxLength));
    }

4

Notez que tronquer une chaîne ne signifie pas simplement couper une chaîne à une longueur spécifiée, mais il faut faire attention de ne pas diviser le mot.

par exemple chaîne: il s'agit d'une chaîne de test.

Je veux le couper à 11 heures. Si nous utilisons l'une des méthodes indiquées ci-dessus, le résultat sera

c'est un te

Ce n'est pas ce que nous voulons

La méthode que j'utilise n'est peut-être pas aussi parfaite, mais elle peut gérer la plupart des situations

public string CutString(string source, int length)
{
        if (source== null || source.Length < length)
        {
            return source;
        }
        int nextSpace = source.LastIndexOf(" ", length);
        return string.Format("{0}...", input.Substring(0, (nextSpace > 0) ? nextSpace : length).Trim());
} 

4

Pourquoi pas:

string NormalizeLength(string value, int maxLength)
{
    //check String.IsNullOrEmpty(value) and act on it. 
    return value.PadRight(maxLength).Substring(0, maxLength);
}

c'est-à-dire dans les value.Length < maxLengthespaces du pad d' événement jusqu'à la fin ou tronquer l'excédent.


Vous générez deux fois plus d'objets chaîne et cela pourrait lever une NullReferenceException à partir de l'appel PadRight si la valeur est nulle, ce qui est inapproprié, ce devrait être une ArgumentNullException.
Jeremy

1
@Jeremy Je ne comprends pas "cela pourrait lever une NullReferenceException de l'appel PadRight si la valeur est nulle"; n'ai-je pas mentionné "// vérifier la chaîne. IsNullOrEmpty (valeur) et agir en conséquence".
Sri

3

Juste au cas où il n'y aurait pas assez de réponses ici, voici la mienne :)

public static string Truncate(this string str, 
                              int totalLength, 
                              string truncationIndicator = "")
{
    if (string.IsNullOrEmpty(str) || str.Length < totalLength) 
        return str;

    return str.Substring(0, totalLength - truncationIndicator.Length) 
           + truncationIndicator;
}

utiliser:

"I use it like this".Truncate(5,"~")

2

Par souci de (sur) complexité, j'ajouterai ma version surchargée qui remplace les 3 derniers caractères par des points de suspension par rapport au paramètre maxLength.

public static string Truncate(this string value, int maxLength, bool replaceTruncatedCharWithEllipsis = false)
{
    if (replaceTruncatedCharWithEllipsis && maxLength <= 3)
        throw new ArgumentOutOfRangeException("maxLength",
            "maxLength should be greater than three when replacing with an ellipsis.");

    if (String.IsNullOrWhiteSpace(value)) 
        return String.Empty;

    if (replaceTruncatedCharWithEllipsis &&
        value.Length > maxLength)
    {
        return value.Substring(0, maxLength - 3) + "...";
    }

    return value.Substring(0, Math.Min(value.Length, maxLength)); 
}

2

Mes deux cents avec une longueur d'exemple de 30:

  var truncatedInput = string.IsNullOrEmpty(input) ? 
      string.Empty : 
      input.Substring(0, Math.Min(input.Length, 30));

1

Je préfère la réponse de jpierson, mais aucun des exemples ici que je peux voir ne gère un paramètre maxLength invalide, comme lorsque maxLength <0.

Les choix seraient soit de gérer l'erreur dans un essai / rattraper, de fixer le paramètre maxLength min à 0, ou si maxLength est inférieur à 0, de renvoyer une chaîne vide.

Code non optimisé:

public string Truncate(this string value, int maximumLength)
{
    if (string.IsNullOrEmpty(value) == true) { return value; }
    if (maximumLen < 0) { return String.Empty; }
    if (value.Length > maximumLength) { return value.Substring(0, maximumLength); }
    return value;
}

3
Notez que dans mon implémentation, j'ai choisi de ne pas gérer le cas où maximumLength est inférieur à 0 parce que je pensais que la seule chose que je ferais serait de lancer un ArgumentOutOfRangeExcpetion qui essentiellement ce que string.Substring () fait pour moi.
jpierson

1

Voici une solution vb.net, notez que l'instruction if (bien que laide) améliore les performances car nous n'avons pas besoin de l'instruction substring lorsque la chaîne est déjà plus petite que maxlength ... En en faisant une extension à string, elle est facile à utiliser. ..

 <System.Runtime.CompilerServices.Extension()> _
    Public Function Truncate(String__1 As String, maxlength As Integer) As String
        If Not String.IsNullOrEmpty(String__1) AndAlso String__1.Length > maxlength Then
            Return String__1.Substring(0, maxlength)
        Else
            Return String__1
        End If
    End Function

Dans VB.net, vous pouvez remplacer "Not String.IsNullOrEmpty (String__1)" par "String__1 <> Nothing". C'est un peu plus court. La valeur par défaut des chaînes est une chaîne vide. L'utilisation de "<> Nothing" vérifie à la fois la casse nulle et la chaîne vide. Testez-le avec: Truncate ("", 50) et Truncate (Nothing, 50)
jrjensen

En VB, vous pouvez faire Left (string, maxlength)
Michael Z.

1

Je sais qu'il y a déjà une tonne de réponses, mais mon besoin était de garder le début et la fin de la chaîne intacts, mais de les raccourcir sous la longueur maximale.

    public static string TruncateMiddle(string source)
    {
        if (String.IsNullOrWhiteSpace(source) || source.Length < 260) 
            return source;

        return string.Format("{0}...{1}", 
            source.Substring(0, 235),
            source.Substring(source.Length - 20));
    }

Il s'agit de créer des URL SharePoint d'une longueur maximale de 260 caractères.

Je n'ai pas fait de la longueur un paramètre car c'est une constante 260. Je n'ai pas non plus fait de la première longueur de sous-chaîne un paramètre parce que je veux qu'elle se casse à un point spécifique. Enfin, la deuxième sous-chaîne est la longueur de la source - 20 puisque je connais la structure des dossiers.

Cela pourrait facilement être adapté à vos besoins spécifiques.


1

Je sais qu'il y a déjà une tonne de réponses ici, mais c'est celle avec laquelle je suis allé, qui gère à la fois les chaînes nulles et la situation où la longueur passée est négative:

public static string Truncate(this string s, int length)
{
    return string.IsNullOrEmpty(s) || s.Length <= length ? s 
        : length <= 0 ? string.Empty 
        : s.Substring(0, length);
}

1

En C # 8, la nouvelle fonctionnalité Ranges peut être utilisée ...

value = value[..Math.Min(30, value.Length)];

0

Il n'y a rien dans .net pour cela que je sache - voici ma version qui ajoute "...":

public static string truncateString(string originalString, int length) {
  if (string.IsNullOrEmpty(originalString)) {
   return originalString;
  }
  if (originalString.Length > length) {
   return originalString.Substring(0, length) + "...";
  }
  else {
   return originalString;
  }
}

2
Votre version donnera des chaînes de 3 caractères plus longues que la longueur demandée, au cas où elles seraient tronquées. De plus, les triples points n'ont vraiment de sens que dans la représentation, je ne les stockerais pas dans une base de données comme celle qui est le cas d'utilisation donné par l'OP.
MarioDS

0

TruncateString

public static string _TruncateString(string input, int charaterlimit)
{
    int characterLimit = charaterlimit;
    string output = input;

    // Check if the string is longer than the allowed amount
    // otherwise do nothing
    if (output.Length > characterLimit && characterLimit > 0)
    {
        // cut the string down to the maximum number of characters
        output = output.Substring(0, characterLimit);
        // Check if the character right after the truncate point was a space
        // if not, we are in the middle of a word and need to remove the rest of it
        if (input.Substring(output.Length, 1) != " ")
        {
            int LastSpace = output.LastIndexOf(" ");

            // if we found a space then, cut back to that space
            if (LastSpace != -1)
            {
                output = output.Substring(0, LastSpace);
            }
        }
        // Finally, add the "..."
        output += "...";
    }
    return output;
}

2
Pourquoi faites-vous précéder le nom de votre méthode publique d'un trait de soulignement?
Michael Z.

0

En plus des possibilités discutées ci-dessus, je voudrais partager ma solution. C'est une méthode d'extension qui permet null (retourne string.Empty) et il y a un second .Truncate () pour l'utiliser avec des points de suspension. Attention, ce n'est pas des performances optimisées.

public static string Truncate(this string value, int maxLength) =>
    (value ?? string.Empty).Substring(0, (value?.Length ?? 0) <= (maxLength < 0 ? 0 : maxLength) ? (value?.Length ?? 0) : (maxLength < 0 ? 0 : maxLength));
public static string Truncate(this string value, int maxLength, string ellipsis) =>
    string.Concat(value.Truncate(maxLength - (((value?.Length ?? 0) > maxLength ? ellipsis : null)?.Length ?? 0)), ((value?.Length ?? 0) > maxLength ? ellipsis : null)).Truncate(maxLength);

-1
public static string Truncate( this string value, int maxLength )
    {
        if (string.IsNullOrEmpty(value)) { return value; }

        return new string(value.Take(maxLength).ToArray());// use LINQ and be happy
    }

L' ToArray()appel ici est juste des frais généraux inutiles; en utilisant par exemple, String.Concatvous pouvez construire une chaîne à partir d'un nombre de caractères sans avoir à passer par un tableau.
Mark Amery

-3

Tronquer la chaîne

public static string TruncateText(string strText, int intLength)
{
    if (!(string.IsNullOrEmpty(strText)))
    {                                
        // split the text.
        var words = strText.Split(' ');

        // calculate the number of words
        // based on the provided characters length 
        // use an average of 7.6 chars per word.
        int wordLength = Convert.ToInt32(Math.Ceiling(intLength / 7.6));

        // if the text is shorter than the length,
        // display the text without changing it.
        if (words.Length <= wordLength)
            return strText.Trim();                

        // put together a shorter text
        // based on the number of words
        return string.Join(" ", words.Take(wordLength)) + " ...".Trim();
    }
        else
        {
            return "";
        }            
    }

Cela ne répond pas à la question du PO. Tout d'abord, il doit s'agir d'une fonction membre (bien que vous l'ayez écrite comme méthode d'extension). Deuxièmement, l'OP ne précise pas que le texte doit être divisé et que les mots doivent être tronqués à env. 7,6 caractères par mot.
Wicher Visser

7.6 n'est qu'un nombre. vous pouvez écrire tout autre numéro que vous souhaitez. Il s'agissait d'une longueur moyenne de mots anglais. Je l'ai trouvé sur Google. Utiliser le fractionnement est juste un moyen facile de décomposer les mots par espace. Je ne pense pas que vous vouliez afficher un demi-mot! Donc, à moins que vous ne parcouriez pour trouver un espace vide qui nécessitera plus de code, c'est un moyen facile de tronquer une chaîne et d'afficher des mots entiers. Cela vous assurera qu'une chaîne n'est pas plus longue que la longueur donnée et vous n'aurez pas de mots cassés.
VT

-4

Voici le code que j'utilise habituellement:

string getSubString(string value, int index, int length)
        {
            if (string.IsNullOrEmpty(value) || value.Length <= length)
            {
                return value;
            }
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            for (int i = index; i < length; i++)
            {
                sb.AppendLine(value[i].ToString());
            }
            return sb.ToString();
        }

5
Veuillez noter que la concaténation de chaînes avec + = est une opération coûteuse, en particulier lors de la reconstruction caractère par caractère. Les chaînes .NET sont immuables, ce qui signifie que dans ce cas, une nouvelle chaîne est créée à chaque fois dans votre boucle.
Steve Guidi

Les chaînes @SteveGuidi ne sont pas immuables, elles se font juste passer pour immuables. Je souhaite que les chaînes soient de véritables primitives immuables afin que je puisse avoir une chaîne et une chaîne?, Mais hélas, ce ne sont pas des primitives.
Chris Marisic

Vous dites cher comme si le coût des performances était important, je l'ai changé pour utiliser stringBuilder mais je trouve qu'avec + = il est plus facile de voir ce qui se passe, je voulais juste que l'OP comprenne facilement le code.
user3390116
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.