.NET Framework
Clase System.IO.File

Sintaxis

• fuente de cadena
• cadena de destino;

Parámetros

Borrar un archivo

Eliminar un archivo (si tiene permisos requeridos) es tan simple como:

File.Delete(path);

Sin embargo, muchas cosas pueden ir mal:

• No tiene los permisos necesarios (se UnauthorizedAccessException ).
• El archivo puede estar en uso por otra persona (se produce una IOException ).
• El archivo no se puede eliminar debido a un error de bajo nivel o los medios son de solo lectura (se produce una IOException ).
• El archivo ya no existe (se lanza IOException ).

Tenga en cuenta que el último punto (el archivo no existe) generalmente se evita con un fragmento de código como este:

if (File.Exists(path))
    File.Delete(path);

Sin embargo, no es una operación atómica y el archivo puede ser eliminado por otra persona entre la llamada a File.Exists() y antes de File.Delete() . El enfoque correcto para manejar la operación de E / S requiere un manejo de excepciones (asumiendo que se puede tomar un curso alternativo de acciones cuando falla la operación):

if (File.Exists(path))
{
    try
    {
        File.Delete(path);
    }
    catch (IOException exception)
    {
        if (!File.Exists(path))
            return; // Someone else deleted this file

        // Something went wrong...
    }
    catch (UnauthorizedAccessException exception)
    {
        // I do not have required permissions
    }
}

Tenga en cuenta que estos errores de E / S a veces son transitorios (archivo en uso, por ejemplo) y si se trata de una conexión de red, puede recuperarse automáticamente sin ninguna acción por nuestra parte. Entonces es común volver a intentar una operación de E / S varias veces con un pequeño retraso entre cada intento:

public static void Delete(string path)
{
    if (!File.Exists(path))
        return;

    for (int i=1; ; ++i)
    {
        try
        {
            File.Delete(path);
            return;
        }
        catch (IOException e)
        {
            if (!File.Exists(path))
                return;

            if (i == NumberOfAttempts)
                throw;

            Thread.Sleep(DelayBetweenEachAttempt);
        }

        // You may handle UnauthorizedAccessException but this issue
        // will probably won't be fixed in few seconds...
    }
}

private const int NumberOfAttempts = 3;
private const int DelayBetweenEachAttempt = 1000; // ms

Nota: en el entorno de Windows, el archivo no se eliminará realmente cuando llame a esta función, si alguien más abre el archivo con FileShare.Delete , el archivo se puede eliminar, pero solo ocurrirá cuando el propietario cierre el archivo.

Eliminar líneas no deseadas de un archivo de texto

Cambiar un archivo de texto no es fácil porque su contenido debe moverse. Para los archivos pequeños , el método más sencillo es leer su contenido en la memoria y luego volver a escribir el texto modificado.

En este ejemplo leemos todas las líneas de un archivo y soltamos todas las líneas en blanco, luego escribimos de nuevo en la ruta original:

File.WriteAllLines(path,
    File.ReadAllLines(path).Where(x => !String.IsNullOrWhiteSpace(x)));

Si el archivo es demasiado grande para cargarlo en la memoria y la ruta de salida es diferente de la ruta de entrada:

File.WriteAllLines(outputPath,
    File.ReadLines(inputPath).Where(x => !String.IsNullOrWhiteSpace(x)));

Convertir codificación de archivos de texto

El texto se guarda codificado (consulte también el tema Cadenas ). A veces, es posible que deba cambiar su codificación. En este ejemplo se supone (para simplificar) que el archivo no es demasiado grande y se puede leer por completo en la memoria:

public static void ConvertEncoding(string path, Encoding from, Encoding to)
{
    File.WriteAllText(path, File.ReadAllText(path, from), to);
}

Al realizar conversiones, no olvide que el archivo puede contener BOM (Byte Order Mark), para comprender mejor cómo se gestiona, consulte Encoding.UTF8.GetString no tiene en cuenta el Preámbulo / BOM .

"Toque" una gran cantidad de archivos (para actualizar el último tiempo de escritura)

Este ejemplo actualiza el último tiempo de escritura de una gran cantidad de archivos (usando System.IO.Directory.EnumerateFiles lugar de System.IO.Directory.GetFiles() ). Opcionalmente, puede especificar un patrón de búsqueda (el valor predeterminado es "*.*" Y, finalmente, buscar en un árbol de directorios (no solo el directorio especificado):

public static void Touch(string path,
                         string searchPattern = "*.*",
                         SearchOptions options = SearchOptions.None)
{
    var now = DateTime.Now;

    foreach (var filePath in Directory.EnumerateFiles(path, searchPattern, options))
    {
        File.SetLastWriteTime(filePath, now);
    }
}

Enumerar archivos anteriores a una cantidad especificada

Este fragmento de código es una función auxiliar para enumerar todos los archivos anteriores a una edad especificada, es útil, por ejemplo, cuando tiene que eliminar archivos de registro antiguos o datos en caché antiguos.

static IEnumerable<string> EnumerateAllFilesOlderThan(
                               TimeSpan maximumAge,
                               string path,
                               string searchPattern = "*.*",
                               SearchOption options = SearchOption.TopDirectoryOnly)
{
    DateTime oldestWriteTime = DateTime.Now - maximumAge;

    return Directory.EnumerateFiles(path, searchPattern, options)
        .Where(x => Directory.GetLastWriteTime(x) < oldestWriteTime);
}

Utilizado de esta manera:

var oldFiles = EnumerateAllFilesOlderThan(TimeSpan.FromDays(7), @"c:\log", "*.log");

Algunas cosas a tener en cuenta:

• La búsqueda se realiza utilizando Directory.EnumerateFiles() lugar de Directory.GetFiles() . La enumeración está activa , por lo que no tendrá que esperar hasta que se hayan recuperado todas las entradas del sistema de archivos.
• Estamos comprobando el último tiempo de escritura, pero puede usar el tiempo de creación o el último tiempo de acceso (por ejemplo, para eliminar los archivos en caché no utilizados , tenga en cuenta que el tiempo de acceso puede estar deshabilitado).
• La granularidad no es uniforme para todas esas propiedades (tiempo de escritura, tiempo de acceso, tiempo de creación), consulte MSDN para obtener detalles sobre esto.

Mueve un archivo de una ubicación a otra

Archivo.Mover

File.Move(@"C:\TemporaryFile.txt", @"C:\TemporaryFiles\TemporaryFile.txt");

Sin embargo, hay muchas cosas que podrían salir mal con esta simple operación. Por ejemplo, ¿qué sucede si el usuario que ejecuta su programa no tiene una unidad que tiene la etiqueta 'C'? ¿Qué pasaría si lo hicieran, pero decidieron cambiarle el nombre a 'B' o 'M'?

¿Qué sucede si el archivo de origen (el archivo en el que desea mover) se ha movido sin que usted lo sepa, o si simplemente no existe?

Esto puede evitarse comprobando primero si el archivo fuente existe:

string source = @"C:\TemporaryFile.txt", destination = @"C:\TemporaryFiles\TemporaryFile.txt";
if(File.Exists("C:\TemporaryFile.txt"))
{
    File.Move(source, destination);
}

Esto asegurará que, en ese mismo momento, el archivo exista y se pueda mover a otra ubicación. Puede haber ocasiones en que una simple llamada a File.Exists no sea suficiente. Si no es así, verifique nuevamente, transmita al usuario que la operación falló, o maneje la excepción.

Una FileNotFoundException no es la única excepción que es probable que encuentre.

Vea abajo para posibles excepciones: