DirectoryInfo Classe

Definizione

Spazio dei nomi:

System.IO

Assembly:

System.Runtime.dll

Origine:

DirectoryInfo.cs

Espone i metodi dell'istanza per la creazione, lo spostamento e l'enumerazione tramite directory e sottodirectory. La classe non può essere ereditata.

public ref class DirectoryInfo sealed : System::IO::FileSystemInfo

public sealed class DirectoryInfo : System.IO.FileSystemInfo

type DirectoryInfo = class
    inherit FileSystemInfo

Public NotInheritable Class DirectoryInfo
Inherits FileSystemInfo

Ereditarietà

Object

MarshalByRefObject

FileSystemInfo

DirectoryInfo

Esempio

Nell'esempio seguente vengono illustrati alcuni dei membri principali della DirectoryInfo classe.

using namespace System;
using namespace System::IO;
int main()
{
   
   // Specify the directories you want to manipulate.
   DirectoryInfo^ di = gcnew DirectoryInfo( "c:\\MyDir" );
   try
   {
      
      // Determine whether the directory exists.
      if ( di->Exists )
      {
         
         // Indicate that the directory already exists.
         Console::WriteLine( "That path exists already." );
         return 0;
      }
      
      // Try to create the directory.
      di->Create();
      Console::WriteLine( "The directory was created successfully." );
      
      // Delete the directory.
      di->Delete();
      Console::WriteLine( "The directory was deleted successfully." );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "The process failed: {0}", e );
   }

}

using System;
using System.IO;

class Test
{
    public static void Main()
    {
        // Specify the directories you want to manipulate.
        DirectoryInfo di = new DirectoryInfo(@"c:\MyDir");
        try
        {
            // Determine whether the directory exists.
            if (di.Exists)
            {
                // Indicate that the directory already exists.
                Console.WriteLine("That path exists already.");
                return;
            }

            // Try to create the directory.
            di.Create();
            Console.WriteLine("The directory was created successfully.");

            // Delete the directory.
            di.Delete();
            Console.WriteLine("The directory was deleted successfully.");
        }
        catch (Exception e)
        {
            Console.WriteLine("The process failed: {0}", e.ToString());
        }
        finally {}
    }
}

open System.IO

// Specify the directories you want to manipulate.
let di = DirectoryInfo @"c:\MyDir"
try
    // Determine whether the directory exists.
    if di.Exists then
        // Indicate that the directory already exists.
        printfn "That path exists already."
    else
        // Try to create the directory.
        di.Create()
        printfn "The directory was created successfully."

        // Delete the directory.
        di.Delete()
        printfn "The directory was deleted successfully."
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:\MyDir")
        Try
            ' Determine whether the directory exists.
            If di.Exists Then
                ' Indicate that it already exists.
                Console.WriteLine("That path exists already.")
                Return
            End If

            ' Try to create the directory.
            di.Create()
            Console.WriteLine("The directory was created successfully.")

            ' Delete the directory.
            di.Delete()
            Console.WriteLine("The directory was deleted successfully.")

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

Nell'esempio seguente viene illustrato come copiare una directory e il relativo contenuto.

using System;
using System.IO;

class CopyDir
{
    public static void CopyAll(DirectoryInfo source, DirectoryInfo target)
    {
        if (source.FullName.ToLower() == target.FullName.ToLower())
        {
            return;
        }

        // Check if the target directory exists, if not, create it.
        if (Directory.Exists(target.FullName) == false)
        {
            Directory.CreateDirectory(target.FullName);
        }

        // Copy each file into it's new directory.
        foreach (FileInfo fi in source.GetFiles())
        {
            Console.WriteLine(@"Copying {0}\{1}", target.FullName, fi.Name);
            fi.CopyTo(Path.Combine(target.ToString(), fi.Name), true);
        }

        // Copy each subdirectory using recursion.
        foreach (DirectoryInfo diSourceSubDir in source.GetDirectories())
        {
            DirectoryInfo nextTargetSubDir =
                target.CreateSubdirectory(diSourceSubDir.Name);
            CopyAll(diSourceSubDir, nextTargetSubDir);
        }
    }

    public static void Main()
    {
        string sourceDirectory = @"c:\sourceDirectory";
        string targetDirectory = @"c:\targetDirectory";

        DirectoryInfo diSource = new DirectoryInfo(sourceDirectory);
        DirectoryInfo diTarget = new DirectoryInfo(targetDirectory);

        CopyAll(diSource, diTarget);
    }

    // Output will vary based on the contents of the source directory.
}

open System.IO

let rec copyAll (source: DirectoryInfo) (target: DirectoryInfo) =
    if source.FullName.ToLower() <> target.FullName.ToLower() then
        // Check if the target directory exists, if not, create it.
        if not (Directory.Exists target.FullName) then
            Directory.CreateDirectory target.FullName |> ignore

        // Copy each file into it's new directory.
        for fi in source.GetFiles() do
            printfn $@"Copying {target.FullName}\{fi.Name}"
            fi.CopyTo(Path.Combine(string target, fi.Name), true) |> ignore

        // Copy each subdirectory using recursion.
        for diSourceSubDir in source.GetDirectories() do
            target.CreateSubdirectory diSourceSubDir.Name
            |> copyAll diSourceSubDir

let sourceDirectory = @"c:\sourceDirectory"
let targetDirectory = @"c:\targetDirectory"

let diSource = DirectoryInfo sourceDirectory
let diTarget = DirectoryInfo targetDirectory

copyAll diSource diTarget

// Output will vary based on the contents of the source directory.

Imports System.IO

Class CopyDir
    Shared Sub CopyAll(ByVal source As DirectoryInfo, ByVal target As DirectoryInfo)
        If (source.FullName.ToLower() = target.FullName.ToLower()) Then
            Return
        End If

        ' Check if the target directory exists, if not, create it.
        If Directory.Exists(target.FullName) = False Then
            Directory.CreateDirectory(target.FullName)
        End If

        ' Copy each file into it's new directory.
        For Each fi As FileInfo In source.GetFiles()
            Console.WriteLine("Copying {0}\{1}", target.FullName, fi.Name)
            fi.CopyTo(Path.Combine(target.ToString(), fi.Name), True)
        Next

        ' Copy each subdirectory using recursion.
        For Each diSourceSubDir As DirectoryInfo In source.GetDirectories()
            Dim nextTargetSubDir As DirectoryInfo = target.CreateSubdirectory(diSourceSubDir.Name)
            CopyAll(diSourceSubDir, nextTargetSubDir)
        Next
    End Sub

    Shared Sub Main()
        Dim sourceDirectory As String = "c:\\sourceDirectory"
        Dim targetDirectory As String = "c:\\targetDirectory"

        Dim diSource As DirectoryInfo = New DirectoryInfo(sourceDirectory)
        Dim diTarget As DirectoryInfo = New DirectoryInfo(targetDirectory)

        CopyAll(diSource, diTarget)
    End Sub
    ' Output will vary based on the contents of the source directory.
End Class

Commenti

Usare la classe per operazioni tipiche, ad esempio la copia, lo spostamento, la ridenominazione, la creazione e l'eliminazione DirectoryInfo di directory.

Se si intende riutilizzare un oggetto più volte, è consigliabile usare il metodo di istanza anziché DirectoryInfo i metodi statici corrispondenti della classe, perché un controllo di Directory sicurezza non sarà sempre necessario.

Nota

Nei membri che accettano un percorso come stringa di input, tale percorso deve essere formato correttamente o viene generata un'eccezione. Ad esempio, se un percorso è completo, ma inizia con uno spazio, il percorso non viene tagliato nei metodi della classe. Pertanto, il percorso è non valido e viene generata un'eccezione. Analogamente, un percorso o una combinazione di percorsi non può essere completo due volte. Ad esempio, "c:\temp c:\windows" genera anche un'eccezione nella maggior parte dei casi. Assicurarsi che i percorsi siano ben formati quando si usano metodi che accettano una stringa di percorso.

Nei membri che accettano un percorso, il percorso può fare riferimento a un file o solo a una directory. Il percorso specificato può anche fare riferimento a un percorso relativo o a un percorso UNC (Universal Naming Convention) per un server e un nome di condivisione. Ad esempio, tutti i percorsi seguenti sono accettabili:

• "c:\\MyDir\\MyFile.txt" in C#o "c:\MyDir\MyFile.txt" in Visual Basic.

• "c:\\MyDir" in C#o "c:\MyDir" in Visual Basic.

• "MyDir\\MySubdir" in C#o "MyDir\MySubDir" in Visual Basic.

• "\MyServer\\MyShare" in C#o "\\MyServer\MyShare" in Visual Basic.

Per impostazione predefinita, l'accesso in lettura/scrittura completo alle nuove directory viene concesso a tutti gli utenti.

Per un elenco di attività di I/O comuni, vedere Attività di I/O comuni.

Costruttori

DirectoryInfo(String)

Inizializza una nuova istanza della classe DirectoryInfo nel percorso specificato.

Campi

FullPath	Rappresenta il percorso completo del file o della directory. (Ereditato da FileSystemInfo)
OriginalPath	Percorso, assoluto o relativo, originariamente specificato dall'utente. (Ereditato da FileSystemInfo)

Proprietà

Attributes	Ottiene o imposta gli attributi per il file o la directory corrente. (Ereditato da FileSystemInfo)
CreationTime	Ottiene o imposta l'ora di creazione del file o della directory corrente. (Ereditato da FileSystemInfo)
CreationTimeUtc	Ottiene o imposta l'ora di creazione, nell'ora UTC (Coordinated Universal Time) del file o della directory corrente. (Ereditato da FileSystemInfo)
Exists	Ottiene un valore che indica se la directory esiste.
Extension	Ottiene la parte di estensione del nome del file, incluso il punto . iniziale anche se è l'intero nome del file o una stringa vuota se non è presente alcuna estensione. (Ereditato da FileSystemInfo)
FullName	Recupera il percorso completo del file o della directory. (Ereditato da FileSystemInfo)
LastAccessTime	Recupera o imposta l'ora in cui è avvenuto l'ultimo accesso al file o alla directory corrente. (Ereditato da FileSystemInfo)
LastAccessTimeUtc	Ottiene o imposta l'ora, nell'ora UTC (Universal Coordinated Time), dell'ultimo accesso al file o alla directory corrente. (Ereditato da FileSystemInfo)
LastWriteTime	Recupera o imposta l'ora dell'ultima modifica del file o della directory corrente. (Ereditato da FileSystemInfo)
LastWriteTimeUtc	Ottiene o imposta l'ora, nell'ora UTC (Universal Coordinated Time), dell'ultima scrittura al file o alla directory corrente. (Ereditato da FileSystemInfo)
LinkTarget	Ottiene il percorso di destinazione del collegamento che si trova in FullNameo null se questa FileSystemInfo istanza non rappresenta un collegamento. (Ereditato da FileSystemInfo)
Name	Recupera il nome di questa istanza di DirectoryInfo.
Parent	Ottiene la directory padre di una sottodirectory specificata.
Root	Ottiene la radice della directory.
UnixFileMode	Ottiene o imposta la modalità file Unix per il file o la directory corrente. (Ereditato da FileSystemInfo)

Metodi

Create()	Crea una directory.
CreateAsSymbolicLink(String)	Crea un collegamento simbolico che si trova in FullName che punta all'oggetto specificato pathToTarget. (Ereditato da FileSystemInfo)
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
CreateSubdirectory(String)	Crea una o più sottodirectory nel percorso specificato. Il percorso specificato può essere relativo a questa istanza della classe DirectoryInfo.
Delete()	Elimina questo oggetto DirectoryInfo se è vuoto.
Delete(Boolean)	Elimina questa istanza di DirectoryInfo, specificando se eliminare le subdirectory e i file.
EnumerateDirectories()	Restituisce un insieme enumerabile di informazioni sulla directory nella directory corrente.
EnumerateDirectories(String)	Restituisce una raccolta enumerabile di informazioni sulla directory che corrispondono a un criterio di ricerca specificato.
EnumerateDirectories(String, EnumerationOptions)	Restituisce una raccolta enumerabile di informazioni sulla directory che corrisponde al criterio di ricerca e alle opzioni di enumerazione specificati.
EnumerateDirectories(String, SearchOption)	Restituisce una raccolta enumerabile di informazioni sulla directory che corrispondono a un criterio di ricerca e all'opzione di ricerca subdirectory specificati.
EnumerateFiles()	Restituisce un insieme enumerabile di informazioni sui file nella directory corrente.
EnumerateFiles(String)	Restituisce una raccolta enumerabile di informazioni sui file che corrispondono a un criterio di ricerca.
EnumerateFiles(String, EnumerationOptions)	Restituisce una raccolta enumerabile di informazioni sui file che corrisponde al criterio di ricerca e alle opzioni di enumerazione specificati.
EnumerateFiles(String, SearchOption)	Restituisce una raccolta enumerabile di informazioni sui file che corrispondono a un criterio di ricerca e all'opzione di ricerca subdirectory specificati.
EnumerateFileSystemInfos()	Restituisce una raccolta enumerabile di informazioni di file system nella directory corrente.
EnumerateFileSystemInfos(String)	Restituisce una raccolta enumerabile di informazioni sul file system che corrisponde a un criterio di ricerca specificato.
EnumerateFileSystemInfos(String, EnumerationOptions)	Restituisce una raccolta enumerabile di informazioni sul file system che corrisponde al criterio di ricerca e alle opzioni di enumerazione specificati.
EnumerateFileSystemInfos(String, SearchOption)	Restituisce una raccolta enumerabile di informazioni sul file system che corrisponde a un criterio di ricerca e all'opzione di ricerca subdirectory specificati.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetDirectories()	Restituisce le sottodirectory della directory corrente.
GetDirectories(String)	Restituisce una matrice di directory nell'oggetto DirectoryInfo corrente che corrisponde ai criteri di ricerca specificati.
GetDirectories(String, EnumerationOptions)	Restituisce una matrice di directory nell'elemento DirectoryInfo corrente corrispondente al criterio di ricerca e alle opzioni di enumerazione specificati.
GetDirectories(String, SearchOption)	Restituisce una matrice di directory nella classe DirectoryInfo corrente che corrisponde ai criteri di ricerca forniti e che utilizza un valore per determinare se eseguire la ricerca nelle sottodirectory.
GetFiles()	Restituisce un elenco di file della directory corrente.
GetFiles(String)	Restituisce un elenco di file della directory corrente corrispondente al criterio di ricerca fornito.
GetFiles(String, EnumerationOptions)	Restituisce un elenco di file dalla directory corrente corrispondente al criterio di ricerca e alle opzioni di enumerazione specificati.
GetFiles(String, SearchOption)	Restituisce un elenco di file dalla directory corrente che corrisponde al criterio di ricerca fornito e che utilizza un valore per determinare se eseguire la ricerca nelle sottodirectory.
GetFileSystemInfos()	Restituisce una matrice di voci FileSystemInfo fortemente tipizzate che rappresenta tutti i file e le sottodirectory in una directory.
GetFileSystemInfos(String)	Recupera una matrice di oggetti FileSystemInfo fortemente tipizzati che rappresenta i file e le sottodirectory corrispondenti ai criteri di ricerca specificati.
GetFileSystemInfos(String, EnumerationOptions)	Recupera una matrice di oggetti FileSystemInfo fortemente tipizzati che rappresenta i file e le sottodirectory corrispondenti al criterio di ricerca e alle opzioni di enumerazione specificati.
GetFileSystemInfos(String, SearchOption)	Recupera una matrice di oggetti FileSystemInfo che rappresenta i file e le sottodirectory corrispondenti ai criteri di ricerca specificati.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetObjectData(SerializationInfo, StreamingContext)	Obsoleti. Imposta l'oggetto SerializationInfo con il nome del file e le informazioni aggiuntive sull'eccezione. (Ereditato da FileSystemInfo)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
MoveTo(String)	Sposta un'istanza di DirectoryInfo e il relativo contenuto in un nuovo percorso.
Refresh()	Aggiorna lo stato dell'oggetto. (Ereditato da FileSystemInfo)
ResolveLinkTarget(Boolean)	Ottiene la destinazione del collegamento specificato. (Ereditato da FileSystemInfo)
ToString()	Restituisce il percorso originale passato al costruttore DirectoryInfo. Usare le proprietà FullName o Name per il percorso completo o il nome di file/directory invece di questo metodo.

Metodi di estensione

Create(DirectoryInfo, DirectorySecurity)	Crea una nuova directory, verificando che venga creata con la sicurezza della directory specificata. Se la directory esiste già non viene eseguita nessuna operazione.
GetAccessControl(DirectoryInfo)	Restituisce le informazioni di sicurezza di una directory.
GetAccessControl(DirectoryInfo, AccessControlSections)	Restituisce le informazioni di sicurezza di una directory.
SetAccessControl(DirectoryInfo, DirectorySecurity)	Modifica gli attributi di sicurezza di una directory esistente.

Vedi anche

• File
• Attributes
• FileSystemWatcher
• Directory
• Path
• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file
• Procedura: Leggere e scrivere su un file di dati appena creato