Quelle méthode de la classe String renvoie uniquement les N premiers caractères?

Je voudrais écrire une méthode d'extension à la Stringclasse afin que si la chaîne d'entrée est plus longue que la longueur fournie N, seul le premierN caractères doivent être affichés.

Voici à quoi cela ressemble:

public static string TruncateLongString(this string str, int maxLength)
{
    if (str.Length <= maxLength)
        return str;
    else
        //return the first maxLength characters                
}

Quelle String.*()méthode puis-je utiliser pour obtenir uniquement les premiers Ncaractères de str?

public static string TruncateLongString(this string str, int maxLength)
{
    if (string.IsNullOrEmpty(str))
        return str;
    return str.Substring(0, Math.Min(str.Length, maxLength));
}

string truncatedToNLength = new string(s.Take(n).ToArray());  

Cette solution a un petit avantage en ce que si n est supérieur à la longueur, elle fait toujours la bonne chose.

Vous pouvez utiliser LINQ str.Take(n)ou str.SubString(0, n), où ce dernier lèvera une ArgumentOutOfRangeExceptionexception pourn > str.Length .

L' esprit que la version LINQ renvoie IEnumerable<char>, vous auriez donc avoir à convertir le IEnumerable<char>à string: new string(s.Take(n).ToArray()).

Chaque fois que je dois faire des manipulations de chaînes en C #, je manque le bon vieux Leftet les Rightfonctions de Visual Basic, qui sont beaucoup plus simples à utiliser queSubstring .

Donc, dans la plupart de mes projets C #, je crée des méthodes d'extension pour eux:

public static class StringExtensions
{
    public static string Left(this string str, int length)
    {
        return str.Substring(0, Math.Min(length, str.Length));
    }

    public static string Right(this string str, int length)
    {
        return str.Substring(str.Length - Math.Min(length, str.Length));
    }
}

Remarque:
la Math.Minpartie est là car Substringjette unArgumentOutOfRangeException lorsque la longueur de la chaîne d'entrée est inférieure à la longueur demandée, comme déjà mentionné dans certains commentaires sous les réponses précédentes.

Usage:

string longString = "Long String";

// returns "Long";
string left1 = longString.Left(4);

// returns "Long String";
string left2 = longString.Left(100);

Simplement:

public static String Truncate(String input,int maxLength)
{
   if(input.Length > maxLength)
      return input.Substring(0,maxLength);
   return input;
}

public static string TruncateLongString(this string str, int maxLength)
{
    return str.Length <= maxLength ? str : str.Remove(maxLength);
}

si nous parlons de validations, pourquoi nous n'avons pas vérifié les entrées de chaîne nulle. Des raisons spécifiques?

Je pense que ci-dessous aide car IsNullOrEmpty est une méthode définie par le système et les opérateurs ternaires ont une complexité cyclomatique = 1 tandis que if () {} else {} a la valeur 2.

    public static string Truncate(string input, int truncLength)
    {
        return (!String.IsNullOrEmpty(input) && input.Length >= truncLength)
                   ? input.Substring(0, truncLength)
                   : input;
    }

J'ai ajouté cela dans mon projet simplement parce que là où je l'utilise, il y a de fortes chances qu'il soit utilisé dans des boucles, dans un projet hébergé en ligne, donc je ne voulais pas de crash si je pouvais le gérer. La longueur correspond à une colonne que j'ai. C'est C # 7

Juste une ligne:

 public static string SubStringN(this string Message, int Len = 499) => !String.IsNullOrEmpty(Message) ? (Message.Length >= Len ? Message.Substring(0, Len) : Message) : "";

La méthode .NET Substring est lourde de risques. J'ai développé des méthodes d'extension qui gèrent une grande variété de scénarios. La bonne chose est qu'il préserve le comportement d'origine, mais lorsque vous ajoutez un paramètre supplémentaire "true", il recourt ensuite à la méthode d'extension pour gérer l'exception et renvoie les valeurs les plus logiques, basées sur l'index et la longueur. Par exemple, si la longueur est négative et compte à rebours. Vous pouvez consulter les résultats des tests avec une grande variété de valeurs sur le violon à l' adresse : https://dotnetfiddle.net/m1mSH9 . Cela vous donnera une idée claire de la façon dont il résout les sous-chaînes.

J'ajoute toujours ces méthodes à tous mes projets et je n'ai jamais à me soucier de la rupture de code, car quelque chose a changé et l'index est invalide. Ci-dessous le code.

    public static String Substring(this String val, int startIndex, bool handleIndexException)
    {
        if (!handleIndexException)
        { //handleIndexException is false so call the base method
            return val.Substring(startIndex);
        }
        if (string.IsNullOrEmpty(val))
        {
            return val;
        }
        return val.Substring(startIndex < 0 ? 0 : startIndex > (val.Length - 1) ? val.Length : startIndex);
    }

    public static String Substring(this String val, int startIndex, int length, bool handleIndexException)
    {
        if (!handleIndexException)
        { //handleIndexException is false so call the base method
            return val.Substring(startIndex, length);
        }
        if (string.IsNullOrEmpty(val))
        {
            return val;
        }
        int newfrom, newlth, instrlength = val.Length;
        if (length < 0) //length is negative
        {
            newfrom = startIndex + length;
            newlth = -1 * length;
        }
        else //length is positive
        {
            newfrom = startIndex;
            newlth = length;
        }
        if (newfrom + newlth < 0 || newfrom > instrlength - 1)
        {
            return string.Empty;
        }
        if (newfrom < 0)
        {
            newlth = newfrom + newlth;
            newfrom = 0;
        }
        return val.Substring(newfrom, Math.Min(newlth, instrlength - newfrom));
    }

J'ai blogué à ce sujet en mai 2010 à l' adresse : http://jagdale.blogspot.com/2010/05/substring-extension-method-that-does.html

En partie à des fins de récapitulation (à l'exclusion de la solution LINQ), voici deux one-liners qui adressent la int maxLengthmise en garde d'autoriser des valeurs négatives et également le cas de la chaîne nulle:

1. Le Substringchemin (d'après la réponse de Paul Ruane ):

public static string Truncate(this string s, uint maxLength) =>
    s?.Substring(0, Math.Min(s.Length, (int)maxLength));

2. Le Removechemin (d' après la réponse de Kbrimington ):

public static string Truncate(this string s, uint maxLength) =>
    s?.Length > maxLength ? s.Remove((int)maxLength) : s;

substring(int startpos, int lenght);

string.Substring (0, n); // 0 - index de départ et n - nombre de caractères