Path Classe

Définition

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.

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

Méthodes

S’applique à

Voir aussi

• fichier et flux d’E/S
• Guide pratique pour lire du texte à partir d’un fichier
• Comment : écrire du texte dans un fichier
• Comment : lire et écrire dans un fichier de données nouvellement créé
• formats de chemin de fichier sur les systèmes Windows