C# e .NET Core - Tratando o sistema de arquivos


Neste artigo veremos como gerenciar o sistema de arquivos no .NET Core usando a linguagem C#.

No .NET Core quando você está lendo e escrevendo em arquivos e diretórios, é possível usar APIs simples ou usar
APIs avançadas que oferecem mais recursos.

Você também tem que diferenciar entre classes da plataforma .NET e a funcionalidade oferecida a partir do runtime do Windows.

Nota: A partir dos aplicativos da Universal Windows Plataform (UWP), você não tem acesso ao sistema de arquivos em nenhum diretório; você tem acesso apenas a diretórios específicos.

As classes usadas para navegar pelo sistema de arquivos e realizar operações como mover, copiar e deletar arquivos são mostradas na figura abaixo:

Onde temos que:

Note que existem duas classes usadas para trabalhar com pastas e duas classes para trabalhar com arquivos. Qual delas você vai usar vai depender em quantas operações você vai precisar acessar na pasta ou no arquivo.

As classes Directory e File contém somente métodos estáticos e nunca são instânciadas. Você usa essas classes fornecendo o caminho para o objeto do sistema de arquivos sempre que você chamar um método do membro. Se você deseja fazer apenas uma operação em uma pasta ou arquivo essas classes são mais eficientes pois elas evitam que você crie um objeto .NET.

As classe DirectoryInfo e FileInfo implementam aproximadamente os mesmos métodos públicos que Directory e File, bem como algumas propriedades públicas e construtores, mas eles são stateful e os membros destas
classes não são estáticas. Você precisa instanciar essas classes antes que cada instância seja associada a um
determinada pasta ou arquivo. Isso significa que essas classes são mais eficientes se você estiver executando
várias operações usando o mesmo objeto.

Antes de tratar com arquivos e pastas vamos iniciar com os drives do sistema.

Verificando os drives do sistema

Você usa a classe DriveInfo, para executar uma varredura no sistema de arquivos e  fornecer uma lista de unidades disponíveis e, em seguida, pode obter informações detalhadas sobre as unidades.

No exemplo a seguir listamos as unidades do computador local obtendo informações sobre elas:

using System.IO;
using static System.Console;
namespace NetCore_FS1
{
    class Program
    {
        static void Main(string[] args)
        {
            DriveInfo[] drives = DriveInfo.GetDrives();
            foreach (DriveInfo drive in drives)
            {
                if (drive.IsReady)
                {
                    WriteLine($"Nome do Drive: {drive.Name}");
                    WriteLine($"Formato: {drive.DriveFormat}");
                    WriteLine($"Tipo: {drive.DriveType}");
                    WriteLine($"Diretório Raiz : {drive.RootDirectory}");
                    WriteLine($"Volume label: {drive.VolumeLabel}");
                    WriteLine($"Espaço Livre: {drive.TotalFreeSpace}");
                    WriteLine($"Espaço disponível: {drive.AvailableFreeSpace}");
                    WriteLine($"Tamanho Total: {drive.TotalSize}");
                    WriteLine();
                    ReadLine();
                }
            }
        }
    }
}
 
 

No código cima usamos o método estático DriveInfo.GetDrives que retorna uma matriz de objetos DriveInfo.

Com essa matriz, todas as unidades prontas são acessadas e podemos obter informações sobre o nome da unidade, tipo e formato, e também informações de tamanho.

Usando a classe Path

Para acessar arquivos e diretórios, os nomes dos arquivos e diretórios precisam ser definidos - incluindo
as pastas pai. Quando você combina várias pastas e arquivos usando operadores de concatenação de strings,
pode facilmente se esquecer de um caractere separador ou usar um número excessivo de caracteres.

A classe Path pode ajudar com isso porque essa classe adiciona caracteres separadores ausentes e lida com requesitos de diferentes plataformas em sistemas baseados em Windows e Unix.

A classe Path expõe alguns métodos estáticos que facilitam as operações em nomes de caminho. Por exemplo,
suponha que você deseja exibir o nome do caminho completo para um arquivo, teste.txt, na pasta d:\Projetos.

Você poderia encontrar o caminho para o arquivo usando o seguinte código:

Console.WriteLine(Path.Combine(@"D:\Projetos", "teste.txt"));

Path.Combine é o método dessa classe que você provavelmente usará com mais freqüência, mas o Path também implementa outros métodos que fornecem informações sobre o caminho ou o formato necessário para isso.

Usando os campos públicos VolumeSeparatorChar, DirectorySeparatorChar, AltDirectorySeparatorChar, e PathSeparator você pode obter o caractere específico da plataforma que é usado para separar unidades, pastas e arquivos e o separador de vários caminhos.

Com o Windows, esses os caracteres são: , \, / e.

using System;
using System.IO;
using static System.Console;
namespace ExPath1
{
    class Program
    {
        static void Main(string[] args)
        {
            WriteLine(" ==== Sistema Operacional Windows 10 ======");
            WriteLine();
            WriteLine($"Path.DirectorySeparatorChar: '{Path.DirectorySeparatorChar}'");
            WriteLine($"Path.AltDirectorySeparatorChar: '{Path.AltDirectorySeparatorChar}'");
            WriteLine($"Path.PathSeparator: '{Path.PathSeparator}'");
            WriteLine($"Path.VolumeSeparatorChar: '{Path.VolumeSeparatorChar}'");
            var invalidChars = Path.GetInvalidPathChars();
            WriteLine($"Path.GetInvalidPathChars:");
            for (int ctr = 0; ctr < invalidChars.Length; ctr++)
            {
                Write($"  U+{Convert.ToUInt16(invalidChars[ctr]):X4} ");
                if ((ctr + 1) % 10 == 0) Console.WriteLine();
            }
            WriteLine();
            WriteLine("---------------------------------------");
            WriteLine($"GetTempPath : {Path.GetTempPath()}");
            WriteLine($"GetTempFileName : {Path.GetTempFileName()}");
            WriteLine($"GetRandomFileName : {Path.GetRandomFileName()}");
            ReadLine();
        }
    }
}

A classe Path também ajuda a acessar a pasta temporária específica do usuário (GetTempPath) e a criar nomes temporários (GetTempFileName) e nomes de arquivos aleatórios (GetRandomFileName).

Preste atenção que o método GetTempFileName inclui a pasta, enquanto GetRandomFileName apenas retorna o nome do arquivo sem qualquer pasta.

Em outro artigo vamos tratar de arquivos e pastas.

Pegue o projeto aqui : NetCore_FS1.zip

"Quão amáveis são os teus tabernáculos, SENHOR dos Exércitos!
A minha alma está desejosa, e desfalece pelos átrios do Senhor; o meu coração e a minha carne clamam pelo Deus vivo."

Salmos 84:1-2

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:


José Carlos Macoratti