C# - Procurando arquivos e/ou diretórios

 Hoje vamos recordar como localizar um arquivo ou diretório pelo nome usando a linguagem C#.

Existem muitas maneiras de implementar a localização de arquivos e diretórios na linguagem C# e neste artigo eu vou mostrar uma abordagem onde vamos usar o objeto DirectoryInfo que contém diversos métodos que nos ajudam nesta tarefa.

A classe DirectoryInfo expõe métodos de instância para criar, mover e enumerar em diretórios e subdiretórios. Essa classe não pode ser herdada é uma classe sealed.

Cabe ressaltar o alerta da documentação que avisa  que : "Se você pretende reutilizar um objeto várias vezes, considere usar o método de instância do DirectoryInfo em vez dos métodos estáticos correspondentes da Directory classe, pois uma verificação de segurança nem sempre será necessária."

A seguir veremos um exemplo prático que pesquisa uma árvore de diretório para qualquer arquivo ou diretório que corresponde ao padrão de entrada.

recursos usados:

Criando o projeto no VS 2019 Community

Abra o VS 2019 e crie um novo projeto do tipo Console (.NET Core) chamado LocalizaArquivos:

A seguir crie uma classe no projeto chamada Localizador ou outro nome que você achar mais conveniente, e,  inclua o código abaixo nesta classe:

using System;
using System.IO;
namespace LocalizaArquivos
{
    public class Localizador
    {
        public static void ProcurarPor(string _diretorioInicial, string _criterioBusca, bool _somenteDiretorio)
        {
            DirectoryInfo di = new DirectoryInfo(_diretorioInicial);
            DirectoryInfo[] diretorios = di.GetDirectories(_criterioBusca, SearchOption.AllDirectories);
            int numResultados = diretorios.Length;
            ExibirResultadoPesquisa(diretorios);
            if (!_somenteDiretorio)
            {
                FileInfo[] arquivos = di.GetFiles(_criterioBusca, SearchOption.AllDirectories);
                ExibirResultadoPesquisa(arquivos);
                numResultados += arquivos.Length;
            }
            Console.WriteLine($"{ numResultados} resultados encontrados ");
        }

        private static void ExibirResultadoPesquisa(DirectoryInfo[] diretorios)
        {
            foreach (DirectoryInfo dir in diretorios)
            {
                Console.WriteLine($"{ dir.Name}\t{ dir.Parent}\t{ "D"}");
            }
        }

        private static void ExibirResultadoPesquisa(FileInfo[] arquivos)
        {
            foreach (FileInfo arq in arquivos)
            {
                Console.WriteLine($"{ arq.Name}\t{ arq.DirectoryName}\t{ "F"}");
            }
        }
    }
}

Na classe Localizador criamos o método estático:

Onde estamos passando os parâmetros informando o diretório inicial, o critério e se vamos procurar arquivos ou diretórios

A seguir criamos duas sobrecargas para o método ExibirResultadoPesquisa :

Onde o primeira exibe os diretórios e o segundo exibe os arquivos encontrados.

No método Main da classe Program incluímos o código a seguir para usar esta classe realizando uma validação bem simples da entrada do usuário apenas para mostrar o seu funcionamento:

using System;
namespace LocalizaArquivos
{
    class Program
    {
        static bool _somenteDiretorio = false;
        static string _diretorioInicial;
        static string _criterioBusca;
        static void Main(string[] args)
        {
            Console.WriteLine("###########  Procurando arquivos ou diretórios ################\n");

            Console.WriteLine("Informe o nome do diretório de início (Ex: c:\\dados) ");
            _diretorioInicial = Console.ReadLine();
            Console.WriteLine("Informe o critério de busca (Ex: *.txt");
            _criterioBusca = Console.ReadLine();
            Console.WriteLine("Informe true para buscar diretórios e false para buscar arquivos");
            var valor = Console.ReadLine();

            if (valor.Equals("true") || valor.Equals("false"))
            {
                _somenteDiretorio = Convert.ToBoolean(valor);
            }
            else
            {
                 _somenteDiretorio = false;
            }
            var resultado = _somenteDiretorio ? "(somente diretórios)" : "(arquivos)";
            Console.WriteLine($"Procurando em : { _diretorioInicial} por : { resultado } criterio: { _criterioBusca} ");
            Console.WriteLine("Tecle algo para iniciar...\n\n");
            Console.ReadLine();
            Localizador.ProcurarPor(_diretorioInicial,_criterioBusca, _somenteDiretorio);
            Console.ReadLine();
        }
    }
}

Executando o projeto teremos o resultado abaixo :

Se você quiser tratar os argumentos de entrada no método Main  a partir da linha de comando para exibir ao usuário como usar o método para localizar arquivos ou diretórios pode usar o seguinte código:

  static void Main(string[] args)
  {
      if (!TrataArgumentos(args))
      {
           ExibirUtilizacao();
           return;
      }
        ....
        ...
       static void ExibirUtilizacao()
       {
            Console.WriteLine("Uso: ProcurarPor[-diretório] CriterioDeBusca DiretorioInicial");
            Console.WriteLine("Ex: Localizador.ProcurarPor -directory code C:\\Projetos");
            Console.WriteLine("*coringas podem ser usados");
        }
        static bool TrataArgumentos(string[] args)
        {
            if (args.Length < 2)
            {
                return false;
            }
            if (string.Compare(args[0], "-directory") == 0)
            {
                _somenteDiretorio = true;
                if (args.Length < 3)
                    return false;
            }
            _diretorioInicial = args[args.Length - 1];
            _criterioBusca = args[args.Length - 2];
            return true;
        }
    }

Pegue o projeto completo aqui: LocalizaArquivos.zip

"Quão grandes são, Senhor, as tuas obras! Mui profundos são os teus pensamentos."
Salmos 92:5

Referências:

José Carlos Macoratti