Directory-Klasse
Macht statische Methoden zum Erstellen, Verschieben und Auflisten in Verzeichnissen und Unterverzeichnissen verfügbar. Diese Klasse kann nicht geerbt werden.
Namespace: System.IO
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
<ComVisibleAttribute(True)> _
Public NotInheritable Class Directory
'Usage
Auf die Member einer statischen Klassen wird direkt ohne Instanz der Klasse zugegriffen.
[ComVisibleAttribute(true)]
public static class Directory
[ComVisibleAttribute(true)]
public ref class Directory abstract sealed
/** @attribute ComVisibleAttribute(true) */
public final class Directory
ComVisibleAttribute(true)
public final class Directory
Hinweise
Verwenden Sie die Directory-Klasse für typische Operationen, z. B. das Kopieren, Verschieben, Umbenennen, Erstellen und Löschen von Dateien. Sie können mithilfe der Directory-Klasse auch DateTime-Informationen in Bezug auf den Dateizugriff, die Dateierstellung sowie das Schreiben in Verzeichnisse abrufen und festlegen.
Da alle Directory-Methoden statisch sind, kann die Verwendung einer Directory-Methode effektiver als die Verwendung einer entsprechenden DirectoryInfo-Instanzmethode sein, wenn nur eine Aktion ausgeführt werden soll. Für die meisten Directory-Methoden ist der Pfad zum bearbeiteten Verzeichnis erforderlich.
Die statischen Methoden der Directory-Klasse führen Sicherheitsüberprüfungen für alle Methoden durch. Wenn Sie ein Objekt mehrmals wiederverwenden, verwenden Sie stattdessen die entsprechende Instanzmethode von DirectoryInfo, da die Sicherheitsüberprüfung nicht immer erforderlich ist.
Hinweis
Bei Membern, die einen Pfad als Eingabezeichenfolge akzeptieren, muss dieser Pfad wohlgeformt sein. Andernfalls wird eine Ausnahme ausgelöst. Wenn beispielsweise ein Pfad vollqualifiziert ist, aber mit einem Leerzeichen beginnt, wird der Pfad in Methoden der Klasse nicht gekürzt. Daher ist der Pad falsch formatiert, und es wird eine Ausnahme ausgelöst. Ebenso kann ein Pfad oder eine Kombination von Pfaden nicht zweimal vollqualifiziert werden. Auch "c:\temp c:\windows" löst beispielsweise in den meisten Fällen eine Ausnahme aus. Bei der Verwendung von Methoden, die eine Pfadzeichenfolge akzeptieren, müssen Sie sicherstellen, dass die Pfade wohlgeformt sind.
Bei Membern, die einen Pfad akzeptieren, kann der Pfad auf eine Datei oder nur auf ein Verzeichnis verweisen. Der angegebene Pfad kann auch auf einen relativen Pfad oder auf einen UNC-Pfad (Universal Naming Convention) für einen Server- und Freigabenamen verweisen. Beispielsweise sind alle folgenden Pfade zulässig:
"c:\\MyDir" in C# oder "c:\MyDir" in Visual Basic.
"MyDir\\MySubdir" in C# oder "MyDir\MySubDir" in Visual Basic.
"\\\\MyServer\\MyShare" in C# oder "\\MyServer\MyShare" in Visual Basic.
Standardmäßig wird allen Benutzern voller Lese- und Schreibzugriff für alle neuen Verzeichnisse gewährt. Das Anfordern einer Berechtigung für ein Verzeichnis, dessen Pfadzeichenfolge mit dem Verzeichnistrennzeichen endet, führt dazu, dass Berechtigungen für alle darin enthaltenen Unterverzeichnisse angefordert werden (beispielsweise "C:\Temp\"). Wenn die Berechtigungen nur für ein bestimmtes Verzeichnis erforderlich sind, muss die Zeichenfolge mit dem Zeichen "." enden (beispielsweise "C:\Temp\.").
In der folgenden Tabelle sind Beispiele für andere typische oder verwandte E/A-Aufgaben aufgeführt.
Aufgabe |
Beispiel in diesem Thema |
|---|---|
Erstellen einer Textdatei. |
|
Schreiben in eine Textdatei. |
|
Lesen aus einer Textdatei. |
|
Umbenennen oder Verschieben eines Verzeichnisses. |
|
Löschen eines Verzeichnisses. |
|
Erstellen eines Verzeichnisses. |
|
Erstellen eines Unterverzeichnisses. |
|
Anzeigen der Dateien in einem Verzeichnis. |
|
Anzeigen der Unterverzeichnisse in einem Verzeichnis. |
|
Anzeigen aller Dateien in allen Unterverzeichnissen eines Verzeichnisses. |
|
Ermitteln der Größe eines Verzeichnisses. |
Directory |
Bestimmen, ob eine Datei vorhanden ist. |
|
Sortieren von Dateien in einem Verzeichnis nach Größe. |
GetFileSystemInfos |
Bestimmen, ob ein Verzeichnis vorhanden ist. |
Beispiel
Im folgenden Codebeispiel wird bestimmt, ob ein angegebenes Verzeichnis vorhanden ist. Wenn das Verzeichnis vorhanden ist, wird es gelöscht. Wenn das Verzeichnis nicht vorhanden ist, wird es erstellt. Anschließend wird das Verzeichnis verschoben, im Verzeichnis wird eine Datei erstellt, und die Dateien im Verzeichnis werden gezählt.
Imports System
Imports System.IO
Public Class Test
Public Shared Sub Main()
'Specify the directories you want to manipulate.
Dim path As String = "c:\MyDir"
Dim target As String = "c:\TestDir"
Try
' Determine whethers the directory exists.
If Directory.Exists(path) = False Then
' Create the directory.
Directory.CreateDirectory(path)
End If
If Directory.Exists(target) Then
' Delete the target to ensure it is not there.
Directory.Delete(target, True)
End If
' Move the directory.
Directory.Move(path, target)
'Create a file in the directory.
File.CreateText(target + "\myfile.txt")
'Count the files in the target.
Console.WriteLine("The number of files in {0} is {1}", _
target, Directory.GetFiles(target).Length)
Catch e As Exception
Console.WriteLine("The process failed: {0}", e.ToString())
End Try
End Sub
End Class
using System;
using System.IO;
class Test
{
public static void Main()
{
// Specify the directories you want to manipulate.
string path = @"c:\MyDir";
string target = @"c:\TestDir";
try
{
// Determine whether the directory exists.
if (!Directory.Exists(path))
{
// Create the directory it does not exist.
Directory.CreateDirectory(path);
}
if (Directory.Exists(target))
{
// Delete the target to ensure it is not there.
Directory.Delete(target, true);
}
// Move the directory.
Directory.Move(path, target);
// Create a file in the directory.
File.CreateText(target + @"\myfile.txt");
// Count the files in the target directory.
Console.WriteLine("The number of files in {0} is {1}",
target, Directory.GetFiles(target).Length);
}
catch (Exception e)
{
Console.WriteLine("The process failed: {0}", e.ToString());
}
finally {}
}
}
using namespace System;
using namespace System::IO;
int main()
{
// Specify the directories you want to manipulate.
String^ path = "c:\\MyDir";
String^ target = "c:\\TestDir";
try
{
// Determine whether the directory exists.
if ( !Directory::Exists( path ) )
{
// Create the directory it does not exist.
Directory::CreateDirectory( path );
}
if ( Directory::Exists( target ) )
{
// Delete the target to ensure it is not there.
Directory::Delete( target, true );
}
// Move the directory.
Directory::Move( path, target );
// Create a file in the directory.
File::CreateText( String::Concat( target, "\\myfile.txt" ) );
// Count the files in the target directory.
Console::WriteLine( "The number of files in {0} is {1}", target, Directory::GetFiles( target )->Length );
}
catch ( Exception^ e )
{
Console::WriteLine( "The process failed: {0}", e );
}
}
import System.*;
import System.IO.*;
class Test
{
public static void main(String[] args)
{
// Specify the directories you want to manipulate.
String path = "c:\\MyDir";
String target = "c:\\TestDir";
try {
// Determine whether the directory exists.
if (!(Directory.Exists(path))) {
// Create the directory it does not exist.
Directory.CreateDirectory(path);
}
if (Directory.Exists(target)) {
// Delete the target to ensure it is not there.
Directory.Delete(target, true);
}
// Move the directory.
Directory.Move(path, target);
// Create a file in the directory.
File.CreateText(target + "\\myfile.txt");
// Count the files in the target directory.
Console.WriteLine("The number of files in {0} is {1}", target,
(Int32)Directory.GetFiles(target).length);
}
catch (System.Exception e) {
Console.WriteLine("The process failed: {0}", e.ToString());
}
finally {
}
} //main
} //Test
Im folgenden Codebeispiel wird veranschaulicht, wie die Größe eines Verzeichnisses berechnet wird.
' The following example calculates the size of a directory
' and its subdirectories, if any, and displays the total size
' in bytes.
Imports System
Imports System.IO
Imports Microsoft.VisualBasic
Public Class ShowDirSize
Public Shared Function DirSize(ByVal d As DirectoryInfo) As Long
Dim Size As Long = 0
' Add file sizes.
Dim fis As FileInfo() = d.GetFiles()
Dim fi As FileInfo
For Each fi In fis
Size += fi.Length
Next fi
' Add subdirectory sizes.
Dim dis As DirectoryInfo() = d.GetDirectories()
Dim di As DirectoryInfo
For Each di In dis
Size += DirSize(di)
Next di
Return Size
End Function 'DirSize
Public Overloads Shared Sub Main(ByVal args() As String)
If args.Length <> 1 Then
Console.WriteLine("You must provide a directory argument at the command line.")
Else
Dim d As New DirectoryInfo(args(0))
Console.WriteLine("The size of {0} and its subdirectories is {1} bytes.", d, DirSize(d))
End If
End Sub 'Main
End Class 'ShowDirSize
// The following example calculates the size of a directory
// and its subdirectories, if any, and displays the total size
// in bytes.
using System;
using System.IO;
public class ShowDirSize
{
public static long DirSize(DirectoryInfo d)
{
long Size = 0;
// Add file sizes.
FileInfo[] fis = d.GetFiles();
foreach (FileInfo fi in fis)
{
Size += fi.Length;
}
// Add subdirectory sizes.
DirectoryInfo[] dis = d.GetDirectories();
foreach (DirectoryInfo di in dis)
{
Size += DirSize(di);
}
return(Size);
}
public static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("You must provide a directory argument at the command line.");
}
else
{
DirectoryInfo d = new DirectoryInfo(args[0]);
Console.WriteLine("The size of {0} and its subdirectories is {1} bytes.", d, DirSize(d));
}
}
}
// The following example calculates the size of a directory
// and its subdirectories, if any, and displays the total size
// in bytes.
using namespace System;
using namespace System::IO;
long DirSize( DirectoryInfo^ d )
{
long Size = 0;
// Add file sizes.
array<FileInfo^>^fis = d->GetFiles();
System::Collections::IEnumerator^ myEnum = fis->GetEnumerator();
while ( myEnum->MoveNext() )
{
FileInfo^ fi = safe_cast<FileInfo^>(myEnum->Current);
Size += (long)fi->Length;
}
array<DirectoryInfo^>^dis = d->GetDirectories();
while ( myEnum->MoveNext() )
{
DirectoryInfo^ di = safe_cast<DirectoryInfo^>(myEnum->Current);
Size += DirSize( di );
}
return Size;
}
int main()
{
array<String^>^args = Environment::GetCommandLineArgs();
if ( args->Length != 2 )
{
Console::WriteLine( "You must provide a directory argument at the command line." );
}
else
{
DirectoryInfo^ d = gcnew DirectoryInfo( args[ 1 ] );
Console::WriteLine( "The size of {0} and its subdirectories is {1} bytes.", d, DirSize( d ) );
}
}
Vererbungshierarchie
System.Object
System.IO.Directory
Threadsicherheit
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0
Siehe auch
Referenz
Directory-Member
System.IO-Namespace
File
DirectoryInfo
FileInfo
Weitere Ressourcen
Datei- und Stream-E/A
Gewusst wie: Lesen aus einer Textdatei
Gewusst wie: Schreiben von Text in eine Datei
Grundlegende Datei-E/A
Gewusst wie: Lesen und Schreiben einer neu erstellten Datendatei