21 12 2016

O FTP é um protocolo muito antigo, porém muito utilizado até os dias de hoje. Em algumas aplicações, pode ser pode ser que precisemos acessar um servidor FTP para baixarmos um arquivo ou até mesmo para fazermos um upload de algum arquivo relacionado ao nosso aplicativo.

No .NET Framework temos à nossa disposição a classe FtpWebRequest, que implementa todas as funcionalidades necessárias para manipularmos servidores FTP com C# e VB.NET. Porém, se quisermos fazer algo que vá além do upload e download de arquivos, o código acaba ficando um tanto quanto complexo.

Para substituir o FtpWebRequest, podemos utilizar uma infinidade de bibliotecas que implementam as funcionalidades de acesso a servidores FTP no .NET. Uma dessas bibliotecas é a FluentFTP, implementada 100% com código gerenciado e muito simples de ser utilizada.

No artigo de hoje, eu vou mostrar para você como utilizar a classe FtpWebRequest para fazer o upload e download de arquivos, bem como a biblioteca FluentFTP para outras atividades mais complexas, como criação, deleção e listagem de diretórios.

Preparando o ambiente de testes

É obvio que, para testarmos as funcionalidades deste artigo, precisaremos ter acesso a um servidor FTP. Eu poderia utilizar alguns servidores FTP que eu tenho disponíveis (como o servidor onde eu hospedo este site ou o servidor da empresa), porém ambos não permitem acesso anônimo e eu não queria correr o risco de acidentalmente compartilhar o meu usuário e senha no meio dos códigos de exemplo. Por isso, resolvi configurar um outro servidor FTP local com suporte a acesso anônimo.

Não sei se você sabe (eu não sabia), mas nós podemos configurar um servidor FTP com as próprias funcionalidades do Windows. Para conseguirmos fazer isso, temos que habilitar o IIS e criarmos um novo “FTP Site“. Eu segui as instruções deste tutorial e configurei um servidor FTP local com suporte a acesso anônimo:

How to set up and manage an FTP server on Windows 10

Se mesmo assim você achar esse processo muito complicado, saiba que existem outras opções mais simples ainda. Nesta thread do SuperUser (StackOverflow de infra) o pessoal da comunidade discutiu sobre as principais opções para configurarmos um servidor FTP no Windows com o mínimo esforço possível:

Dead-simple FTP server for Windows?

Caso você já tenha um servidor FTP acessível para fazer os testes, você obviamente não precisa seguir os passos apresentados nos links acima.

O que o FtpWebRequest tem a nos oferecer?

Uma vez tendo um servidor FTP para testarmos as funcionalidades, vamos começar a criar o nosso projeto de testes. Para simplificar as coisas, vamos criar um projeto do tipo “Console Application“. A ideia dos testes é fazermos as principais operações no nosso servidor FTP: upload, download, deleção de arquivos, criação de diretórios, deleção de diretórios e listagem dos arquivos.

O próprio .NET Framework conta com uma classe que implementa a manipulação de servidores FTP. Essa classe se chama FtpWebRequest, localizada dentro do namespace System.Net. Existem dois exemplos na própria documentação do MSDN mostrando como fazer upload e download de arquivos com o FtpWebRequest. Resolvi coloca-los à prova para ver se eles realmente funcionam (e também para convertê-los para VB.NET, uma vez que eles só estão disponíveis em C# na documentação).

Para testarmos o upload de arquivo, precisamos de um arquivo de teste. Na maioria dos exemplos que você encontra por aí, os autores trabalham com arquivos texto. Eu resolvi ser diferente e vou testar a funcionalidade de upload e download utilizando um arquivo PDF, mais especificamente este aqui, que é um guia de licenciamento do Visual Studio 2015, feito pela própria Microsoft. Se o link do Microsoft Download Center não estiver funcionando, você pode baixar o PDF diretamente aqui no meu site. Coloque o arquivo PDF dentro da pasta bin/debug do projeto.

Seguindo o exemplo de upload de arquivos da documentação no MSDN, o código ficaria assim:

        // C#
        private static void Upload(string arquivo, string destino)
        {
            var request = (System.Net.FtpWebRequest)System.Net.WebRequest.Create("ftp://localhost/" + destino);
            request.Method = System.Net.WebRequestMethods.Ftp.UploadFile;
            request.Credentials = new System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br");

            using (var stream = new System.IO.StreamReader(arquivo))
            {
                var conteudoArquivo = Encoding.UTF8.GetBytes(stream.ReadToEnd());
                request.ContentLength = conteudoArquivo.Length;

                var requestStream = request.GetRequestStream();
                requestStream.Write(conteudoArquivo, 0, conteudoArquivo.Length);
                requestStream.Close();
            }

            var response = (System.Net.FtpWebResponse)request.GetResponse();
            Console.WriteLine("Upload completo. Status: {0}", response.StatusDescription);
            response.Close();
        }

    ' VB.NET
    Private Sub Upload(Arquivo As String, Destino As String)
        Dim Request = DirectCast(System.Net.WebRequest.Create(Convert.ToString("ftp://localhost/") & Destino), System.Net.FtpWebRequest)
        Request.Method = System.Net.WebRequestMethods.Ftp.UploadFile
        Request.Credentials = New System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br")

        Using Stream = New System.IO.StreamReader(Arquivo)
            Dim ConteudoArquivo = Text.Encoding.UTF8.GetBytes(Stream.ReadToEnd())
            Request.ContentLength = ConteudoArquivo.Length

            Dim RequestStream = Request.GetRequestStream()
            RequestStream.Write(ConteudoArquivo, 0, ConteudoArquivo.Length)
            RequestStream.Close()
        End Using

        Dim Response = DirectCast(Request.GetResponse(), System.Net.FtpWebResponse)
        Console.WriteLine("Upload completo. Status: {0}", Response.StatusDescription)
        Response.Close()
    End Sub

Veja que o código não é tão simples assim. A classe FtpWebRequest, como o próprio nome já diz, trabalha com Requests e Responses. Dessa forma, para fazermos o upload de um arquivo para o servidor FTP, temos que abrir um Request no endereço desejado e temos que escrever o conteúdo do arquivo em bytes na RequestStream. A chamada no método “main” ficaria assim:

        // C#
        static void Main(string[] args)
        {
            Upload("Visual Studio 2015 Licensing Whitepaper - November-2016.pdf", "arquivo.pdf");
            Console.ReadLine();
        }

    ' VB.NET
    Sub Main()
        Upload("Visual Studio 2015 Licensing Whitepaper - November-2016.pdf", "arquivo.pdf")
        Console.ReadLine()
    End Sub

Execute a aplicação e veja o resultado retornado pelo método:

Mas, será que o upload foi realmente feito com sucesso? Ao navegar até a pasta raiz do meu servidor FTP, o arquivo realmente estava lá:

Porém, ao abrir o arquivo, o seu conteúdo estava em branco:

Pesquisando um pouco sobre esse efeito, acabei encontrando esta thread no StackOverflow, que fala justamente sobre esse problema. Aquele código disponibilizado na documentação do MSDN só funciona corretamente para arquivos texto, portanto, temos que ajustá-lo para que ele funcione para qualquer tipo de arquivo. A diferença não é tão grande assim. Basicamente, a única coisa que precisamos alterar é o jeito que lemos o arquivo de origem. Ao invés de lermos o arquivo utilizando um StreamReader, nós temos que extrair diretamente os bytes do arquivo com o método ReadAllBytes:

        // C#
        private static void Upload(string arquivo, string destino)
        {
            var request = (System.Net.FtpWebRequest)System.Net.WebRequest.Create("ftp://localhost/" + destino);
            request.Method = System.Net.WebRequestMethods.Ftp.UploadFile;
            request.Credentials = new System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br");

            var conteudoArquivo = System.IO.File.ReadAllBytes(arquivo);
            request.ContentLength = conteudoArquivo.Length;

            var requestStream = request.GetRequestStream();
            requestStream.Write(conteudoArquivo, 0, conteudoArquivo.Length);
            requestStream.Close();

            var response = (System.Net.FtpWebResponse)request.GetResponse();
            Console.WriteLine("Upload completo. Status: {0}", response.StatusDescription);
            response.Close();
        }

    ' VB.NET
    Private Sub Upload(Arquivo As String, Destino As String)
        Dim Request = DirectCast(System.Net.WebRequest.Create(Convert.ToString("ftp://localhost/") & Destino), System.Net.FtpWebRequest)
        Request.Method = System.Net.WebRequestMethods.Ftp.UploadFile
        Request.Credentials = New System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br")

        Dim ConteudoArquivo = System.IO.File.ReadAllBytes(Arquivo)
        Request.ContentLength = ConteudoArquivo.Length

        Dim RequestStream = Request.GetRequestStream()
        RequestStream.Write(ConteudoArquivo, 0, ConteudoArquivo.Length)
        RequestStream.Close()

        Dim Response = DirectCast(Request.GetResponse(), System.Net.FtpWebResponse)
        Console.WriteLine("Upload completo. Status: {0}", Response.StatusDescription)
        Response.Close()
    End Sub

Agora sim. Se executarmos novamente o projeto, veremos que o PDF será gerado corretamente dentro do servidor FTP:

OK, conseguimos implementar o upload de arquivo com sucesso utilizando o FtpWebRequest. Agora vamos testar o download utilizando o código da documentação do MSDN, com a única diferença que, ao invés de mostrarmos o conteúdo do arquivo no console, nós salvaremos o arquivo com o mesmo nome no diretório da aplicação:

        // C#
        private static void Download(string caminho)
        {
            var request = (System.Net.FtpWebRequest)System.Net.WebRequest.Create("ftp://localhost/" + caminho);
            request.Method = System.Net.WebRequestMethods.Ftp.DownloadFile;

            request.Credentials = new System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br");
            var response = (System.Net.FtpWebResponse)request.GetResponse();

            var responseStream = response.GetResponseStream();
            using (var memoryStream = new System.IO.MemoryStream())
            {
                responseStream.CopyTo(memoryStream);
                var conteudoArquivo = memoryStream.ToArray();
                System.IO.File.WriteAllBytes(caminho, conteudoArquivo);
            }

            Console.WriteLine("Download Complete, status {0}", response.StatusDescription);
            response.Close();
        }

    ' VB.NET
    Private Sub Download(Caminho As String)
        Dim Request = DirectCast(System.Net.WebRequest.Create(Convert.ToString("ftp://localhost/") & Caminho), System.Net.FtpWebRequest)
        Request.Method = System.Net.WebRequestMethods.Ftp.DownloadFile

        Request.Credentials = New System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br")
        Dim Response = DirectCast(Request.GetResponse(), System.Net.FtpWebResponse)

        Dim ResponseStream = Response.GetResponseStream()
        Using MemoryStream = New System.IO.MemoryStream()
            ResponseStream.CopyTo(MemoryStream)
            Dim ConteudoArquivo = MemoryStream.ToArray()
            System.IO.File.WriteAllBytes(Caminho, ConteudoArquivo)
        End Using

        Console.WriteLine("Download Complete, status {0}", Response.StatusDescription)
        Response.Close()
    End Sub

Não podemos esquecer de adicionar a chamada no método “main“:

        // C#
        static void Main(string[] args)
        {
            Upload("Visual Studio 2015 Licensing Whitepaper - November-2016.pdf", "arquivo.pdf");
            Console.ReadLine();
            Download("arquivo.pdf");
            Console.ReadLine();
        }

    ' VB.NET
    Sub Main()
        Upload("Visual Studio 2015 Licensing Whitepaper - November-2016.pdf", "arquivo.pdf")
        Console.ReadLine()
        Download("arquivo.pdf")
        Console.ReadLine()
    End Sub

Execute o projeto e veja que o arquivo será baixado do servidor FTP com sucesso:

Desafios do FtpWebRequest

O upload e download de arquivos são as operações mais básicas que podemos realizar em um servidor FTP. Muitas vezes, somente essas duas operações já resolvem as necessidades do nosso projeto. Porém, existem outras operações que são tão importantes quanto o upload e download, como criação de diretórios, deleção de arquivos, listagem do conteúdo de uma pasta, etc. Será que essas outras operações também podem ser implementadas com o FtpWebRequest?

Teoricamente, sim – essas outras operações podem ser implementadas com o FtpWebRequest. Porém, o código acaba ficando um tanto quanto complexo. Veja só esta thread no StackOverflow sobre a criação de diretórios com o FtpWebRequest. Ou esta outra thread sobre a deleção de arquivos. Como você pode perceber, o código fica complicado de entender. Por isso, na minha opinião, se a sua aplicação precisa fazer mais do que um simples upload ou download de arquivos de um servidor FTP, vale a pena investigar algumas alternativas à classe FtpWebRequest.

Procurando por alternativas ao FtpWebRequest, acabei encontrando esta outra thread no StackOverflow. Várias sugestões são dadas naquela discussão, porém a que mais se destacou foi a biblioteca FluentFTP.

Conhecendo a biblioteca FluentFTP

A biblioteca FluentFTP (conhecida anteriormente como System.Net.FtpClient) é uma biblioteca desenvolvida 100% com código gerenciado e implementa todas as funcionalidades que você possa imaginar relacionadas ao acesso a servidores FTP. Ela é open source (o seu código está publicado no GitHub) e é disponibilizada através da licença MIT (extremamente permissiva).

Para instalarmos o FluentFTP no nosso projeto, basta utilizarmos o NuGet (procurando por “FluentFTP” ou digitando o comando “Install-Package FluentFTP” no Package Manager Console – caso tenha dúvidas sobre a utilização do NuGet no Visual Studio, confira este artigo):

Uma vez instalada a biblioteca, vamos ver como podemos fazer para implementarmos o upload de um arquivo.

As classes do FluentFTP ficam dentro do namespace “FluentFTP” e a principal classe que vamos utilizar é a FtpClient. Com ela nós conseguiremos fazer todas as operações no nosso servidor FTP. O upload de arquivo, por exemplo, é feito através do método OpenWrite, que cria uma Stream onde teremos que escrever o conteúdo do arquivo (como fizemos com o FtpWebRequest que vimos anteriormente).

Tomando como base o exemplo disponibilizado no GitHub da biblioteca, esta foi a minha primeira tentativa de implementação do upload de um arquivo:

        // C#
        private static void UploadFluent(string arquivo, string destino)
        {
            using (var client = new FluentFTP.FtpClient())
            {
                client.Host = "ftp://localhost";
                using (var stream = client.OpenWrite(destino))
                {
                    var conteudoArquivo = System.IO.File.ReadAllBytes(arquivo);
                    stream.Write(conteudoArquivo, 0, conteudoArquivo.Length);
                }
            }
        }

    ' VB.NET
    Private Sub UploadFluent(Arquivo As String, Destino As String)
        Using Client = New FluentFTP.FtpClient()
            Client.Host = "ftp://localhost"
            Using Stream = Client.OpenWrite(destino)
                Dim ConteudoArquivo = System.IO.File.ReadAllBytes(Arquivo)
                Stream.Write(ConteudoArquivo, 0, ConteudoArquivo.Length)
            End Using
        End Using
    End Sub

E, obviamente, temos que adicionar a chamada no método “main“:

        // C#
        static void Main(string[] args)
        {
            UploadFluent("Visual Studio 2015 Licensing Whitepaper - November-2016.pdf", "arquivo.pdf");
            Console.WriteLine("Upload FluentFTP completo");
            Console.ReadLine();
        }

    ' VB.NET
    Sub Main()
        UploadFluent("Visual Studio 2015 Licensing Whitepaper - November-2016.pdf", "arquivo.pdf")
        Console.WriteLine("Upload FluentFTP completo")
        Console.ReadLine()
    End Sub

Porém, ao testar esse código, acabei recebendo este erro:

Isso acontece porque a biblioteca FluentFTP espera que o endereço do servidor FTP não tenha o prefixo “ftp://“. Ou seja, no meu caso que o servidor está localizado no “localhost“, eu deveria passar somente “localhost“, e não “ftp://localhost“:

        // C#
        private static void UploadFluent(string arquivo, string destino)
        {
            using (var client = new FluentFTP.FtpClient())
            {
                client.Host = "localhost";
                using (var stream = client.OpenWrite(destino))
                {
                    var conteudoArquivo = System.IO.File.ReadAllBytes(arquivo);
                    stream.Write(conteudoArquivo, 0, conteudoArquivo.Length);
                }
            }
        }

    ' VB.NET
    Private Sub UploadFluent(Arquivo As String, Destino As String)
        Using Client = New FluentFTP.FtpClient()
            Client.Host = "localhost"
            Using Stream = Client.OpenWrite(destino)
                Dim ConteudoArquivo = System.IO.File.ReadAllBytes(Arquivo)
                Stream.Write(ConteudoArquivo, 0, ConteudoArquivo.Length)
            End Using
        End Using
    End Sub

Depois dessa alteração, a mensagem de erro mudou:

Dessa vez o problema é que não passamos as credenciais para o acesso ao servidor FTP. Eu achei que, devido ao servidor suportar conexões anônimas, eu não precisaria passar as credenciais para o cliente. Mas, se repararmos bem, com o FtpWebRequest nós também temos que passar as credenciais, senão o código não funciona.

Com o FluentFTP, nós passamos as credenciais para o FtpClient através da propriedade Credentials:

        // C#
        private static void UploadFluent(string arquivo, string destino)
        {
            using (var client = new FluentFTP.FtpClient())
            {
                client.Host = "localhost";
                client.Credentials = new System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br");
                using (var stream = client.OpenWrite(destino))
                {
                    var conteudoArquivo = System.IO.File.ReadAllBytes(arquivo);
                    stream.Write(conteudoArquivo, 0, conteudoArquivo.Length);
                }
            }
        }

    ' VB.NET
    Private Sub UploadFluent(Arquivo As String, Destino As String)
        Using Client = New FluentFTP.FtpClient()
            Client.Host = "localhost"
            Client.Credentials = New System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br")
            Using Stream = Client.OpenWrite(destino)
                Dim ConteudoArquivo = System.IO.File.ReadAllBytes(Arquivo)
                Stream.Write(ConteudoArquivo, 0, ConteudoArquivo.Length)
            End Using
        End Using
    End Sub

Agora sim, ao executarmos o projeto novamente, o upload do arquivo será realizado com sucesso. A implementação da funcionalidade de download é extremamente parecida. A única diferença é que, ao invés de utilizarmos o método OpenWrite, nós utilizamos o método OpenRead e gravamos o conteúdo no disco através de um FileStream:

        // C#
        private static void DownloadFluent(string caminho)
        {
            using (var client = new FluentFTP.FtpClient())
            {
                client.Host = "localhost";
                client.Credentials = new System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br");
                using (var stream = client.OpenRead(caminho))
                {
                    using (var fileStream = new System.IO.FileStream(caminho, System.IO.FileMode.Create))
                    {
                        stream.CopyTo(fileStream);
                    }
                }
            }
        }

    ' VB.NET
    Private Sub DownloadFluent(Caminho As String)
        Using Client = New FluentFTP.FtpClient()
            Client.Host = "localhost"
            Client.Credentials = New System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br")
            Using Stream = Client.OpenRead(Caminho)
                Using FileStream = New System.IO.FileStream(Caminho, System.IO.FileMode.Create)
                    Stream.CopyTo(FileStream)
                End Using
            End Using
        End Using
    End Sub

Não podemos esquecer de adicionar a chamada no método “main“!

        // C#
        static void Main(string[] args)
        {
            UploadFluent("Visual Studio 2015 Licensing Whitepaper - November-2016.pdf", "arquivo.pdf");
            Console.WriteLine("Upload FluentFTP completo");
            Console.ReadLine();
            DownloadFluent("arquivo.pdf");
            Console.WriteLine("Download FluentFTP completo");
            Console.ReadLine();
        }

    ' VB.NET
    Sub Main()
        UploadFluent("Visual Studio 2015 Licensing Whitepaper - November-2016.pdf", "arquivo.pdf")
        Console.WriteLine("Upload FluentFTP completo")
        Console.ReadLine()
        DownloadFluent("arquivo.pdf")
        Console.WriteLine("Download FluentFTP completo")
        Console.ReadLine()
    End Sub

Pronto! Com isso nós temos as funcionalidades de upload e download de arquivos implementada com a biblioteca FluentFTP. Vamos agora partir para algumas funcionalidades mais interessantes?

Deletando um arquivo do servidor

Como mencionei anteriormente, para deletarmos um arquivo do servidor FTP com o FtpWebRequest, temos que fazer um certo malabarismo. Já com a biblioteca FluentFTP, essa funcionalidade pode ser implementada de maneira extremamente simples. Basta chamarmos o método “DeleteFile” da classe FtpClient passando o caminho do arquivo que queremos deletar:

        // C#
        private static void DeletarArquivoFluent(string caminho)
        {
            using (var client = new FluentFTP.FtpClient())
            {
                client.Host = "localhost";
                client.Credentials = new System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br");
                client.DeleteFile(caminho);
            }
        }

    ' VB.NET
    Private Sub DeletarArquivoFluent(Caminho As String)
        Using Client = New FluentFTP.FtpClient()
            Client.Host = "localhost"
            Client.Credentials = New System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br")
            Client.DeleteFile(Caminho)
        End Using
    End Sub

Criando e deletando diretórios

A criação e deleção de diretórios também pode ser implementada de maneira muito simples através da biblioteca FluentFTP. Basta utilizarmos os métodos CreateDirectory e DeleteDirectory:

        // C#
        private static void CriarDiretorioFluent(string diretorio)
        {
            using (var client = new FluentFTP.FtpClient())
            {
                client.Host = "localhost";
                client.Credentials = new System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br");
                client.CreateDirectory(diretorio);
            }
        }

        private static void DeletarDiretorioFluent(string diretorio)
        {
            using (var client = new FluentFTP.FtpClient())
            {
                client.Host = "localhost";
                client.Credentials = new System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br");
                client.DeleteDirectory(diretorio, true, false);
            }
        }

    ' VB.NET
    Private Sub CriarDiretorioFluent(Diretorio As String)
        Using client = New FluentFTP.FtpClient()
            client.Host = "localhost"
            client.Credentials = New System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br")
            client.CreateDirectory(diretorio)
        End Using
    End Sub

    Private Sub DeletarDiretorioFluent(Diretorio As String)
        Using Client = New FluentFTP.FtpClient()
            Client.Host = "localhost"
            Client.Credentials = New System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br")
            Client.DeleteDirectory(Diretorio, True, False)
        End Using
    End Sub

Note que temos a opção de fazermos a deleção recursiva na chamada do método DeleteDirectory. Para isso, nós temos que passar “true” para o parâmetro “force” (que é o segundo parâmetro desse método).

Listando o conteúdo de um diretório

Por fim, vamos ver uma última funcionalidade bem interessante da biblioteca FluentFTP: a listagem dos arquivos de um diretório. O método “GetListing” da classe FtpClient implementa essa funcionalidade na biblioteca FluentFTP. Porém, esse método não faz a listagem recursiva do diretório, ou seja, se quisermos listar recursivamente todos os arquivos de um diretório, nós teremos que implementar a recursividade no lado do nosso aplicativo.

Não se assuste. Isso não é nem um pouco complicado de ser feito. Basta criarmos um método que chama ele mesmo caso o item do FTP seja do tipo “Directory“. Veja só como fica o código:

        // C#
        private static void ListarConteudoFluent()
        {
            using (var client = new FluentFTP.FtpClient())
            {
                client.Host = "localhost";
                client.Credentials = new System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br");
                ListarConteudoFluentRecursivo(client, string.Empty);
            }
        }

        private static void ListarConteudoFluentRecursivo(FluentFTP.FtpClient client, string caminho)
        {
            var arquivos = client.GetListing(caminho);
            foreach (var arquivo in arquivos)
            {
                if (arquivo.Type == FluentFTP.FtpFileSystemObjectType.Directory)
                {
                    ListarConteudoFluentRecursivo(client, arquivo.FullName);
                }
                else
                {
                    Console.WriteLine("{0} || {1} b || {2:G}", arquivo.FullName, arquivo.Size, arquivo.Created != DateTime.MinValue ? arquivo.Created : arquivo.Modified);
                }
            }
        }

    ' VB.NET
    Private Sub ListarConteudoFluent()
        Using Client = New FluentFTP.FtpClient()
            Client.Host = "localhost"
            Client.Credentials = New System.Net.NetworkCredential("anonymous", "contato@andrealveslima.com.br")
            ListarConteudoFluentRecursivo(Client, String.Empty)
        End Using
    End Sub

    Private Sub ListarConteudoFluentRecursivo(Client As FluentFTP.FtpClient, Caminho As String)
        Dim Arquivos = Client.GetListing(Caminho)
        For Each Arquivo In Arquivos
            If Arquivo.Type = FluentFTP.FtpFileSystemObjectType.Directory Then
                ListarConteudoFluentRecursivo(Client, Arquivo.FullName)
            Else
                Console.WriteLine("{0} || {1} b || {2:G}", Arquivo.FullName, Arquivo.Size, If(Arquivo.Created <> DateTime.MinValue, Arquivo.Created, Arquivo.Modified))
            End If
        Next
    End Sub

Veja que, na hora de acessarmos a data do arquivo, temos duas propriedades à nossa disposição: “Created” e “Modified“. Porém, nem todos os servidores FTP suportam a data de criação dos arquivos. Portanto, ao invés de simplesmente acessarmos diretamente a propriedade “Created“, nós verificamos se ela não é igual a DateTime.MinValue. Caso ela seja igual a DateTime.MinValue, isso significa que o servidor não informa a data de criação do arquivo, então, nós utilizamos a propriedade “Modified“, que retorna a data da última modificação do arquivo.

Eu copiei a pasta “Debug” do projeto para dentro do meu servidor FTP e o resultado da listagem dos arquivos foi este:

Concluindo

O .NET Framework conta com uma classe que implementa as funcionalidades necessárias para acessarmos um servidor FTP através dos nossos aplicativos. Essa classe, chamada FtpWebRequest, é muito simples de ser utilizada para fazermos upload e download de arquivos em um servidor FTP com C# e VB.NET. Porém, para operações mais complexas, o código acaba ficando bem difícil de entender.

Uma ótima alternativa à classe FtpWebRequest é a biblioteca FluentFTP. Essa biblioteca possui métodos muito simples para fazermos upload, download e deleção de arquivos, criação, deleção e listagem de diretórios, entre outras funcionalidades.

No artigo de hoje você conferiu como utilizar a classe FtpWebRequest para fazer o upload e download de arquivos, bem como a biblioteca FluentFTP para implementar as outras funcionalidades mais complexas.

Você já precisou trabalhar com FTP nas suas aplicações? Como é que você acabou implementando essas funcionalidades? Utilizou o FtpWebRequest ou o FluentFTP? Ou talvez até mesmo uma outra biblioteca diferente? Conte-nos mais detalhes na caixa de comentários!

Por fim, convido você a inscrever-se na minha newsletter. Ao fazer isso, você receberá um e-mail toda semana sobre o artigo publicado e ficará sabendo também em primeira mão sobre o artigo da próxima semana, além de receber dicas “bônus” que eu só compartilho por e-mail. Inscreva-se utilizando o formulário logo abaixo.

Até a próxima!

André Lima

Image by Pixabay used under Creative Commons
https://pixabay.com/en/computer-file-network-server-156949/

Apresentação DevWeek 2016 – Ferramentas gratuitas para geração de relatórios no .NET Nos vemos em 2017!