Comment tronquer un .NET string?

Il n'y a pas un Truncate() méthode sur la chaîne, malheureusement. Vous devez écrire ce genre de logique vous-même. Ce que vous pouvez faire, cependant, est de conclure à une méthode d'extension de sorte que vous n'avez pas à faire de même 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);

J'ai pensé que je voudrais jeter dans mon application depuis je crois qu'il couvre tous les cas qui ont été abordés par les autres et le fait de manière concise qui est encore 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 surtout sur la Ray solution et ouvre la méthode pour l'utiliser comme une extension de la méthode à l'aide de la ce mot-clé juste comme LBushkin n' dans sa solution.

Vous pouvez utiliser LINQ... il élimine la nécessité de vérifier la longueur de la chaîne. Certes 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());

J'ai fait le mien dans une ligne un peu comme ce

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

L' .NET Framework a une API pour tronquer une chaîne de caractères comme ceci:

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

Mais dans une application en C#, vous aurez probablement mieux rouler que de prendre une dépendance sur Microsoft.VisualBasic.dll, dont la principale raison d'être est d'assurer la compatibilité ascendante.

Je sais que c'est une vieille question, mais voici une belle 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);

Retourne: bonjour...

Pas encore de méthode Tronquer en 2016 pour les chaînes de langage C#.
Mais - À L'Aide De C# 6.0 Syntaxe:

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"

Kndly noter que tronquer une chaîne pas simplement un moyen justing découpe une chaîne de caractères à une longueur spécifiée seul, mais prendre soin de ne pas diviser le mot.

par exemple de la chaîne : c'est une chaîne de test.

Je veux le couper à 11 . Si nous utilisons tout de la méthode donnée ci-dessus, le résultat sera

c'est de te

Ce n'est pas la chose que nous voulons

La méthode que je suis en utilisant peut pas être parfait, mais il peut gérer la plupart de la situation

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

Juste au cas où il n'y a pas assez de réponses, 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,"~")

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

Choix serait de gérer l'erreur dans un try/catch, serrer les maxLength paramètre min à 0, ou si maxLength est inférieure à 0 renvoie une chaîne vide.

Pas de code 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;
}

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

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

C'est pour la création d'Url SharePoint qui ont une longueur maximale de 260 caractères.

Je n'ai pas la longueur d'un paramètre, car c'est une constante 260. Je n'ai pas à faire la première sous-chaîne de longueur d'un paramètre parce que je veux un break à un moment précis. Enfin, la deuxième sous-chaîne est la longueur de la source - 20 car je sais que la structure des dossiers.

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

Mes deux cents à l'exemple de la longueur de 30 :

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

Comme un complément aux possibilités examinées ci-dessus, je voudrais partager ma solution.
C'est une méthode d'extension qui permet null (retourne la chaîne.Vide) il y a aussi un deuxième .Truncate() pour l'utiliser avec des points de suspension. Méfiez-vous, ce n'est pas une performance optimisée.

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

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
    }

Tronquer 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 "";
        }            
    }