Path Path Path Path Class

Définition

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.Performs operations on String instances that contain file or directory path information. Ces opérations sont effectuées différemment selon la plateforme.These operations are performed in a cross-platform manner.

public ref class Path abstract sealed
[System.Runtime.InteropServices.ComVisible(true)]
public static class Path
type Path = class
Public Class Path
Héritage
PathPathPathPath
Attributs

Exemples

L’exemple suivant illustre certains membres principaux de la Path classe.The following example demonstrates some of the main members of the Path class.

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
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 répertoire.A path is a string that provides the location of a file or directory. Un chemin d’accès ne pointe pas nécessairement vers un emplacement sur le disque ; par exemple, un chemin d’accès peut mapper à un emplacement en mémoire ou sur un appareil.A path does not necessarily point to a location on disk; for example, a path might map to a location in memory or on a device. Le format exact d’un chemin d’accès est déterminé par la plateforme actuelle.The exact format of a path is determined by the current platform. Par exemple, sur certains systèmes, un chemin d’accès peut commencer par une lettre de lecteur ou volume, tandis que cet élément n’est pas présent dans d’autres systèmes.For example, on some systems, a path can start with a drive or volume letter, while this element is not present in other systems. Sur certains systèmes, les chemins d’accès de fichier peuvent contenir des extensions, qui indiquent le type d’informations stockées dans le fichier.On some systems, file paths can contain extensions, which indicate the type of information stored in the file. Le format d’une extension de nom de fichier est dépendante de la plateforme ; par exemple, certains systèmes de limitent les extensions à trois caractères, et d’autres ne le faites pas.The format of a file name extension is platform-dependent; for example, some systems limit extensions to three characters, and others do not. La plateforme actuelle 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.The current platform also determines the set of characters used to separate the elements of a path, and the set of characters that cannot be used when specifying paths. En raison de ces différences, les champs de la Path classe, ainsi que le comportement exact de certains membres de la Path classe sont dépendants de la plateforme.Because of these differences, the fields of the Path class as well as the exact behavior of some members of the Path class are platform-dependent.

Un chemin d’accès peut contenir des informations d’emplacement absolu ou relatif.A path can contain absolute or relative location information. Chemins d’accès absolus spécifient un emplacement : le fichier ou le répertoire peut être identifiée, quel que soit l’emplacement actuel.Absolute paths fully specify a location: the file or directory can be uniquely identified regardless of the current location. Chemins d’accès 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 d’accès relatif.Relative paths specify a partial location: the current location is used as the starting point when locating a file specified with a relative path. Pour déterminer le répertoire actif, appelez Directory.GetCurrentDirectory.To determine the current directory, call 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 de périphériques, tels que «\? \C :"..NET Core 1.1 and later versions and .NET Framework 4.6.2 and later versions also support access to file system objects that are device names, such as "\?\C:".

Pour plus d’informations sur les formats de chemin d’accès de fichier sur Windows, consultez les formats de chemin d’accès des fichiers sur les systèmes Windows.For more information on file path formats on Windows, see File path formats on Windows systems.

La plupart des membres de la Path n’interagissent pas avec le système de fichiers de classe et ne pas vérifier l’existence du fichier spécifié par une chaîne de chemin d’accès.Most members of the Path class do not interact with the file system and do not verify the existence of the file specified by a path string. Path classe les membres qui modifient une chaîne de chemin d’accès, tel que ChangeExtension, n’ont aucun effet sur les noms de fichiers dans le système de fichiers.Path class members that modify a path string, such as ChangeExtension, have no effect on names of files in the file system. Path membres, toutefois, valider le contenu d’une chaîne de chemin d’accès spécifié et lève un ArgumentException exception si la chaîne contient des caractères qui ne sont pas valides dans les chaînes de chemin d’accès, tel que défini dans les caractères renvoyés à partir de la GetInvalidPathChars (méthode).Path members do, however, validate the contents of a specified path string, and throw an ArgumentException exception if the string contains characters that are not valid in path strings, as defined in the characters returned from the GetInvalidPathChars method. Par exemple, sur les plateformes de bureau Windows, les caractères de chemin non valide peuvent inclure les guillemets («), inférieur à (<), supérieur à (>), barre verticale (|), retour arrière (\b), valeur null (\0) et les caractères Unicode 16 et 18 et 20 à 25.For example, on Windows-based desktop platforms, invalid path characters might include quote ("), less than (<), greater than (>), pipe (|), backspace (\b), null (\0), and Unicode characters 16 through 18 and 20 through 25.

Les membres de la Path classe que vous puissiez rapidement et facilement effectuer 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 chemin d’accès.The members of the Path class enable you to quickly and easily perform common operations such as determining whether a file name extension is part of a path, and combining two strings into one path name.

Tous les membres de la Path classe sont statique et peuvent donc être appelés sans disposer d’une instance d’un chemin d’accès.All members of the Path class are static and can therefore be called without having an instance of a path.

Notes

Dans les membres qui acceptent un chemin d’accès sous forme de chaîne d’entrée, ce chemin d’accès doit être correctement construit, ou une exception est levée.In members that accept a path as an input string, that path must be well-formed or an exception is raised. Par exemple, si un chemin d’accès est qualifié complet mais commence par un espace, le chemin d’accès n’est pas tronqué dans les méthodes de la classe.For example, if a path is fully qualified but begins with a space, the path is not trimmed in methods of the class. Par conséquent, le chemin d’accès est incorrect et une exception est levée.Therefore, the path is malformed and an exception is raised. De même, un chemin d’accès ou une combinaison de chemins d’accès ne peut pas être qualifiée à deux reprises.Similarly, a path or a combination of paths cannot be fully qualified twice. Par exemple, « c:\temp c:\windows » déclenche également une exception dans la plupart des cas.For example, "c:\temp c:\windows" also raises an exception in most cases. Assurez-vous que vos chemins sont correctement construits lors de l’utilisation des méthodes qui acceptent une chaîne de chemin d’accès.Ensure that your paths are well-formed when using methods that accept a path string.

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.In members that accept a path, the path can refer to a file or just a directory. 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 UNC Universal Naming Convention () pour un nom de serveur et le partage.The specified path can also refer to a relative path or a Universal Naming Convention (UNC) path for a server and share name. Par exemple, tous les éléments suivants sont des chemins d’accès acceptables :For example, all the following are acceptable paths:

  • « c:\\MyDir\\MyFile.txt » en C# ou « c:\MyDir\MyFile.txt » en Visual Basic."c:\\MyDir\\MyFile.txt" in C#, or "c:\MyDir\MyFile.txt" in Visual Basic.

  • « c:\\MyDir » en C# ou « c:\MyDir » en Visual Basic."c:\\MyDir" in C#, or "c:\MyDir" in Visual Basic.

  • « MyDir\\MySubdir » en C# ou « Monrépertoire\monsousrépertoire » en Visual Basic."MyDir\\MySubdir" in C#, or "MyDir\MySubDir" in Visual Basic.

  • «\\\\MyServer\\MyShare » en C#, ou «\\MyServer\MyShare » en Visual Basic."\\\\MyServer\\MyShare" in C#, or "\\MyServer\MyShare" in Visual Basic.

Étant donné que toutes ces opérations sont effectuées sur les chaînes, il est impossible de vérifier que les résultats sont valides dans tous les scénarios.Because all these operations are performed on strings, it is impossible to verify that the results are valid in all scenarios. Par exemple, le GetExtension méthode analyse une chaîne que vous lui transmettez et retourne l’extension de cette chaîne.For example, the GetExtension method parses a string that you pass to it and returns the extension from that string. Toutefois, cela ne signifie pas qu’un fichier avec cette extension existe sur le disque.However, this does not mean that a file with that extension exists on the disk.

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Champs

AltDirectorySeparatorChar AltDirectorySeparatorChar AltDirectorySeparatorChar 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.Provides a platform-specific alternate character used to separate directory levels in a path string that reflects a hierarchical file system organization.

DirectorySeparatorChar DirectorySeparatorChar DirectorySeparatorChar 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.Provides a platform-specific character used to separate directory levels in a path string that reflects a hierarchical file system organization.

InvalidPathChars InvalidPathChars InvalidPathChars InvalidPathChars

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.Provides a platform-specific array of characters that cannot be specified in path string arguments passed to members of the Path class.

PathSeparator PathSeparator PathSeparator 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.A platform-specific separator character used to separate path strings in environment variables.

VolumeSeparatorChar VolumeSeparatorChar VolumeSeparatorChar VolumeSeparatorChar

Fournit un caractère de séparation de volume spécifique à la plateforme.Provides a platform-specific volume separator character.

Méthodes

ChangeExtension(String, String) ChangeExtension(String, String) ChangeExtension(String, String) ChangeExtension(String, String)

Modifie l'extension d'une chaîne de chemin d'accès.Changes the extension of a path string.

Combine(String[]) Combine(String[]) Combine(String[]) Combine(String[])

Combine un tableau de chaînes en un chemin d’accès.Combines an array of strings into a path.

Combine(String, String) Combine(String, String) Combine(String, String) Combine(String, String)

Combine deux chaînes en un chemin d’accès.Combines two strings into a path.

Combine(String, String, String) Combine(String, String, String) Combine(String, String, String) Combine(String, String, String)

Combine trois chaînes en un chemin d'accès.Combines three strings into a path.

Combine(String, String, String, String) Combine(String, String, String, String) Combine(String, String, String, String) Combine(String, String, String, String)

Combine quatre chaînes en un chemin d'accès.Combines four strings into a path.

GetDirectoryName(ReadOnlySpan<Char>) GetDirectoryName(ReadOnlySpan<Char>) GetDirectoryName(ReadOnlySpan<Char>) GetDirectoryName(ReadOnlySpan<Char>)

Renvoie les informations relatives au répertoire pour le chemin spécifié représenté par une étendue de caractères.Returns the directory information for the specified path represented by a character span.

GetDirectoryName(String) GetDirectoryName(String) GetDirectoryName(String) GetDirectoryName(String)

Retourne les informations relatives au répertoire pour la chaîne de chemin d’accès spécifiée.Returns the directory information for the specified path string.

GetExtension(String) GetExtension(String) GetExtension(String) GetExtension(String)

Retourne l'extension de la chaîne de chemin d'accès spécifiée.Returns the extension of the specified path string.

GetExtension(ReadOnlySpan<Char>) GetExtension(ReadOnlySpan<Char>) GetExtension(ReadOnlySpan<Char>) 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.Returns the extension of a file path that is represented by a read-only character span.

GetFileName(ReadOnlySpan<Char>) GetFileName(ReadOnlySpan<Char>) GetFileName(ReadOnlySpan<Char>) 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.Returns the file name and extension of a file path that is represented by a read-only character span.

GetFileName(String) GetFileName(String) GetFileName(String) GetFileName(String)

Retourne le nom et l’extension de fichier de la chaîne de chemin d’accès spécifiée.Returns the file name and extension of the specified path string.

GetFileNameWithoutExtension(ReadOnlySpan<Char>) GetFileNameWithoutExtension(ReadOnlySpan<Char>) GetFileNameWithoutExtension(ReadOnlySpan<Char>) 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.Returns the file name without the extension of a file path that is represented by a read-only character span.

GetFileNameWithoutExtension(String) GetFileNameWithoutExtension(String) GetFileNameWithoutExtension(String) GetFileNameWithoutExtension(String)

Retourne le nom de fichier de la chaîne de chemin d'accès spécifiée sans l'extension.Returns the file name of the specified path string without the extension.

GetFullPath(String) GetFullPath(String) GetFullPath(String) GetFullPath(String)

Retourne le chemin d'accès absolu de la chaîne de chemin d'accès spécifiée.Returns the absolute path for the specified path string.

GetFullPath(String, String) GetFullPath(String, String) GetFullPath(String, String) GetFullPath(String, String)

Renvoie un chemin d'accès complet à partir d'un chemin de base complet et d'un chemin relatif.Returns an absolute path from a fully qualified base path and a relative path.

GetInvalidFileNameChars() GetInvalidFileNameChars() GetInvalidFileNameChars() GetInvalidFileNameChars()

Obtient un tableau contenant les caractères qui ne sont pas autorisés dans les noms de fichiers.Gets an array containing the characters that are not allowed in file names.

GetInvalidPathChars() GetInvalidPathChars() GetInvalidPathChars() GetInvalidPathChars()

Obtient un tableau contenant les caractères qui ne sont pas autorisés dans les noms de chemins d'accès.Gets an array containing the characters that are not allowed in path names.

GetPathRoot(String) GetPathRoot(String) GetPathRoot(String) GetPathRoot(String)

Obtient les informations relatives au répertoire racine du chemin d’accès spécifié.Gets the root directory information of the specified path.

GetPathRoot(ReadOnlySpan<Char>) GetPathRoot(ReadOnlySpan<Char>) GetPathRoot(ReadOnlySpan<Char>) 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.Gets the root directory information from the path contained in the specified character span.

GetRandomFileName() GetRandomFileName() GetRandomFileName() GetRandomFileName()

Retourne un nom de dossier ou de fichier aléatoire.Returns a random folder name or file name.

GetRelativePath(String, String) GetRelativePath(String, String) GetRelativePath(String, String) GetRelativePath(String, String)

Renvoie un chemin d'accès relatif d'un chemin à un autre.Returns a relative path from one path to another.

GetTempFileName() GetTempFileName() GetTempFileName() 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.Creates a uniquely named, zero-byte temporary file on disk and returns the full path of that file.

GetTempPath() GetTempPath() GetTempPath() GetTempPath()

Retourne le chemin d’accès du dossier temporaire de l’utilisateur actuel.Returns the path of the current user's temporary folder.

HasExtension(ReadOnlySpan<Char>) HasExtension(ReadOnlySpan<Char>) HasExtension(ReadOnlySpan<Char>) 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.Determines whether the path represented by the specified character span includes a file name extension.

HasExtension(String) HasExtension(String) HasExtension(String) HasExtension(String)

Détermine si un chemin d'accès inclut une extension de nom de fichier.Determines whether a path includes a file name extension.

IsPathFullyQualified(ReadOnlySpan<Char>) IsPathFullyQualified(ReadOnlySpan<Char>) IsPathFullyQualified(ReadOnlySpan<Char>) 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.Returns a value that indicates whether the file path represented by the specified character span is fixed to a specific drive or UNC path.

IsPathFullyQualified(String) IsPathFullyQualified(String) IsPathFullyQualified(String) 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.Returns a value that indicates whether the specified file path is fixed to a specific drive or UNC path.

IsPathRooted(String) IsPathRooted(String) IsPathRooted(String) IsPathRooted(String)

Renvoie une valeur indiquant si la chaîne de chemin d'accès spécifiée contient une racine.Returns a value indicating whether the specified path string contains a root.

IsPathRooted(ReadOnlySpan<Char>) IsPathRooted(ReadOnlySpan<Char>) IsPathRooted(ReadOnlySpan<Char>) 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.Returns a value that indicates whether the specified character span that represents a file path contains a root.

Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène deux composants de chemin d'accès en un seul chemin.Concatenates two path components into a single path.

Join(String, String) Join(String, String) Join(String, String) Join(String, String)
Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Join(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatène trois composants de chemin d'accès en un seul chemin.Concatenates three path components into a single path.

Join(String, String, String) Join(String, String, String) Join(String, String, String) Join(String, String, String)
TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32) TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32) TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32) 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.Attempts to concatenate two path components to a single preallocated character span, and returns a value that indicates whether the operation succeeded.

TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32) TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32) TryJoin(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, Span<Char>, Int32) TryJoin(ReadOnlySpan<Char>, 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.Attempts to concatenate two path components to a single preallocated character span, and returns a value that indicates whether the operation succeeded.

S’applique à

Voir aussi