C# - FTP :  Upload e Download, Delete, Move de arquivos (revisão)

 Hoje vamos recordar como fazer o upload, download, move, e delete de arquivos via FTP em  uma aplicação Windows Forms usando a linguagem C#.

 

Conceitos Básicos - Revisão

A classe FtpWebRequest implementa um cliente FTP - File Transfer Protocol e permite criar via código conexões com servidores FTP para transferir arquivos.

Para obter uma instância desta classe usamos o método Create:

FtpWebRequest.Create(new Uri(txtDominioFTP.Text));  //FtpWebRequest.Create(txtDominioFtp.Text)

Nota: Você também pode usar a classe WebClient para enviar e baixar informações de um servidor FTP

Usando qualquer uma dessas abordagens quando você especificar o seu recurso de rede que usa o esquema FTP (por exemplo ftp://macoratti.net) a classe FtpWebRequest permite interagir com servidores FTP via código.

A URI informada pode ser relativa ou absoluta:

Você tem que ter um nome de usuário e senha válidos para o servidor ou o servidor deve permitir o login anônimo. As credenciais usadas para se conectar com o servidor podem ser definidas usando a propriedade Credentials ou você pode incluí-las na parte UserInfo da URI passada para o método Create; neste caso a propriedade Credentials é definida para uma nova credencial com a informação do usuário e senha.

Você tem que ter permissão para acessar o recurso FTP ou uma exceção do tipo SecurityException será lançada.

Ao usar FtpWebRequest para enviar um arquivo para um servidor você precisa escrever o conteúdo do arquivo para a requisição stream obtida pela chamada do método GetRequestStream ou pela sua contraparte assíncrona BeginGetRequestStream e EndGetRequestStream. Você tem que escrever para o stream e fechar o stream antes de enviar a requisição.

As requisições são enviadas ao servidor pelo método GeResponse ou BeginGetResponse/EndGetResponse. Quando a operação terminar um objeto FtpWebResponse será retornado, sendo que este objeto fornece o status da operação.

A fazer o download de um arquivo de um servidor FTP, se o comando foi executado com sucesso, o conteúdo do arquivo requisitado estará disponível no stream do objeto da resposta. Este stream pode ser acessado chamando o método GetResponseStream.

Se a propriedade Proxy for definida, quer diretamente quer via arquivo de configuração, a comunicação com o servidor FTP será feita através do proxy definido. Se o proxy for um proxy HTTP somente os comandos DownloadFile, ListDirectory e ListDirectoryDetails são suportados.

Somente o download de conteúdo binário é armazenado em cache ou seja o conteúdo recebido pelo comando DownloadFile com a propriedade UseBinary definida como true.

Após a revisão desses conceitos vamos realizar algumas operações via FTP usando C#.

 

Recursos usados :

Criando o projeto no VS 2013

Abra o VS 2013 Express for Windows desktop e clique em New Project;

A seguir selecione Visual C# -> Windows Forms Application;

Informe o nome FTP_Upload_Download e clique no botão OK;

Vamos agora definir a interface com o usuário incluindo no formulário form1.cs do projeto os seguintes controles a partir da ToolBox:

Disponha os controles no formulário conforme o leiaute da figura abaixo:

Agora vamos criar uma classe em nosso projeto chamada FTP onde iremos definir os métodos para realizar as operações FTP.

No menu PROJECT clique em Add -> Class e informe o nome FTP.

A seguir inclua o código abaixo nesta classe:

Vamos definir no início da classe os seguintes namespaces :

using System;

using System.Net;

using System.IO;

Agora vamos definir dois métodos :

  1. EnviarArquivoFTP(string arquivo, string url, string usuario, string senha)

  2. BaixarArquivoFTP(string url, string local, string usuario, string senha)

Estes métodos utilizam como parâmetros os valores necessários para realizar o upload e download de arquivos incluindo o nome do usuário e a senha no servidor FTP.

Nota: Seria mais elegante definir uma classe com os dados necessários para realizar essas operações e usar a classe como parâmetro desses métodos.

Abaixo vemos a implementação destes métodos: 

        /// <summary>
        /// Upload de arquivos
        /// </summary>
        /// <param name="arquivo"></param>
        /// <param name="url"></param>
        /// <param name="usuario"></param>
        /// <param name="senha"></param>
        public static void EnviarArquivoFTP(string arquivo, string url, string usuario, string senha)
        {
            try
            {
                FileInfo arquivoInfo = new FileInfo(arquivo);
                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(new Uri(url));
                request.Method = WebRequestMethods.Ftp.UploadFile;
                request.Credentials = new NetworkCredential(usuario, senha);
                request.UseBinary = true;
                request.ContentLength = arquivoInfo.Length;
                using (FileStream fs = arquivoInfo.OpenRead())
                {
                    byte[] buffer = new byte[2048];
                    int bytesSent = 0;
                    int bytes = 0;
                    using (Stream stream = request.GetRequestStream())
                    {
                        while (bytesSent < arquivoInfo.Length)
                        {
                            bytes = fs.Read(buffer, 0, buffer.Length);
                            stream.Write(buffer, 0, bytes);
                            bytesSent += bytes;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Download de arquivos
        /// </summary>
        /// <param name="url"></param>
        /// <param name="local"></param>
        /// <param name="usuario"></param>
        /// <param name="senha"></param>
        public static void BaixarArquivoFTP(string url, string local, string usuario, string senha)
        {  
            try
            {
                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(new Uri(url));
                request.Method = WebRequestMethods.Ftp.DownloadFile;
                request.Credentials = new NetworkCredential(usuario,senha);
                request.UseBinary = true;
                using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
                {
                    using (Stream rs = response.GetResponseStream())
                    {
                        using (FileStream ws = new FileStream(local, FileMode.Create))
                        {
                            byte[] buffer = new byte[2048];
                            int bytesRead = rs.Read(buffer, 0, buffer.Length);
                            while (bytesRead > 0)
                            {
                                ws.Write(buffer, 0, bytesRead);
                                bytesRead = rs.Read(buffer, 0, buffer.Length);
                            }
                        }
                    }
                }
            }
            catch
            {
                throw;
            }
       }
C#

Já podemos usar a classe para enviar e baixar arquivos via FTP.

Definindo o código na interface do usuário

Para começar vamos definir os namespaces necessários :

using System;

using System.Security;

using System.Windows.Forms;

using System.IO;

Vamos definir o código no evento Click dos botões de comando do formulário form1.cs.

1- Enviar Arquivo

  private void btnEnviarArquivo_Click(object sender, EventArgs e)
  {
            if (validaInformacaoServidorFTP())
            {
                if (!string.IsNullOrEmpty(txtArquivoUpload.Text))
                {
                    string urlArquivoEnviar = txtEnderecoServidorFTP.Text + "/sistemas/" + Path.GetFileName(txtArquivoUpload.Text);
                    try
                    {
                        FTP.EnviarArquivoFTP(txtArquivoUpload.Text, urlArquivoEnviar,txtUsuario.Text,txtSenha.Text);
                    }
                    catch(Exception ex)
                    {
                        MessageBox.Show("Erro " + ex.Message, "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
            else
            {
                MessageBox.Show("Informações do sevidor incompletas", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
   }

No evento Click do botão de comando btnProcurar temos o código que permite ao usuário selecionar um arquivo para enviar:

private void btnProcurar_Click(object sender, EventArgs e)
 {
            OpenFileDialog ofd1 = new OpenFileDialog();
            //define as propriedades do controle 
            //OpenFileDialog
            ofd1.Multiselect = false;
            ofd1.Title = "Selecionar Arquivos";
            ofd1.InitialDirectory = @"C:\Dados\";
            //filtra para exibir todos arquivos
            ofd1.Filter = "All files (*.*)|*.*";
            ofd1.CheckFileExists = true;
            ofd1.CheckPathExists = true;
            ofd1.RestoreDirectory = true;
            
            DialogResult dr = ofd1.ShowDialog();
            if (dr == System.Windows.Forms.DialogResult.OK)
            {
                try
                {
                    txtArquivoUpload.Text = ofd1.FileName;
                }
                catch (SecurityException ex)
                {
                    // O usuário  não possui permissão para ler arquivos
                    MessageBox.Show("Erro de segurança Contate o administrador de segurança da rede.\n\n" +
                                                "Mensagem : " + ex.Message + "\n\n" +
                                                "Detalhes (enviar ao suporte):\n\n" + ex.StackTrace);
                }
                catch (Exception ex)
                {
                    // Não pode carregar a imagem (problemas de permissão)
                    MessageBox.Show("Você pode não ter permissão para ler o arquivo , ou " +
                                               " ele pode estar corrompido.\n\nErro reportado : " + ex.Message);
                }
            }
 }

2- Baixar Arquivos

 private void btnBaixarArquivo_Click(object sender, EventArgs e)
  {
            if (validaInformacaoServidorFTP())
            {
                if (validaInformacaoDownload())
                {
                    try
                    {
                        FTP.BaixarArquivoFTP(txtArquivoDownload.Text, txtBaixarPara.Text,txtUsuario.Text,txtSenha.Text);
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show("Erro " + ex.Message, "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
                else
                {
                    MessageBox.Show("Informações para download incompletas", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            else
            {
                MessageBox.Show("Informações do sevidor incompletas", "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);
           }
 }

Abaixo vemos os métodos que realizam as validações a nível de formulário : 

        private bool validaInformacaoServidorFTP()
        {
            if (string.IsNullOrEmpty(txtUsuario.Text) || string.IsNullOrEmpty(txtSenha.Text) || string.IsNullOrEmpty(txtEnderecoServidorFTP.Text))
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        private bool validaInformacaoDownload()
        {
            if (string.IsNullOrEmpty(txtArquivoDownload.Text) || string.IsNullOrEmpty(txtBaixarPara.Text))
            {
                return false;
            }
            else
            {
                return true;
            }
        }

Agora podemos executar o projeto e verificar o resultado conforme abaixo:

Agora para concluir eu vou mostrar a implementação para as operações de deletar e mover arquivos via FTP:

Vamos incluir os métodos na classe FTP.cs que criamos no projeto.

3- Mover Arquivo

        public void MoverArquivo(string ftpURL, string UserName, string Password, string ftpDirectory, string ftpDirectoryProcessed, string FileName)
        {
            FtpWebRequest ftpRequest = null;
            FtpWebResponse ftpResponse = null;
            try
            {
                ftpRequest = (FtpWebRequest)WebRequest.Create(ftpURL + "/" + ftpDirectory + "/" + FileName);
                ftpRequest.Credentials = new NetworkCredential(UserName, Password);
                ftpRequest.UseBinary = true;
                ftpRequest.UsePassive = true;
                ftpRequest.KeepAlive = true;
                ftpRequest.Method = WebRequestMethods.Ftp.Rename;
                ftpRequest.RenameTo = ftpDirectoryProcessed + "/" + FileName;
                ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
                ftpResponse.Close();
                ftpRequest = null;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

A chamada deste método pode ser feito assim : MoverArquivo(_ftpURL, _UserName, _Password, _ftpDirectory, _FileName, _ftpDirectoryProcessed);

4- Deletar Arquivo 

 public void DeletaArquivo(string ftpURL, string UserName, string Password, string ftpDirectory, string FileName)
  {
            try
            {
                FtpWebRequest ftpRequest = (FtpWebRequest)WebRequest.Create(ftpURL + "/" + ftpDirectory + "/" + FileName);
                ftpRequest.Credentials = new NetworkCredential(UserName, Password);
                ftpRequest.Method = WebRequestMethods.Ftp.DeleteFile;
                FtpWebResponse responseFileDelete = (FtpWebResponse)ftpRequest.GetResponse();
            }
            catch (Exception ex)
            {
                throw ex;
            }
  }

A chamada deste método pode ser feito assim :  DeletaArquivo(_ftpURL, _UserName, _Password, _ftpDirectory, _FileName);

Pegue o projeto completo aqui: FTP_Upload_Download.zip

Jesus respondeu, e disse-lhe: Porque te disse: Vi-te debaixo da figueira, crês ? Coisas maiores do que estas verás.
E disse-lhe: Na verdade, na verdade vos digo que daqui em diante vereis o céu aberto, e os anjos de Deus subindo e descendo sobre o Filho do homem.
João 1:50,51

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 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti