Partager via


DirectoryInfo.GetDirectories Méthode

Définition

Retourne les sous-répertoires du répertoire actuel.

Surcharges

GetDirectories()

Retourne les sous-répertoires du répertoire actuel.

GetDirectories(String)

Retourne un tableau de répertoires dans le DirectoryInfo en cours satisfaisant aux critères de recherche spécifiés.

GetDirectories(String, EnumerationOptions)

Retourne un tableau de répertoires dans l’élément DirectoryInfo actuel correspondant au modèle de recherche et aux options d'énumération spécifiés.

GetDirectories(String, SearchOption)

Retourne un tableau de répertoires dans le DirectoryInfo en cours qui correspond à des critères de recherche donnés et qui utilise une valeur pour déterminer s'il faut effectuer une recherche dans les sous-répertoires.

GetDirectories()

Source:
DirectoryInfo.cs
Source:
DirectoryInfo.cs
Source:
DirectoryInfo.cs

Retourne les sous-répertoires du répertoire actuel.

public:
 cli::array <System::IO::DirectoryInfo ^> ^ GetDirectories();
public System.IO.DirectoryInfo[] GetDirectories ();
member this.GetDirectories : unit -> System.IO.DirectoryInfo[]
Public Function GetDirectories () As DirectoryInfo()

Retours

Tableau d'objets DirectoryInfo.

Exceptions

Le chemin d’accès encapsulé dans l’objet DirectoryInfo n’est pas valide (par exemple, il est sur un lecteur non mappé).

L'appelant n'a pas l'autorisation requise.

L'appelant n'a pas l'autorisation requise.

Exemples

L’exemple suivant récupère tous les répertoires du répertoire racine et affiche les noms de répertoires.

using namespace System;
using namespace System::IO;
int main()
{
   
   // Make a reference to a directory.
   DirectoryInfo^ di = gcnew DirectoryInfo( "c:\\" );
   
   // Get a reference to each directory in that directory.
   array<DirectoryInfo^>^diArr = di->GetDirectories();
   
   // Display the names of the directories.
   Collections::IEnumerator^ myEnum = diArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      DirectoryInfo^ dri = safe_cast<DirectoryInfo^>(myEnum->Current);
      Console::WriteLine( dri->Name );
   }
}
using System;
using System.IO;

public class GetDirectoriesTest
{
    public static void Main()
    {

        // Make a reference to a directory.
        DirectoryInfo di = new DirectoryInfo("c:\\");

        // Get a reference to each directory in that directory.
        DirectoryInfo[] diArr = di.GetDirectories();

        // Display the names of the directories.
        foreach (DirectoryInfo dri in diArr)
            Console.WriteLine(dri.Name);
    }
}
open System.IO

// Make a reference to a directory.
let di = DirectoryInfo "c:\\"

// Get a reference to each directory in that directory.
let diArr = di.GetDirectories()

// Display the names of the directories.
for dri in diArr do
    printfn $"{dri.Name}"
Imports System.IO

Public Class GetDirectoriesTest

    Public Shared Sub Main()
        ' Make a reference to a directory.
        Dim di As New DirectoryInfo("c:\")
        ' Get a reference to each directory in that directory.
        Dim diArr As DirectoryInfo() = di.GetDirectories()
        ' Display the names of the directories.
        Dim dri As DirectoryInfo
        For Each dri In diArr
            Console.WriteLine(dri.Name)
        Next dri
    End Sub
End Class

Remarques

S’il n’existe aucun sous-répertoire, cette méthode retourne un tableau vide. Cette méthode n’est pas récursive.

Cette méthode préremplit les valeurs des propriétés suivantes DirectoryInfo :

Voir aussi

S’applique à

GetDirectories(String)

Source:
DirectoryInfo.cs
Source:
DirectoryInfo.cs
Source:
DirectoryInfo.cs

Retourne un tableau de répertoires dans le DirectoryInfo en cours satisfaisant aux critères de recherche spécifiés.

public:
 cli::array <System::IO::DirectoryInfo ^> ^ GetDirectories(System::String ^ searchPattern);
public System.IO.DirectoryInfo[] GetDirectories (string searchPattern);
member this.GetDirectories : string -> System.IO.DirectoryInfo[]
Public Function GetDirectories (searchPattern As String) As DirectoryInfo()

Paramètres

searchPattern
String

Chaîne recherchée à trouver parmi les noms de répertoires. Ce paramètre peut contenir une combinaison d’un chemin littéral valide et de caractères génériques (* et ?), mais il ne prend pas en charge les expressions régulières.

Retours

Tableau de type DirectoryInfo correspondant à searchPattern.

Exceptions

.NET Framework et .NET Core versions antérieures à 2.1 : searchPattern contient un ou plusieurs caractères non valides définis par la GetInvalidPathChars() méthode .

searchPattern a la valeur null.

Le chemin d’accès encapsulé dans l’objet DirectoryInfo n’est pas valide (par exemple, il est sur un lecteur non mappé).

L'appelant n'a pas l'autorisation requise.

Exemples

L’exemple suivant compte les répertoires d’un chemin qui contiennent la lettre spécifiée.

using namespace System;
using namespace System::IO;
int main()
{
   try
   {
      DirectoryInfo^ di = gcnew DirectoryInfo( "c:\\" );
      
      // Get only subdirectories that contain the letter "p."
      array<DirectoryInfo^>^dirs = di->GetDirectories( "*p*" );
      Console::WriteLine( "The number of directories containing the letter p is {0}.", dirs->Length );
      Collections::IEnumerator^ myEnum = dirs->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         DirectoryInfo^ diNext = safe_cast<DirectoryInfo^>(myEnum->Current);
         Console::WriteLine( "The number of files in {0} is {1}", diNext, diNext->GetFiles()->Length );
      }
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "The process failed: {0}", e );
   }

}
using System;
using System.IO;

class Test
{
    public static void Main()
    {
        try
        {
            DirectoryInfo di = new DirectoryInfo(@"c:\");

            // Get only subdirectories that contain the letter "p."
            DirectoryInfo[] dirs = di.GetDirectories("*p*");
            Console.WriteLine("The number of directories containing the letter p is {0}.", dirs.Length);

            foreach (DirectoryInfo diNext in dirs)
            {
                Console.WriteLine("The number of files in {0} is {1}", diNext,
                    diNext.GetFiles().Length);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("The process failed: {0}", e.ToString());
        }
    }
}
open System.IO

try
    let di = DirectoryInfo @"c:\"

    // Get only subdirectories that contain the letter "p."
    let dirs = di.GetDirectories "*p*"
    printfn $"The number of directories containing the letter p is {dirs.Length}."

    for diNext in dirs do
        printfn $"The number of files in {diNext} is {diNext.GetFiles().Length}"
with e ->
    printfn $"The process failed: {e}"
Imports System.IO

Public Class Test
    Public Shared Sub Main()
        ' Specify the directories you want to manipulate.
        Dim di As DirectoryInfo = New DirectoryInfo("c:\")

        Try
            'Get only subdirectories that contain the letter "p."
            Dim dirs As DirectoryInfo() = di.GetDirectories("*p*")
            Console.WriteLine("The number of directories containing the letter p is {0}.", dirs.Length)
            Dim diNext As DirectoryInfo
            For Each diNext In dirs
                Console.WriteLine("The number of files in {0} is {1}", diNext, _
                 diNext.GetFiles().Length)
            Next

        Catch e As Exception
            Console.WriteLine("The process failed: {0}", e.ToString())
        End Try
    End Sub
End Class

Remarques

searchPattern peut être une combinaison de caractères littéraux et génériques, mais elle ne prend pas en charge les expressions régulières. Les spécificateurs génériques suivants sont autorisés dans searchPattern.

Spécificateur générique Correspond à
* (astérisque) Zéro ou plusieurs caractères dans cette position.
? (point d’interrogation) Zéro ou un caractère dans cette position.

Les caractères autres que le caractère générique sont des caractères littéraux. Par exemple, la chaîne « *t » recherche tous les noms en se terminant par la lettre « t ». ". La searchPattern chaîne « s* » recherche tous les noms en path commençant par la lettre « s ».

Cette méthode préremplit les valeurs des propriétés suivantes DirectoryInfo :

Voir aussi

S’applique à

GetDirectories(String, EnumerationOptions)

Source:
DirectoryInfo.cs
Source:
DirectoryInfo.cs
Source:
DirectoryInfo.cs

Retourne un tableau de répertoires dans l’élément DirectoryInfo actuel correspondant au modèle de recherche et aux options d'énumération spécifiés.

public:
 cli::array <System::IO::DirectoryInfo ^> ^ GetDirectories(System::String ^ searchPattern, System::IO::EnumerationOptions ^ enumerationOptions);
public System.IO.DirectoryInfo[] GetDirectories (string searchPattern, System.IO.EnumerationOptions enumerationOptions);
member this.GetDirectories : string * System.IO.EnumerationOptions -> System.IO.DirectoryInfo[]
Public Function GetDirectories (searchPattern As String, enumerationOptions As EnumerationOptions) As DirectoryInfo()

Paramètres

searchPattern
String

Chaîne recherchée à trouver parmi les noms de répertoires. Ce paramètre peut contenir une combinaison d’un chemin littéral valide et de caractères génériques (* et ?), mais il ne prend pas en charge les expressions régulières.

enumerationOptions
EnumerationOptions

Objet qui décrit la configuration de recherche et d’énumération à utiliser.

Retours

Tableau de type DirectoryInfo correspondant à searchPattern et enumerationOptions.

Exceptions

.NET Framework et .NET Core versions antérieures à 2.1 : searchPattern contient un ou plusieurs caractères non valides définis par la GetInvalidPathChars() méthode .

searchPattern a la valeur null.

Le chemin d’accès encapsulé dans l’objet DirectoryInfo n’est pas valide (par exemple, il est sur un lecteur non mappé).

L'appelant n'a pas l'autorisation requise.

Remarques

searchPattern peut être une combinaison de caractères littéraux et génériques, mais elle ne prend pas en charge les expressions régulières. Les spécificateurs génériques suivants sont autorisés dans searchPattern.

Spécificateur générique Correspond à
* (astérisque) Zéro ou plusieurs caractères dans cette position.
? (point d’interrogation) Zéro ou un caractère dans cette position.

Les caractères autres que le caractère générique sont des caractères littéraux. Par exemple, la chaîne « *t » recherche tous les noms en se terminant par la lettre « t ». ". La searchPattern chaîne « s* » recherche tous les noms en path commençant par la lettre « s ».

Cette méthode préremplit les valeurs des propriétés suivantes DirectoryInfo :

S’applique à

GetDirectories(String, SearchOption)

Source:
DirectoryInfo.cs
Source:
DirectoryInfo.cs
Source:
DirectoryInfo.cs

Retourne un tableau de répertoires dans le DirectoryInfo en cours qui correspond à des critères de recherche donnés et qui utilise une valeur pour déterminer s'il faut effectuer une recherche dans les sous-répertoires.

public:
 cli::array <System::IO::DirectoryInfo ^> ^ GetDirectories(System::String ^ searchPattern, System::IO::SearchOption searchOption);
public System.IO.DirectoryInfo[] GetDirectories (string searchPattern, System.IO.SearchOption searchOption);
member this.GetDirectories : string * System.IO.SearchOption -> System.IO.DirectoryInfo[]
Public Function GetDirectories (searchPattern As String, searchOption As SearchOption) As DirectoryInfo()

Paramètres

searchPattern
String

Chaîne recherchée à trouver parmi les noms de répertoires. Ce paramètre peut contenir une combinaison d’un chemin littéral valide et de caractères génériques (* et ?), mais il ne prend pas en charge les expressions régulières.

searchOption
SearchOption

L'une des valeurs d'énumération qui spécifie si l'opération de recherche doit inclure uniquement le répertoire actif ou tous les sous-répertoires.

Retours

Tableau de type DirectoryInfo correspondant à searchPattern.

Exceptions

.NET Framework et .NET Core versions antérieures à 2.1 : searchPattern contient un ou plusieurs caractères non valides définis par la GetInvalidPathChars() méthode .

searchPattern a la valeur null.

searchOption n’est pas une valeur de SearchOption valide.

Le chemin d’accès encapsulé dans l’objet DirectoryInfo n’est pas valide (par exemple, il est sur un lecteur non mappé).

L'appelant n'a pas l'autorisation requise.

Exemples

L’exemple suivant répertorie tous les répertoires et fichiers qui commencent par la lettre « c » dans « c :\ ».

using namespace System;
using namespace System::IO;

ref class App
{
public:
    static void Main()
    {
        // Specify the directory you want to manipulate.
        String^ path = "c:\\";
        String^ searchPattern = "c*";

        DirectoryInfo^ di = gcnew DirectoryInfo(path);
        array<DirectoryInfo^>^ directories =
            di->GetDirectories(searchPattern, SearchOption::TopDirectoryOnly);

        array<FileInfo^>^ files =
            di->GetFiles(searchPattern, SearchOption::TopDirectoryOnly);

        Console::WriteLine(
            "Directories that begin with the letter \"c\" in {0}", path);
        for each (DirectoryInfo^ dir in directories)
        {
            Console::WriteLine(
                "{0,-25} {1,25}", dir->FullName, dir->LastWriteTime);
        }

        Console::WriteLine();
        Console::WriteLine(
            "Files that begin with the letter \"c\" in {0}", path);
        for each (FileInfo^ file in files)
        {
            Console::WriteLine(
                "{0,-25} {1,25}", file->Name, file->LastWriteTime);
        }
    } // Main()
}; // App()

int main()
{
    App::Main();
}
using System;
using System.IO;

class App
{
    public static void Main()
    {
        // Specify the directory you want to manipulate.
        string path = @"c:\";
        string searchPattern = "c*";

        DirectoryInfo di = new DirectoryInfo(path);
        DirectoryInfo[] directories =
            di.GetDirectories(searchPattern, SearchOption.TopDirectoryOnly);

        FileInfo[] files =
            di.GetFiles(searchPattern, SearchOption.TopDirectoryOnly);

        Console.WriteLine(
            "Directories that begin with the letter \"c\" in {0}", path);
        foreach (DirectoryInfo dir in directories)
        {
            Console.WriteLine(
                "{0,-25} {1,25}", dir.FullName, dir.LastWriteTime);
        }

        Console.WriteLine();
        Console.WriteLine(
            "Files that begin with the letter \"c\" in {0}", path);
        foreach (FileInfo file in files)
        {
            Console.WriteLine(
                "{0,-25} {1,25}", file.Name, file.LastWriteTime);
        }
    } // Main()
} // App()
open System.IO

// Specify the directory you want to manipulate.
let path = @"c:\"
let searchPattern = "c*"

let di = DirectoryInfo path
let directories = di.GetDirectories(searchPattern, SearchOption.TopDirectoryOnly)

let files = di.GetFiles(searchPattern, SearchOption.TopDirectoryOnly)

printfn $"Directories that begin with the letter \"c\" in {path}"
for dir in directories do
    printfn $"{dir.FullName,-25} {dir.LastWriteTime,25}"

printfn $"\nFiles that begin with the letter \"c\" in {path}"
for file in files do
    printfn $"{file.Name,-25} {file.LastWriteTime,25}"
Imports System.IO

Class App
    Public Shared Sub Main()
        ' Specify the directory you want to manipulate.
        Dim path As String = "c:\\"
        Dim searchPattern As String = "c*"

        Dim di As DirectoryInfo = New DirectoryInfo(path)
        Dim directories() As DirectoryInfo = _
            di.GetDirectories(searchPattern, SearchOption.TopDirectoryOnly)

        Dim files() As FileInfo = _
            di.GetFiles(searchPattern, SearchOption.TopDirectoryOnly)

        Console.WriteLine( _
            "Directories that begin with the letter 'c' in {0}", path)
        Dim dir As DirectoryInfo
        For Each dir In directories
            Console.WriteLine( _
                "{0,-25} {1,25}", dir.FullName, dir.LastWriteTime)
        Next dir

        Console.WriteLine()
        Console.WriteLine( _
            "Files that begin with the letter 'c' in {0}", path)
        Dim file As FileInfo
        For Each file In files
            Console.WriteLine( _
                "{0,-25} {1,25}", file.Name, file.LastWriteTime)
        Next file
    End Sub
End Class

Remarques

searchPattern peut être une combinaison de caractères littéraux et génériques, mais elle ne prend pas en charge les expressions régulières. Les spécificateurs génériques suivants sont autorisés dans searchPattern.

Spécificateur générique Correspond à
* (astérisque) Zéro ou plusieurs caractères dans cette position.
? (point d’interrogation) Zéro ou un caractère dans cette position.

Les caractères autres que le caractère générique sont des caractères littéraux. Par exemple, la chaîne « *t » recherche tous les noms en se terminant par la lettre « t ». ". La searchPattern chaîne « s* » recherche tous les noms en path commençant par la lettre « s ».

S’il n’existe aucun sous-répertoire ou si aucun sous-répertoire ne correspond au searchPattern paramètre, cette méthode retourne un tableau vide.

Cette méthode préremplit les valeurs des propriétés suivantes DirectoryInfo :

Voir aussi

S’applique à