Docs C# exécutables : Substring

Q: Comment fonctionne Substring en C# ?

s.Substring(start) renvoie les caractères de l'index start jusqu'à la fin ; s.Substring(start, length) renvoie length caractères à partir de start. Les index commencent à 0, et le second argument est une longueur, pas un index de fin : "Hello".Substring(1, 3) vaut "ell". La chaîne d'origine n'est pas modifiée.

Q: Pourquoi Substring lève-t-il ArgumentOutOfRangeException ?

Parce que start est négatif ou supérieur à la longueur de la chaîne, ou que start + length dépasse la fin. La cause la plus fréquente est une longueur calculée pour une chaîne plus longue, ou un résultat d'IndexOf égal à -1 utilisé comme départ. Bornez la longueur avec Math.Min(length, s.Length - start) et vérifiez les résultats d'IndexOf avant de les utiliser.

Q: Comment obtenir les n derniers caractères d'une chaîne en C# ?

s.Substring(s.Length - n) renvoie les n derniers caractères, à condition que n <= s.Length. Pour être sûr avec les chaînes courtes, utilisez s.Length <= n ? s : s.Substring(s.Length - n). Depuis C# 8, vous pouvez aussi écrire s[^n..], qui lève la même exception quand n est trop grand.

Q: Comment obtenir la sous-chaîne entre deux caractères en C# ?

Trouvez les deux positions avec IndexOf, puis prenez la partie située entre elles : int start = s.IndexOf('(') + 1; int end = s.IndexOf(')', start); string inside = s.Substring(start, end - start);. Vérifiez que chaque IndexOf a trouvé quelque chose (pas -1) avant d'appeler Substring. Pour des motifs complexes, une expression régulière est plus claire.

Q: Substring commence-t-il à zéro en C# ?

Oui. Le premier caractère est à l'index 0 et le dernier à Length - 1. Substring(0, 3) renvoie les trois premiers caractères. Passer Length lui-même comme départ est autorisé et renvoie une chaîne vide.

Substring renvoie une nouvelle chaîne formée d'une partie d'une chaîne existante. La méthode a deux surcharges :

s.Substring(startIndex) : de startIndex jusqu'à la fin.
s.Substring(startIndex, length) : length caractères, à partir de startIndex.

Les index commencent à 0, et le second argument est une longueur, pas une position de fin. C'est la différence avec substring(start, end) de JavaScript et substring(begin, end) de Java, et la source de nombreux décalages quand on porte du code.

using System;

class Program
{
    static void Main()
    {
        string sku = "SHOE-4271-BLK";
        //            0123456789...

        Console.WriteLine(sku.Substring(5));        // from index 5 to the end
        Console.WriteLine(sku.Substring(0, 4));     // 4 chars from index 0
        Console.WriteLine(sku.Substring(5, 4));     // 4 chars from index 5
        Console.WriteLine(sku.Substring(10, 3));    // last 3
        Console.WriteLine(sku.Substring(sku.Length).Length); // start == Length: empty string

        Console.WriteLine(sku);                     // unchanged: strings are immutable
    }
}

Sortie :

4271-BLK
SHOE
4271
BLK
0
SHOE-4271-BLK

Comme toutes les méthodes de chaîne, Substring ne modifie pas l'original ; elle renvoie une nouvelle chaîne, donc affectez le résultat.

ArgumentOutOfRangeException et comment l'éviter

Substring lève ArgumentOutOfRangeException quand la plage demandée ne tient pas dans la chaîne : un startIndex négatif, un startIndex supérieur à Length, une length négative, ou startIndex + length supérieur à Length. Il n'y a pas de troncature silencieuse, contrairement aux slices de Python.

using System;

class Program
{
    static void Show(string label, Func<string> take)
    {
        try
        {
            Console.WriteLine($"{label} -> \"{take()}\"");
        }
        catch (ArgumentOutOfRangeException)
        {
            Console.WriteLine($"{label} -> ArgumentOutOfRangeException");
        }
    }

    static void Main()
    {
        string word = "Coffee";   // Length 6

        Show("Substring(2, 4)", () => word.Substring(2, 4));
        Show("Substring(2, 5)", () => word.Substring(2, 5));   // 2 + 5 > 6
        Show("Substring(6)", () => word.Substring(6));         // allowed: empty
        Show("Substring(7)", () => word.Substring(7));
        Show("Substring(-1)", () => word.Substring(-1));
        Show("Substring(0, 10)", () => word.Substring(0, 10));
    }
}

Sortie :

Substring(2, 4) -> "ffee"
Substring(2, 5) -> ArgumentOutOfRangeException
Substring(6) -> ""
Substring(7) -> ArgumentOutOfRangeException
Substring(-1) -> ArgumentOutOfRangeException
Substring(0, 10) -> ArgumentOutOfRangeException

La protection habituelle consiste à borner la longueur à ce qui reste de la chaîne avec Math.Min :

using System;

class Program
{
    static string SafeSubstring(string s, int start, int length)
    {
        if (string.IsNullOrEmpty(s) || start >= s.Length) return "";
        if (start < 0) start = 0;
        return s.Substring(start, Math.Min(length, s.Length - start));
    }

    static void Main()
    {
        Console.WriteLine(SafeSubstring("Coffee", 2, 100));
        Console.WriteLine(SafeSubstring("Tea", 1, 2));
        Console.WriteLine($"[{SafeSubstring("Tea", 5, 2)}]");
        Console.WriteLine($"[{SafeSubstring(null, 0, 2)}]");
    }
}

Sortie :

ffee
ea
[]
[]

Appeler Substring sur une chaîne null lève NullReferenceException, et non ArgumentOutOfRangeException, c'est pourquoi la fonction vérifie d'abord null.

Les n premiers et derniers caractères

Prendre un préfixe ou un suffixe est l'usage le plus courant de Substring. Les deux lèvent une exception quand la chaîne est plus courte que n, donc le code de production vérifie la longueur :

using System;

class Program
{
    static string Left(string s, int n) => s.Length <= n ? s : s.Substring(0, n);
    static string Right(string s, int n) => s.Length <= n ? s : s.Substring(s.Length - n);

    static void Main()
    {
        string card = "4111111111111111";
        Console.WriteLine("**** " + Right(card, 4));

        string title = "An Unexpectedly Long Product Name";
        Console.WriteLine(Left(title, 12) + "...");

        Console.WriteLine(Left("Hi", 12));     // shorter than n: returned whole
        Console.WriteLine(Right("Hi", 4));
    }
}

Sortie :

**** 1111
An Unexpecte...
Hi
Hi

Quand c'est le début de la chaîne que vous voulez supprimer, Substring(n) suffit : "#FF8800".Substring(1) vaut "FF8800". La méthode voisine Remove(start, count) fait l'inverse de Substring : elle renvoie la chaîne privée de cette plage.

Substring avec IndexOf

La plupart des sous-chaînes réelles se trouvent par recherche, pas en comptant. IndexOf renvoie la position d'un caractère ou d'une chaîne (ou -1 s'il est absent), et LastIndexOf cherche depuis la fin. Combinez-les avec Substring pour découper du texte autour d'un séparateur :

using System;

class Program
{
    static void Main()
    {
        string email = "maya.lopez@example.com";
        int at = email.IndexOf('@');
        Console.WriteLine(email.Substring(0, at));       // before the @
        Console.WriteLine(email.Substring(at + 1));      // after the @

        string file = "report.final.v2.pdf";
        int dot = file.LastIndexOf('.');
        Console.WriteLine(file.Substring(dot + 1));      // extension
        Console.WriteLine(file.Substring(0, dot));       // name without extension

        string log = "2026-09-24 [WARN] Disk almost full";
        int open = log.IndexOf('[');
        int close = log.IndexOf(']', open + 1);
        Console.WriteLine(log.Substring(open + 1, close - open - 1)); // between [ and ]
        Console.WriteLine(log.Substring(close + 2));                  // the message
    }
}

Sortie :

maya.lopez
example.com
pdf
report.final.v2
WARN
Disk almost full

Le calcul suit une règle : pour prendre le texte entre les positions a et b (aucune des deux incluse), le départ est a + 1 et la longueur b - a - 1.

Le danger est qu'IndexOf renvoie -1. email.Substring(0, -1) lève une exception et, pire, email.Substring(-1 + 1) renvoie silencieusement toute la chaîne. Vérifiez toujours :

using System;

class Program
{
    static string Domain(string email)
    {
        int at = email.IndexOf('@');
        if (at < 0) return null;
        return email.Substring(at + 1);
    }

    static void Main()
    {
        Console.WriteLine(Domain("leo@shop.io") ?? "(none)");
        Console.WriteLine(Domain("not-an-email") ?? "(none)");
    }
}

Sortie :

shop.io
(none)

Split comme alternative

Quand une chaîne est une liste de champs avec un séparateur, Split est plus simple qu'une chaîne d'appels à IndexOf et Substring, et il n'y a aucun calcul d'index à rater :

using System;

class Program
{
    static void Main()
    {
        string row = "1042;Ana Silva;Porto;31";
        string[] fields = row.Split(';');
        Console.WriteLine(fields[1]);
        Console.WriteLine(fields[2]);

        string email = "maya.lopez@example.com";
        string user = email.Split('@')[0];
        Console.WriteLine(user);

        string path = "images/2026/09/beach.jpg";
        string[] parts = path.Split('/');
        Console.WriteLine(parts[parts.Length - 1]);   // last segment
    }
}

Sortie :

Ana Silva
Porto
maya.lopez
beach.jpg

Split alloue un tableau plus une chaîne par champ, donc pour une seule découpe dans une boucle critique, IndexOf et Substring coûtent moins cher. Pour tout le reste, la lisibilité l'emporte. D'autres options (plusieurs séparateurs, suppression des entrées vides, nombre maximal) se trouvent sur méthodes de chaîne. Pour des motifs comme « les chiffres après ID: », une expression régulière est en général l'outil le plus clair.

L'opérateur de plage (C# 8 et plus)

C# 8 a ajouté la syntaxe d'index et de plage, qui fonctionne sur les chaînes et les tableaux. ^n signifie « n depuis la fin » et a..b est la plage allant de a jusqu'à b non inclus, donc le second nombre est un index de fin, pas une longueur :

// C# 8 and later
string sku = "SHOE-4271-BLK";

string first4 = sku[..4];      // "SHOE"        same as Substring(0, 4)
string middle = sku[5..9];     // "4271"        same as Substring(5, 4)
string last3  = sku[^3..];     // "BLK"         same as Substring(sku.Length - 3)
string noEnds = sku[1..^1];    // "HOE-4271-BL" drop first and last
char lastChar = sku[^1];       // 'K'

Sur une chaîne, une plage se compile en un appel à Substring : elle alloue donc une nouvelle chaîne et lève ArgumentOutOfRangeException dans les mêmes cas de dépassement. Le choix est une question de style ; les plages se lisent mieux quand les deux bornes sont mesurées depuis des côtés différents ([1..^1]).

Des sous-chaînes sans copie : Span

Chaque appel à Substring alloue une nouvelle chaîne. Dans du code d'analyse sensible aux performances (lecture de gros fichiers, traitement de nombreuses requêtes), .NET Core 2.1 et plus proposent ReadOnlySpan<char>, une vue sur une partie de la chaîne d'origine, sans copie :

ReadOnlySpan<char> line = "2026-09-24,42.50,EUR".AsSpan();
ReadOnlySpan<char> amount = line.Slice(11, 5);          // "42.50", no allocation
decimal value = decimal.Parse(amount, provider: CultureInfo.InvariantCulture);

Les spans ne peuvent pas être stockés dans des champs de classes ordinaires ni utilisés à travers un await, ils ont donc leur place dans du code synchrone et serré. Pour le code applicatif courant, Substring est le bon outil.

Erreurs courantes

Passer un index de fin comme longueur. s.Substring(2, 5) signifie cinq caractères à partir de l'index 2, pas « de l'index 2 à 5 ». Pour prendre le texte de l'index a jusqu'à l'index b non inclus, la longueur est b - a.
Ne pas vérifier -1 après IndexOf. On obtient soit une exception, soit, avec + 1, toute la chaîne par accident.
Supposer que les chaînes courtes sont assez longues. Un nom, un code ou une ligne de fichier peut être plus court que prévu. Bornez avec Math.Min ou vérifiez Length.
Ignorer le résultat. s.Substring(1); seul sur sa ligne ne sert à rien.

Questions fréquentes

Comment fonctionne Substring en C# ?

s.Substring(start) renvoie les caractères de l'index start jusqu'à la fin ; s.Substring(start, length) renvoie length caractères à partir de start. Les index commencent à 0, et le second argument est une longueur, pas un index de fin : "Hello".Substring(1, 3) vaut "ell". La chaîne d'origine n'est pas modifiée.

Pourquoi Substring lève-t-il ArgumentOutOfRangeException ?

Parce que start est négatif ou supérieur à la longueur de la chaîne, ou que start + length dépasse la fin. La cause la plus fréquente est une longueur calculée pour une chaîne plus longue, ou un résultat d'IndexOf égal à -1 utilisé comme départ. Bornez la longueur avec Math.Min(length, s.Length - start) et vérifiez les résultats d'IndexOf avant de les utiliser.

Comment obtenir les n derniers caractères d'une chaîne en C# ?

s.Substring(s.Length - n) renvoie les n derniers caractères, à condition que n <= s.Length. Pour être sûr avec les chaînes courtes, utilisez s.Length <= n ? s : s.Substring(s.Length - n). Depuis C# 8, vous pouvez aussi écrire s[^n..], qui lève la même exception quand n est trop grand.

Comment obtenir la sous-chaîne entre deux caractères en C# ?

Trouvez les deux positions avec IndexOf, puis prenez la partie située entre elles : int start = s.IndexOf('(') + 1; int end = s.IndexOf(')', start); string inside = s.Substring(start, end - start);. Vérifiez que chaque IndexOf a trouvé quelque chose (pas -1) avant d'appeler Substring. Pour des motifs complexes, une expression régulière est plus claire.

Substring commence-t-il à zéro en C# ?

Oui. Le premier caractère est à l'index 0 et le dernier à Length - 1. Substring(0, 3) renvoie les trois premiers caractères. Passer Length lui-même comme départ est autorisé et renvoie une chaîne vide.

Concepts liés