Esta documentación está archivada y no tiene mantenimiento.

Directory (Clase)

Actualización: noviembre 2007

Expone métodos estáticos para crear, mover y enumerar archivos en directorios y subdirectorios. Esta clase no se puede heredar.

Espacio de nombres:  System.IO
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(true)]
public static class Directory
/** @attribute ComVisibleAttribute(true) */
public final class Directory
public final class Directory

Utilice la clase Directory para operaciones típicas como copiar, mover, cambiar de nombre, crear y eliminar directorios. También puede utilizar la clase Directory para obtener y establecer información de DateTime relacionada con la creación, el acceso y la escritura de un directorio.

Dado que todos los métodos de Directory son estáticos, puede resultar más eficaz utilizar un método de Directory en lugar del correspondiente método de instancia de DirectoryInfo si se desea realizar sólo una operación. La mayoría de los métodos Directory requieren la ruta de acceso al directorio que está manipulando.

Los métodos estáticos de la clase Directory realizan comprobaciones de seguridad en todos los métodos. Si va a utilizar un objeto varias veces, considere la posibilidad de usar el correspondiente método de instancia de DirectoryInfo, ya que no siempre es necesario realizar una comprobación de seguridad.

wa70yfe2.alert_note(es-es,VS.90).gifNota:

En miembros que aceptan una vía de acceso como una cadena de entrada, esa vía de acceso debe estar bien construida o se produce una excepción; sin embargo, si una vía de acceso está completa pero comienza con un espacio, no se omite el espacio pero no se produce ninguna excepción. De forma similar, una combinación de rutas de acceso no puede completarse dos veces. Por ejemplo, "c:\temp c:\windows" produce también una excepción en la mayoría de los casos. Asegúrese de que las rutas de acceso estén bien construidas cuando utilice métodos que acepten una cadena de ruta de acceso.

En los miembros que aceptan una ruta de acceso, esta ruta puede hacer referencia a un archivo o sólo a un directorio. La ruta especificada puede hacer referencia también a una ruta relativa o a una ruta de convención de nomenclatura universal (Universal Naming Convention, UNC) de un servidor y un nombre de recurso compartido. Por ejemplo, las siguientes rutas de acceso son todas válidas:

  • "c:\\MiDir" en C# o "c:\MiDir" en Visual Basic.

  • "MiDir\\MiSubdir" en C# o "MiDir\MiSubDir" en Visual Basic.

  • "\\\\MiServidor\\MiRecursoComp" en C# o "\\MiServidor\MiRecursoComp" en Visual Basic.

De forma predeterminada, se otorga acceso completo de lectura y escritura a los nuevos directorios a todos los usuarios. Cuando se solicitan permisos para un directorio y la cadena de ruta de acceso finaliza con el carácter de separación de directorios, se solicitan los permisos de todos los subdirectorios que contiene (por ejemplo, "C:\Temp\"). Si sólo se requieren permisos para un directorio concreto, la cadena debería finalizar con un carácter "." (por ejemplo, "C:\Temp\.").

Para obtener una lista de tareas de E/S comunes, vea Tareas de E/S comunes.

En el siguiente ejemplo de código se determina si un directorio especificado existe y, si es así, se elimina o, si no, se crea. A continuación, se mueve el directorio, se crea un archivo en él y se cuentan los archivos que contiene.

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 {}
    }
}


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


En el ejemplo de código siguiente se muestra cómo calcular el tamaño de un directorio.

// 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));
        }
    }
}


Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile para Smartphone, Windows Mobile para Pocket PC, Xbox 360

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 3.5, 2.0, 1.0

XNA Framework

Compatible con: 2.0, 1.0
Mostrar: