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

Source:: Path.cs

Source:: Path.cs

Source:: Path.cs

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 String instances qui contiennent des informations de chemin d’accès de fichier ou de répertoire. Ces opérations sont effectuées de manière multiplateforme.

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 classe Path.

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 d’accès peut commencer par une lettre de lecteur ou 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 un support optique), 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 l’ensemble de caractères qui ne peuvent pas être utilisés lors de la spécification des chemins d’accès. En raison de ces différences, les champs de la classe Path ainsi que le comportement exact de certains membres de la classe Path dépendent de la 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 formats de chemin d’accès de fichier sur les systèmes Windows.

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

Certains membres Path valident le contenu d’une chaîne de chemin d’accès spécifiée et lèvent un ArgumentException 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 à partir de la méthode GetInvalidPathChars. Par exemple, sur les plateformes de bureau Windows, les caractères de chemin d’accès non valides peuvent inclure des guillemets ("), inférieurs à (<), supérieurs à (>), des canaux (|), des retours arrière (\b), null (\0) et des caractères Unicode 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 à 2.1 : tous les membres Path qui prennent un chemin d’accès en tant qu’argument lèvent un ArgumentException s’ils détectent des caractères de chemin d’accès 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 classe Path 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 classe Path sont statiques et peuvent donc être appelés sans avoir d’instance d’un chemin d’accès.

Note

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 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 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. Vérifiez que vos chemins 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 d’accès UNC (Universal Naming Convention) pour un serveur et un nom de partage. Par exemple, tous les chemins suivants sont acceptables :

« c :\\MyDir\\MyFile.txt» en C#, ou « c :\MyDir\MyFile.txt» en Visual Basic.
« c :\\MyDir » en C# ou « c :\MyDir » en Visual Basic.
« MyDir\\MySubdir » en C# ou « MyDir\MySubDir » en Visual Basic.
« \\\\MyServer\\MyShare » en C#, ou « \\MyServer\MyShare » en 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 méthode GetExtension 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 d’E/S courantes, consultez tâches d’E/S courantes.

Champs

AltDirectorySeparatorChar	Fournit un autre 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 hiérarchique du système de fichiers.
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 hiérarchique du système de fichiers.
InvalidPathChars	Obsolète. Obsolète. Fournit un tableau spécifique à la plateforme de caractères qui ne peut pas être spécifié dans les arguments de chaîne de chemin transmis aux membres de la classe Path.
PathSeparator	Caractère séparateur 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(ReadOnlySpan<String>)	Combine une étendue de chaînes dans un chemin d’accès.
Combine(String, String)	Combine deux chaînes dans un chemin d’accès.
Combine(String, String, String)	Combine trois chaînes dans un chemin d’accès.
Combine(String, String, String, String)	Combine quatre chaînes dans un chemin d’accès.
Combine(String[])	Combine un tableau de chaînes en chemin d’accès.
EndsInDirectorySeparator(ReadOnlySpan<Char>)	Renvoie une valeur qui indique si le chemin d’accès, spécifié en tant qu’étendue en lecture seule, se termine par un séparateur de répertoires.
EndsInDirectorySeparator(String)	Retourne une valeur qui indique si le chemin spécifié se termine par un séparateur de répertoires.
Exists(String)	Détermine si le fichier ou le répertoire spécifié existe.
GetDirectoryName(ReadOnlySpan<Char>)	Retourne les informations de répertoire pour le chemin d’accès spécifié représenté par une étendue de caractères.
GetDirectoryName(String)	Retourne les informations de répertoire pour le chemin d’accès 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 de chemin d’accès spécifiée.
GetFileName(ReadOnlySpan<Char>)	Renvoie le nom de fichier et l’extension d’un chemin d’accès de fichier représenté par une étendue de caractères en lecture seule.
GetFileName(String)	Retourne le nom de fichier et l’extension 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 absolu de la chaîne de chemin d’accès spécifiée.
GetFullPath(String, String)	Retourne un chemin 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 chemin d’accès.
GetPathRoot(ReadOnlySpan<Char>)	Obtient les informations du répertoire racine 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 aléatoire ou un nom de fichier.
GetRelativePath(String, String)	Retourne un chemin relatif d’un chemin d’accès à un autre.
GetTempFileName()	Crée un fichier temporaire de type zéro octet unique 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 inclut 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>)	Retourne une valeur qui indique si le chemin d’accès du fichier représenté par l’étendue de caractères spécifiée est fixe à un lecteur spécifique ou à un chemin UNC spécifique.
IsPathFullyQualified(String)	Retourne une valeur qui indique si le chemin d’accès de fichier spécifié est fixe à un lecteur spécifique ou à un chemin UNC.
IsPathRooted(ReadOnlySpan<Char>)	Retourne une valeur qui indique si l’étendue de caractères spécifiée qui représente un chemin d’accès de fichier contient une racine.
IsPathRooted(String)	Retourne 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 en un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène trois composants de chemin en un seul chemin.
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Concatène quatre composants de chemin en un seul chemin.
Join(ReadOnlySpan<String>)	Concatène une étendue de chemins en un seul chemin.
Join(String, String)	Concatène deux chemins en un seul chemin.
Join(String, String, String)	Concatène trois chemins en un seul chemin.
Join(String, String, String, String)	Concatène quatre chemins en un seul chemin.
Join(String[])	Concatène un tableau de chemins en un seul chemin.
TrimEndingDirectorySeparator(ReadOnlySpan<Char>)	Supprime un séparateur de répertoires de fin au-delà de la racine du chemin spécifié.
TrimEndingDirectorySeparator(String)	Supprime un séparateur de répertoires de fin au-delà de la racine du chemin spécifié.
TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32)	Tente de concaténer trois composants de chemin d’accès à une seule étendue de caractères préallouée 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 vers une étendue de caractères préallouée unique et retourne une valeur qui indique si l’opération a réussi.

S’applique à

Partager via