Exporter (0) Imprimer
Développer tout
1 sur 1 ont trouvé cela utile - Évaluez ce sujet

Path, classe

Mise à jour : novembre 2007

Exécute 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 exécutées différemment selon la plateforme.

Espace de noms :  System.IO
Assembly :  mscorlib (dans mscorlib.dll)
[ComVisibleAttribute(true)]
public static class Path
/** @attribute ComVisibleAttribute(true) */
public final class Path
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 plateforme 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 plateforme ; par exemple, certains systèmes limitent les extensions à trois caractères, alors que d'autres n'imposent aucune limite. La plateforme 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 plateforme.

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 plateformes 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.

3bdzys9w.alert_note(fr-fr,VS.90).gifRemarque :

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 la liste des tâches d'E/S courantes, consultez Tâches d'E/S courantes.

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


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

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

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

.NET Framework

Pris en charge dans : 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Pris en charge dans : 3.5, 2.0, 1.0

XNA Framework

Pris en charge dans : 2.0, 1.0
Cela vous a-t-il été utile ?
(1500 caractères restants)
Merci pour vos suggestions.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft. Tous droits réservés.