Path Classe

Référence

Définition

Espace de noms:: System.IO

Assembly:: System.Runtime.Extensions.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Effectue des opérations sur des instances de String qui contiennent des informations relatives au chemin d'accès d'un fichier ou d'un répertoire. Ces opérations sont effectuées différemment selon la plateforme.

public ref class Path abstract sealed

public ref class Path sealed

public static class Path

public sealed class Path

[System.Runtime.InteropServices.ComVisible(true)]
public static class Path

type Path = class

[<System.Runtime.InteropServices.ComVisible(true)>]
type Path = class

Public Class Path

Public NotInheritable Class Path

Héritage: Object
Path

Attributs: ComVisibleAttribute

Exemples

L’exemple suivant illustre certains des principaux membres de la Path classe.

using namespace System;
using namespace System::IO;
int 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() );
   Console::WriteLine( "\r\nThe set of invalid characters in a path is:" );
   Console::WriteLine( "(Note that the wildcard characters '*' and '?' are not invalid.):" );
   Collections::IEnumerator^ myEnum = Path::InvalidPathChars->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Char c =  *safe_cast<Char^>(myEnum->Current);
      Console::WriteLine( c );
   }
}

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.
         */
    }
}

Imports System.IO

Public Class Test

    Public Shared Sub Main()
        Dim path1 As String = "c:\temp\MyTest.txt"
        Dim path2 As String = "c:\temp\MyTest"
        Dim path3 As String = "temp"

        If Path.HasExtension(path1) Then
            Console.WriteLine("{0} has an extension.", path1)
        End If

        If Path.HasExtension(path2) = False Then
            Console.WriteLine("{0} has no extension.", path2)
        End If

        If Path.IsPathRooted(path3) = False Then
            Console.WriteLine("The string {0} contains no root information.", path3)
        End If

        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.

    End Sub
End Class

Remarques

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 le disque ; Par exemple, un chemin d’accès peut être mappé à un emplacement en mémoire ou sur un appareil. Le format exact d’un chemin est déterminé par la plateforme actuelle. Par exemple, sur certains systèmes, un chemin peut commencer par un lecteur ou une lettre de volume, alors que cet élément n’est pas présent dans d’autres systèmes. Sur certains systèmes, les chemins d’accès aux fichiers peuvent contenir des extensions, ce qui indique le type d’informations stockées dans le fichier. Le format d’une extension de nom de fichier dépend de la plateforme ; Par exemple, certains systèmes limitent les extensions à trois caractères (comme FAT16 couramment utilisé sur un stockage flash plus petit et les versions antérieures de ISO 9660 utilisées sur des supports optiques), et d’autres ne le font pas. La plateforme actuelle détermine également l’ensemble de caractères utilisé pour séparer les éléments d’un chemin d’accès et le jeu de caractères qui ne peuvent pas être utilisés lors de la spécification de chemins d’accès. En raison de ces différences, les champs de la Path classe ainsi que le comportement exact de certains membres de la classe dépendent de la Path plateforme.

Un chemin d’accès peut contenir des informations d’emplacement absolues ou relatives. Les chemins absolus spécifient entièrement un emplacement : le fichier ou le répertoire peut être identifié de manière unique, quel que soit l’emplacement actuel. Les chemins relatifs spécifient un emplacement partiel : l’emplacement actuel 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.

.NET Core 1.1 et versions ultérieures et .NET Framework 4.6.2 et versions ultérieures prennent également en charge l’accès aux objets de système de fichiers qui sont des noms d’appareils, tels que «\\ ? »\ C:\ ».

Pour plus d’informations sur les formats de chemin d’accès aux fichiers sur Windows, consultez les formats de chemin d’accès aux fichiers sur les systèmes Windows.

La plupart des membres de la Path classe 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. Path les membres de classe qui modifient une chaîne de chemin d’accès, par ChangeExtensionexemple, n’ont aucun effet sur les noms de fichiers dans le système de fichiers.

Certains Path membres valident le contenu d’une chaîne de chemin d’accès spécifiée et lèvent une ArgumentException valeur si la chaîne contient des caractères qui ne sont pas valides dans les chaînes de chemin d’accès, comme défini dans les caractères retournés par la GetInvalidPathChars méthode. Par exemple, sur les plateformes de bureau basées sur Windows, les caractères de chemin d’accès non valides peuvent inclure des guillemets (« ), inférieurs à (<), greater than (>), des canaux (|), des retours arrière (b), null (\\0) et des caractères Unicode de 16 à 18 et 20 à 25. Ce comportement de validation varie entre les versions de .NET :

Sur .NET Framework et les versions .NET Core antérieures à la version 2.1 : tous les Path membres qui prennent un chemin d’accès en tant qu’argument lèvent un ArgumentException argument s’ils détectent des caractères de chemin non valides.
Sur .NET Core 2.1 et versions ultérieures : GetFullPath est le seul membre qui lève un ArgumentException si la chaîne contient des caractères de chemin d’accès non valides.

Les membres de la Path classe vous permettent d’effectuer rapidement et facilement des opérations courantes, telles que déterminer si une extension de nom de fichier fait partie d’un chemin d’accès et combiner deux chaînes en un seul nom de chemin.

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

Notes

Dans les membres qui acceptent un chemin d’accès en tant que chaîne d’entrée, ce chemin doit être bien formé ou une exception est levée. Par exemple, si un chemin d’accès est complet mais commence par un espace, le chemin n’est pas coupé dans les méthodes de la classe. Par conséquent, le chemin d’accès est incorrect et une exception est levée. De même, un chemin d’accès ou une combinaison de chemins ne peut pas être qualifié deux fois. Par exemple, « c:\temp c:\windows » déclenche également une exception dans la plupart des cas. Assurez-vous que vos chemins d’accès sont bien formés lors de l’utilisation de 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 spécifié peut également faire référence à un chemin relatif ou à un chemin UNC (Universal Naming Convention) pour un serveur et un nom de partage. Par exemple, tous les chemins d’accès acceptables sont les suivants :

« c:\\MyDir\\MyFile.txt » en C# ou « c:\MyDir\MyFile.txt » dans Visual Basic.
« c:\\MyDir » en C# ou « c:\MyDir » dans Visual Basic.
« MyDirMySubdir\\ » en C# ou « MyDirMySubDir\ » dans Visual Basic.
«\\\\ MyServerMyShare\\ » en C# ou «\\ MyServerMyShare\ » dans Visual Basic.

Étant donné que toutes ces opérations sont effectuées sur des chaînes, il est impossible de vérifier que les résultats sont valides dans tous les scénarios. Par exemple, la GetExtension méthode analyse une chaîne que vous lui transmettez et retourne l’extension de cette chaîne. Toutefois, cela ne signifie pas qu’un fichier avec cette extension existe sur le disque.

Pour obtenir la liste des tâches courantes d’E/S, consultez Tâches d’E/S courantes.

Champs

AltDirectorySeparatorChar	Fournit un caractère de remplacement spécifique à la plateforme, utilisé pour séparer les niveaux de répertoire dans une chaîne de chemin d'accès qui reflète une organisation de système de fichiers hiérarchique.
DirectorySeparatorChar	Fournit un caractère spécifique à la plateforme, utilisé pour séparer les niveaux de répertoire dans une chaîne de chemin d'accès qui reflète une organisation de système de fichiers hiérarchique.
InvalidPathChars	Obsolète. Obsolète. Obsolète. Fournit un tableau de caractères (spécifique à la plateforme) qui ne peuvent pas être spécifiés dans des arguments de chaîne de chemin d’accès passés aux membres de la classe Path.
PathSeparator	Caractère de séparation spécifique à la plateforme, utilisé pour séparer les chaînes de chemin d'accès dans les variables d'environnement.
VolumeSeparatorChar	Fournit un caractère de séparation de volume spécifique à la plateforme.

Méthodes

ChangeExtension(String, String)	Modifie l'extension d'une chaîne de chemin d'accès.
Combine(String, String)	Combine deux chaînes en un chemin d’accès.
Combine(String, String, String)	Combine trois chaînes en un chemin d'accès.
Combine(String, String, String, String)	Combine quatre chaînes en un chemin d'accès.
Combine(String[])	Combine un tableau de chaînes en un chemin d’accès.
EndsInDirectorySeparator(ReadOnlySpan<Char>)	Retourne une valeur qui indique si le chemin d’accès, spécifié sous la forme d’une étendue en lecture seule, se termine par un séparateur de répertoire.
EndsInDirectorySeparator(String)	Retourne une valeur qui indique si le chemin d’accès spécifié se termine par un séparateur de répertoire.
Exists(String)	Détermine si le fichier ou le répertoire spécifié existe.
GetDirectoryName(ReadOnlySpan<Char>)	Renvoie les informations relatives au répertoire pour le chemin spécifié représenté par une étendue de caractères.
GetDirectoryName(String)	Retourne les informations de répertoire pour le chemin spécifié.
GetExtension(ReadOnlySpan<Char>)	Renvoie l'extension d'un chemin d'accès de fichier représenté par une étendue de caractères en lecture seule.
GetExtension(String)	Retourne l’extension (y compris le point ".") de la chaîne du chemin d'accès spécifié.
GetFileName(ReadOnlySpan<Char>)	Renvoie le nom et l'extension d'un chemin de fichier représenté par une étendue de caractères en lecture seule.
GetFileName(String)	Retourne le nom et l’extension de fichier de la chaîne de chemin d’accès spécifiée.
GetFileNameWithoutExtension(ReadOnlySpan<Char>)	Renvoie le nom de fichier sans l'extension d'un chemin d'accès de fichier représenté par une étendue de caractères en lecture seule.
GetFileNameWithoutExtension(String)	Retourne le nom de fichier de la chaîne de chemin d'accès spécifiée sans l'extension.
GetFullPath(String)	Retourne le chemin d'accès absolu de la chaîne de chemin d'accès spécifiée.
GetFullPath(String, String)	Renvoie un chemin d’accès absolu à partir d’un chemin relatif et d’un chemin de base complet.
GetInvalidFileNameChars()	Obtient un tableau contenant les caractères qui ne sont pas autorisés dans les noms de fichiers.
GetInvalidPathChars()	Obtient un tableau contenant les caractères qui ne sont pas autorisés dans les noms de chemins d'accès.
GetPathRoot(ReadOnlySpan<Char>)	Obtient les informations du répertoire racine à partir du chemin d’accès contenu dans l’étendue de caractères spécifiée.
GetPathRoot(String)	Obtient les informations du répertoire racine à partir du chemin d’accès contenu dans la chaîne spécifiée.
GetRandomFileName()	Retourne un nom de dossier ou de fichier aléatoire.
GetRelativePath(String, String)	Renvoie un chemin d'accès relatif d'un chemin à un autre.
GetTempFileName()	Crée un fichier temporaire de zéro octet nommé de façon univoque sur le disque et retourne le chemin d’accès complet de ce fichier.
GetTempPath()	Retourne le chemin d’accès du dossier temporaire de l’utilisateur actuel.
HasExtension(ReadOnlySpan<Char>)	Détermine si le chemin d'accès représenté par l'étendue de caractères spécifiée comprend une extension de nom de fichier.
HasExtension(String)	Détermine si un chemin d'accès inclut une extension de nom de fichier.
IsPathFullyQualified(ReadOnlySpan<Char>)	Renvoie une valeur qui indique si le chemin d'accès de fichier représenté par l'étendue de caractères spécifiée est fixé sur un lecteur ou un chemin d'accès UNC spécifique.
IsPathFullyQualified(String)	Renvoie une valeur qui indique si le chemin d'accès du fichier spécifié est fixé sur un lecteur ou un chemin d'accès UNC spécifique.
IsPathRooted(ReadOnlySpan<Char>)	Renvoie une valeur indiquant si l'étendue de caractères spécifiée qui représente un chemin de fichier contient une racine.
IsPathRooted(String)	Renvoie une valeur indiquant si la chaîne de chemin d'accès spécifiée contient une racine.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène deux composants de chemin d'accès en un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène trois composants de chemin d'accès en un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène quatre composants de chemin dans un seul chemin.
Join(String, String)	Concatène deux chemins dans un seul chemin.
Join(String, String, String)	Concatène trois chemins dans un seul chemin.
Join(String, String, String, String)	Concatène quatre chemins dans un seul chemin.
Join(String[])	Concatène un tableau de chemins dans un seul chemin.
TrimEndingDirectorySeparator(ReadOnlySpan<Char>)	Supprime un séparateur de répertoire de fin au-delà de la racine du chemin d’accès spécifié.
TrimEndingDirectorySeparator(String)	Supprime un séparateur de répertoire de fin au-delà de la racine du chemin d’accès spécifié.
TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32)	Tente de concaténer trois composants de chemin d’accès à une étendue de caractères préallouée unique et retourne une valeur qui indique si l’opération a réussi.
TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32)	Tente de concaténer deux composants de chemin d'accès au sein d'une seule étendue de caractères préallouée, et renvoie une valeur indiquant si l'opération est un succès.

S’applique à