Cette documentation est archivée et n’est pas conservée.

Path, classe

Exécute des opérations sur des instances String qui contiennent des informations relatives au chemin d'accès d'un fichier ou d'un répertoire. Ces opérations sont exécutées différemment selon la plate-forme.

Espace de noms : System.IO
Assembly : mscorlib (dans mscorlib.dll)

[ComVisibleAttribute(true)] 
public static class Path
/** @attribute ComVisibleAttribute(true) */ 
public final class Path
ComVisibleAttribute(true) 
public final class Path

Le .NET Framework ne prend pas en charge l'accès direct aux disques physiques via les chemins d'accès qui sont des noms de périphériques, tels que "\\.\PHYSICALDRIVE0".

Un chemin d'accès est une chaîne qui fournit l'emplacement d'un fichier ou d'un répertoire. Un chemin d'accès ne pointe pas nécessairement vers un emplacement sur un disque ; il peut par exemple mapper vers un emplacement en mémoire ou sur un périphérique. Le format exact d'un chemin d'accès est déterminé par la plate-forme en cours. Par exemple, sur certains systèmes, un chemin d'accès peut commencer par une lettre de lecteur ou de volume alors que celle-ci peut ne pas être incluse sur d'autres systèmes. Sur certains systèmes, les chemins d'accès des fichiers contiennent des extensions qui indiquent le type d'informations stockées dans le fichier. Le format de l'extension du nom de fichier varie selon la plate-forme ; par exemple, certains systèmes limitent les extensions à trois caractères, alors que d'autres n'imposent aucune limite. La plate-forme en cours détermine également le jeu de caractères utilisé pour séparer les éléments d'un chemin d'accès et le jeu de caractères qui ne peut pas être utilisé lors de la spécification de chemins d'accès. En raison de ces différences, les champs de la classe Path et le comportement exact de certains membres de la classe Path varient selon la plate-forme.

Un chemin d'accès peut contenir des informations sur l'emplacement relatif ou absolu. Les chemins d'accès absolus spécifient un emplacement : le fichier ou le répertoire peut être identifié de manière unique quel que soit l'emplacement en cours. Les chemins d'accès relatifs spécifient un emplacement partiel : l'emplacement en cours est utilisé comme point de départ lors de la localisation d'un fichier spécifié avec un chemin relatif. Pour déterminer le répertoire actif, appelez Directory.GetCurrentDirectory.

La plupart des membres de la classe Path n'interagissent pas avec le système de fichiers et ne vérifient pas l'existence du fichier spécifié par une chaîne de chemin d'accès. Les membres de la classe Path qui modifient une chaîne de chemin d'accès, telle que ChangeExtension, n'ont aucun effet sur les noms de fichiers du système de fichiers. Toutefois, les membres Path valident le contenu d'une chaîne de chemin d'accès spécifiée et lèvent ArgumentException si la chaîne contient des caractères non valides dans les chaînes de chemin d'accès, comme défini dans InvalidPathChars. Par exemple, sur les plates-formes de bureau Windows, les caractères de chemin d'accès non valides peuvent inclure les guillemets ("), le signe inférieur à (<), le signe supérieur à (>), la barre verticale (|), le retour arrière (\b), la valeur null (\0) et les caractères Unicode compris entre 16 et 18 et entre 20 et 25.

Les membres de la classe Path vous permettent d'exécuter rapidement et facilement des opérations courantes : par exemple, déterminer si l'extension d'un nom de fichier fait partie d'un chemin d'accès ou combiner deux chaînes en un seul nom de chemin d'accès.

Tous les membres de la classe Path sont statiques et peuvent donc être appelés sans disposer d'une instance d'un chemin d'accès.

RemarqueRemarque

Dans les membres qui acceptent un chemin d'accès en tant qu'une chaîne d'entrée, ce chemin d'accès doit être correctement construit ; sinon, une exception est levée. Par exemple, si un chemin d'accès est qualifié complet, mais commence par un espace, le chemin n'est pas rogné dans les méthodes de la classe. Par conséquent, le chemin d'accès est incorrect et une exception est levée. De façon similaire, un chemin d'accès ou une combinaison de chemins d'accès ne peut pas être qualifié complet deux fois. Par exemple, "c:\temp c:\windows" lève une exception dans la plupart des cas. Assurez-vous que vos chemins d'accès sont correctement construits lorsque vous utilisez des méthodes qui acceptent une chaîne de chemin d'accès.

Dans les membres qui acceptent un chemin d'accès, le chemin d'accès peut faire référence à un fichier ou simplement à un répertoire. Le chemin d'accès spécifié peut également faire référence à un chemin d'accès relatif ou à un chemin d'accès de convention d'affectation de noms (UNC) pour un nom de serveur et de partage. Par exemple, les chemins d'accès suivants sont tous valides :

  • "c:\\MonRépertoire\\MonFichier.txt" en C# ou "c:\MonRépertoire\MonFichier.txt" en Visual Basic.

  • "c:\\MonRépertoire" en C# ou "c:\MonRépertoire" en Visual Basic.

  • "MonRépertoire\\MonSousRépertoire" en C# ou "MonRépertoire\MonSousRépertoire" en Visual Basic.

  • "\\\\MonServeur\\MonPartage" en C# ou "\\MonServeur\MonPartage" en Visual Basic.

Toutes ces opérations étant exécutées sur des chaînes, il est impossible de vérifier la validité des résultats dans tous les scénarios. Par exemple, la méthode GetExtension analyse une chaîne que vous lui passez puis retourne l'extension de cette chaîne. Cependant, cela ne signifie pas qu'un fichier avec cette extension existe sur le disque.

Pour obtenir un exemple d'utilisation de cette classe, consultez la section Exemple ci-dessous. Le tableau suivant répertorie des exemples d'autres tâches d'E/S courantes ou apparentées.

Pour effectuer cette opération...

Consultez l'exemple qui se trouve dans cette rubrique...

Créer un fichier texte.

Comment : écrire du texte dans un fichier

Écrire dans un fichier texte.

Comment : écrire du texte dans un fichier

Lire à partir d'un fichier texte.

Comment : lire du texte dans un fichier

Récupérer une extension de nom de fichier.

GetExtension

Récupérer le chemin d'accès qualifié complet d'un fichier.

GetFullPath

Récupérer le nom de fichier et l'extension d'un chemin d'accès.

GetFileName

Récupérer uniquement le nom de fichier d'un chemin d'accès.

GetFileNameWithoutExtension

Récupérer uniquement le nom de répertoire d'un chemin d'accès.

GetDirectoryName

Modifier l'extension d'un fichier.

ChangeExtension

Déterminer si un répertoire existe.

Exists

Déterminer si un fichier existe.

Exists

L'exemple de code suivant illustre certains membres principaux de la classe Path.

using System;
using System.IO;

class Test 
{
	
    public static void Main() 
    {
        string path1 = @"c:\temp\MyTest.txt";
        string path2 = @"c:\temp\MyTest";
        string path3 = @"temp";

        if (Path.HasExtension(path1)) 
        {
            Console.WriteLine("{0} has an extension.", path1);
        }

        if (!Path.HasExtension(path2)) 
        {
            Console.WriteLine("{0} has no extension.", path2);
        }

        if (!Path.IsPathRooted(path3)) 
        {
            Console.WriteLine("The string {0} contains no root information.", path3);
        }

        Console.WriteLine("The full path of {0} is {1}.", path3, Path.GetFullPath(path3));
        Console.WriteLine("{0} is the location for temporary files.", Path.GetTempPath());
        Console.WriteLine("{0} is a file available for use.", Path.GetTempFileName());

        /* This code produces output similar to the following:
         * c:\temp\MyTest.txt has an extension.
         * c:\temp\MyTest has no extension.
         * The string temp contains no root information.
         * The full path of temp is D:\Documents and Settings\cliffc\My Documents\Visual Studio 2005\Projects\ConsoleApplication2\ConsoleApplication2\bin\Debug\temp.
         * D:\Documents and Settings\cliffc\Local Settings\Temp\8\ is the location for temporary files.
         * D:\Documents and Settings\cliffc\Local Settings\Temp\8\tmp3D.tmp is a file available for use.
         */
    }
}

import System.*;
import System.IO.*;

class Test
{
    public static void main(String[] args)
    {
        String path1 = "c:\\temp\\MyTest.txt";
        String path2 = "c:\\temp\\MyTest";
        String path3 = "temp";

        if (Path.HasExtension(path1)) {
            Console.WriteLine("{0} has an extension.", path1);
        }
        if (!(Path.HasExtension(path2))) {
            Console.WriteLine("{0} has no extension.", path2);
        }
        if (!(Path.IsPathRooted(path3))) {
            Console.WriteLine("The string {0} contains no root information.",
                path3);
        }

        Console.WriteLine("The full path of {0} is {1}.", path3, 
            Path.GetFullPath(path3));
        Console.WriteLine("{0} is the location for temporary files.",
            Path.GetTempPath());
        Console.WriteLine("{0} is a file available for use.", 
            Path.GetTempFileName());
        Console.WriteLine("\r\nThe set of invalid characters in a path is:");
        Console.WriteLine("(Note that the wildcard characters '*' and '?' "
            + "are not invalid.):");
        char c = ' ';
        for (int iCtr = 0; iCtr < Path.InvalidPathChars.get_Length(); iCtr++) {
            c = Path.InvalidPathChars[iCtr];
            Console.WriteLine(c);
        }
    } //main
} //Test

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

.NET Framework

Prise en charge dans : 2.0, 1.1, 1.0

.NET Compact Framework

Prise en charge dans : 2.0, 1.0
Afficher: