eliminar - obtener nombre archivo sin extension c#

Ignorar carpetas/archivos cuando se deniega el acceso a Directory.GetFiles()

Question

Estoy tratando de mostrar una lista de todos los archivos encontrados en el directorio seleccionado (y opcionalmente cualquier subdirectorio). El problema que tengo es que cuando el método GetFiles () se encuentra con una carpeta a la que no puede acceder, arroja una excepción y el proceso se detiene.

¿Cómo ignoro esta excepción (e ignoro la carpeta / archivo protegido) y continúo agregando archivos accesibles a la lista?

try
{
if (cbSubFolders.Checked == false)
{
string[] files = Directory.GetFiles(folderBrowserDialog1.SelectedPath);
foreach (string fileName in files)
ProcessFile(fileName);
}
else
{
string[] files = Directory.GetFiles(folderBrowserDialog1.SelectedPath, "*.*", SearchOption.AllDirectories);
foreach (string fileName in files)
ProcessFile(fileName);
}
lblNumberOfFilesDisplay.Enabled = true;
}
catch (UnauthorizedAccessException) { }
finally {}

Answer 1

Aquí hay una implementación compatible con .NET 2.0 con todas las funciones.

¡Incluso puede alterar la List de archivos cedida para omitir directorios en la versión de FileSystemInfo !

(¡Cuidado con null valores null !)

public static IEnumerable<KeyValuePair<string, string[]>> GetFileSystemInfosRecursive(string dir, bool depth_first)
{
foreach (var item in GetFileSystemObjectsRecursive(new DirectoryInfo(dir), depth_first))
{
string[] result;
var children = item.Value;
if (children != null)
{
result = new string[children.Count];
for (int i = 0; i < result.Length; i++)
{ result[i] = children[i].Name; }
}
else { result = null; }
string fullname;
try { fullname = item.Key.FullName; }
catch (IOException) { fullname = null; }
catch (UnauthorizedAccessException) { fullname = null; }
yield return new KeyValuePair<string, string[]>(fullname, result);
}
}
public static IEnumerable<KeyValuePair<DirectoryInfo, List<FileSystemInfo>>> GetFileSystemInfosRecursive(DirectoryInfo dir, bool depth_first)
{
var stack = depth_first ? new Stack<DirectoryInfo>() : null;
var queue = depth_first ? null : new Queue<DirectoryInfo>();
if (depth_first) { stack.Push(dir); }
else { queue.Enqueue(dir); }
for (var list = new List<FileSystemInfo>(); (depth_first ? stack.Count : queue.Count) > 0; list.Clear())
{
dir = depth_first ? stack.Pop() : queue.Dequeue();
FileSystemInfo[] children;
try { children = dir.GetFileSystemInfos(); }
catch (UnauthorizedAccessException) { children = null; }
catch (IOException) { children = null; }
if (children != null) { list.AddRange(children); }
yield return new KeyValuePair<DirectoryInfo, List<FileSystemInfo>>(dir, children != null ? list : null);
if (depth_first) { list.Reverse(); }
foreach (var child in list)
{
var asdir = child as DirectoryInfo;
if (asdir != null)
{
if (depth_first) { stack.Push(asdir); }
else { queue.Enqueue(asdir); }
}
}
}
}

Answer 2

Esta simple función funciona bien y cumple con los requisitos de las preguntas.

private List<string> GetFiles(string path, string pattern)
{
var files = new List<string>();
try
{
files.AddRange(Directory.GetFiles(path, pattern, SearchOption.TopDirectoryOnly));
foreach (var directory in Directory.GetDirectories(path))
files.AddRange(GetFiles(directory, pattern));
}
catch (UnauthorizedAccessException) { }
return files;
}

Answer 3

Esto debería responder la pregunta. He ignorado el problema de ir a través de subdirectorios, supongo que lo has descubierto.

Por supuesto, no necesita tener un método separado para esto, pero puede encontrarlo como un lugar útil para verificar que la ruta sea válida y para tratar con las otras excepciones que pueda encontrar al llamar a GetFiles ().

Espero que esto ayude.

private string[] GetFiles(string path)
{
string[] files = null;
try
{
files = Directory.GetFiles(path);
}
catch (UnauthorizedAccessException)
{
// might be nice to log this, or something ...
}
return files;
}
private void Processor(string path, bool recursive)
{
// leaving the recursive directory navigation out.
string[] files = this.GetFiles(path);
if (null != files)
{
foreach (string file in files)
{
this.Process(file);
}
}
else
{
// again, might want to do something when you can''t access the path?
}
}

Answer 4

Sé que esta pregunta es un poco antigua, pero tuve el mismo problema hoy y encontré el siguiente artículo que explica en detalle una solución de "recursión de carpetas".

El artículo reconoce los defectos del método GetDirectories() ...

Desafortunadamente, esto [ usando el método GetDirectories () ] tiene problemas. La clave entre estas es que algunas de las carpetas que intenta leer podrían configurarse para que el usuario actual no pueda acceder a ellas. En lugar de ignorar las carpetas a las que tiene acceso restringido, el método genera una excepción de acceso no autorizada. Sin embargo, podemos eludir este problema creando nuestro propio código de búsqueda de carpeta recursiva.

... y luego presenta la solución en detalle:

http://www.blackwasp.co.uk/FolderRecursion.aspx

Answer 5

También verifique, Cómo: Iterar a través de un árbol de directorios .

Answer 6

Tendrá que hacer la recursión manualmente; no use AllDirectories: busque una carpeta a la vez y luego intente obtener los archivos de los subdirectores. No probado, pero algo como a continuación (nota utiliza un delegado en lugar de construir una matriz):

using System;
using System.IO;
static class Program
{
static void Main()
{
string path = ""; // TODO
ApplyAllFiles(path, ProcessFile);
}
static void ProcessFile(string path) {/* ... */}
static void ApplyAllFiles(string folder, Action<string> fileAction)
{
foreach (string file in Directory.GetFiles(folder))
{
fileAction(file);
}
foreach (string subDir in Directory.GetDirectories(folder))
{
try
{
ApplyAllFiles(subDir, fileAction);
}
catch
{
// swallow, log, whatever
}
}
}
}

Answer 7

Una forma simple de hacerlo es usando una Lista para archivos y una Cola para directorios. Conserva memoria. Si utiliza un programa recursivo para hacer la misma tarea, eso podría arrojar la excepción OutOfMemory. El resultado: los archivos agregados en la Lista están organizados de acuerdo con el árbol de directorios de arriba hacia abajo (ancho primero).

public static List<string> GetAllFilesFromFolder(string root, bool searchSubfolders) {
Queue<string> folders = new Queue<string>();
List<string> files = new List<string>();
folders.Enqueue(root);
while (folders.Count != 0) {
string currentFolder = folders.Dequeue();
try {
string[] filesInCurrent = System.IO.Directory.GetFiles(currentFolder, "*.*", System.IO.SearchOption.TopDirectoryOnly);
files.AddRange(filesInCurrent);
}
catch {
// Do Nothing
}
try {
if (searchSubfolders) {
string[] foldersInCurrent = System.IO.Directory.GetDirectories(currentFolder, "*.*", System.IO.SearchOption.TopDirectoryOnly);
foreach (string _current in foldersInCurrent) {
folders.Enqueue(_current);
}
}
}
catch {
// Do Nothing
}
}
return files;
}

Pasos:

1. Enqueue la raíz en la cola
2. En un bucle, Dequeue it, Agregue los archivos en ese directorio a la lista y Agregue las subcarpetas a la cola.
3. Repita hasta que la cola esté vacía.

Answer 8

consulte https://.com/a/10728792/89584 para obtener una solución que maneje el problema UnauthorisedAccessException.

Todas las soluciones anteriores perderán archivos y / o directorios si hay llamadas a GetFiles () o GetDirectories () en carpetas con una combinación de permisos.