FtpWebRequest Classe

Definição

Namespace:

System.Net

Assemblies:

netstandard.dll, System.Net.Requests.dll

Origem:

FtpWebRequest.cs

Implementa um cliente de protocolo FTP.

public ref class FtpWebRequest sealed : System::Net::WebRequest

public sealed class FtpWebRequest : System.Net.WebRequest

type FtpWebRequest = class
    inherit WebRequest

Public NotInheritable Class FtpWebRequest
Inherits WebRequest

Herança

Object

MarshalByRefObject

WebRequest

FtpWebRequest

Exemplos

O exemplo de código a seguir demonstra a exclusão de um arquivo de um servidor FTP.

public static bool DeleteFileOnServer(Uri serverUri)
{
    // The serverUri parameter should use the ftp:// scheme.
    // It contains the name of the server file that is to be deleted.
    // Example: ftp://contoso.com/someFile.txt.
    //

    if (serverUri.Scheme != Uri.UriSchemeFtp)
    {
        return false;
    }
    // Get the object used to communicate with the server.
    FtpWebRequest request = (FtpWebRequest)WebRequest.Create(serverUri);
    request.Method = WebRequestMethods.Ftp.DeleteFile;

    FtpWebResponse response = (FtpWebResponse) request.GetResponse();
    Console.WriteLine("Delete status: {0}",response.StatusDescription);
    response.Close();
    return true;
}

O exemplo de código a seguir demonstra o download de um arquivo de um servidor FTP usando a WebClient classe .

public static bool DisplayFileFromServer(Uri serverUri)
{
    // The serverUri parameter should start with the ftp:// scheme.
    if (serverUri.Scheme != Uri.UriSchemeFtp)
    {
        return false;
    }
    // Get the object used to communicate with the server.
    WebClient request = new WebClient();

    // This example assumes the FTP site uses anonymous logon.
    request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");
    try
    {
        byte [] newFileData = request.DownloadData (serverUri.ToString());
        string fileString = System.Text.Encoding.UTF8.GetString(newFileData);
        Console.WriteLine(fileString);
    }
    catch (WebException e)
    {
        Console.WriteLine(e.ToString());
    }
    return true;
}

O exemplo de código a seguir demonstra o uso de operações assíncronas para carregar um arquivo em um servidor FTP.

using System;
using System.Net;
using System.Threading;

using System.IO;
namespace Examples.System.Net
{
    public class FtpState
    {
        private ManualResetEvent wait;
        private FtpWebRequest request;
        private string fileName;
        private Exception operationException = null;
        string status;

        public FtpState()
        {
            wait = new ManualResetEvent(false);
        }

        public ManualResetEvent OperationComplete
        {
            get {return wait;}
        }

        public FtpWebRequest Request
        {
            get {return request;}
            set {request = value;}
        }

        public string FileName
        {
            get {return fileName;}
            set {fileName = value;}
        }
        public Exception OperationException
        {
            get {return operationException;}
            set {operationException = value;}
        }
        public string StatusDescription
        {
            get {return status;}
            set {status = value;}
        }
    }
    public class AsynchronousFtpUpLoader
    {
        // Command line arguments are two strings:
        // 1. The url that is the name of the file being uploaded to the server.
        // 2. The name of the file on the local machine.
        //
        public static void Main(string[] args)
        {
            // Create a Uri instance with the specified URI string.
            // If the URI is not correctly formed, the Uri constructor
            // will throw an exception.
            ManualResetEvent waitObject;

            Uri target = new Uri (args[0]);
            string fileName = args[1];
            FtpState state = new FtpState();
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(target);
            request.Method = WebRequestMethods.Ftp.UploadFile;

            // This example uses anonymous logon.
            // The request is anonymous by default; the credential does not have to be specified.
            // The example specifies the credential only to
            // control how actions are logged on the server.

            request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");

            // Store the request in the object that we pass into the
            // asynchronous operations.
            state.Request = request;
            state.FileName = fileName;

            // Get the event to wait on.
            waitObject = state.OperationComplete;

            // Asynchronously get the stream for the file contents.
            request.BeginGetRequestStream(
                new AsyncCallback (EndGetStreamCallback),
                state
            );

            // Block the current thread until all operations are complete.
            waitObject.WaitOne();

            // The operations either completed or threw an exception.
            if (state.OperationException != null)
            {
                throw state.OperationException;
            }
            else
            {
                Console.WriteLine("The operation completed - {0}", state.StatusDescription);
            }
        }
        private static void EndGetStreamCallback(IAsyncResult ar)
        {
            FtpState state = (FtpState) ar.AsyncState;

            Stream requestStream = null;
            // End the asynchronous call to get the request stream.
            try
            {
                requestStream = state.Request.EndGetRequestStream(ar);
                // Copy the file contents to the request stream.
                const int bufferLength = 2048;
                byte[] buffer = new byte[bufferLength];
                int count = 0;
                int readBytes = 0;
                FileStream stream = File.OpenRead(state.FileName);
                do
                {
                    readBytes = stream.Read(buffer, 0, bufferLength);
                    requestStream.Write(buffer, 0, readBytes);
                    count += readBytes;
                }
                while (readBytes != 0);
                Console.WriteLine ("Writing {0} bytes to the stream.", count);
                // IMPORTANT: Close the request stream before sending the request.
                requestStream.Close();
                // Asynchronously get the response to the upload request.
                state.Request.BeginGetResponse(
                    new AsyncCallback (EndGetResponseCallback),
                    state
                );
            }
            // Return exceptions to the main application thread.
            catch (Exception e)
            {
                Console.WriteLine("Could not get the request stream.");
                state.OperationException = e;
                state.OperationComplete.Set();
                return;
            }
        }

        // The EndGetResponseCallback method
        // completes a call to BeginGetResponse.
        private static void EndGetResponseCallback(IAsyncResult ar)
        {
            FtpState state = (FtpState) ar.AsyncState;
            FtpWebResponse response = null;
            try
            {
                response = (FtpWebResponse) state.Request.EndGetResponse(ar);
                response.Close();
                state.StatusDescription = response.StatusDescription;
                // Signal the main application thread that
                // the operation is complete.
                state.OperationComplete.Set();
            }
            // Return exceptions to the main application thread.
            catch (Exception e)
            {
                Console.WriteLine ("Error getting response.");
                state.OperationException = e;
                state.OperationComplete.Set();
            }
        }
    }
}

Comentários

Importante

Não recomendamos que você use a FtpWebRequest classe para novo desenvolvimento. Para obter mais informações e alternativas ao FtpWebRequest, consulte WebRequest não deve ser usado no GitHub.

Para obter uma instância do FtpWebRequest, use o Create método . Você também pode usar a WebClient classe para carregar e baixar informações de um servidor FTP. Usando qualquer uma dessas abordagens, quando você especifica um recurso de rede que usa o esquema FTP (por exemplo, ) a "ftp://contoso.com"FtpWebRequest classe fornece a capacidade de interagir programaticamente com servidores FTP.

O URI pode ser relativo ou absoluto. Se o URI for do formulário "ftp://contoso.com/%2fpath" (%2f for um '/' com escape), o URI será absoluto e o diretório atual será /path. Se, no entanto, o URI for do formulário "ftp://contoso.com/path", primeiro o .NET Framework entrará no servidor FTP (usando o nome de usuário e a Credentials senha definidos pela propriedade), o diretório atual será definido como <UserLoginDirectory>/path.

Você deve ter um nome de usuário e uma senha válidos para o servidor ou o servidor deve permitir logon anônimo. Você pode especificar as credenciais usadas para se conectar ao servidor definindo a Credentials propriedade ou pode incluí-las na UserInfo parte do URI passada para o Create método . Se você incluir UserInfo informações no URI, a Credentials propriedade será definida como uma nova credencial de rede com as informações de nome de usuário e senha especificadas.

Cuidado

A menos que a EnableSsl propriedade seja true, todos os dados e comandos, incluindo suas informações de nome de usuário e senha, são enviados ao servidor em texto não criptografado. Qualquer pessoa que monitore o tráfego de rede pode exibir suas credenciais e usá-las para se conectar ao servidor. Se você estiver se conectando a um servidor FTP que requer credenciais e dá suporte à SSL (Secure Sockets Layer), defina EnableSsl como true.

Você deve ter que WebPermission acessar o recurso FTP; caso contrário, uma SecurityException exceção é gerada.

Especifique o comando FTP a ser enviado ao servidor definindo a Method propriedade como um valor definido na WebRequestMethods.Ftp estrutura. Para transmitir dados de texto, altere a UseBinary propriedade de seu valor padrão (true) para false. Para obter detalhes e restrições, consulte Method.

Ao usar um FtpWebRequest objeto para carregar um arquivo em um servidor, você deve gravar o conteúdo do arquivo no fluxo de solicitação obtido chamando o GetRequestStream método ou seus equivalentes assíncronos, os BeginGetRequestStream métodos e EndGetRequestStream . Você deve gravar no fluxo e fechar o fluxo antes de enviar a solicitação.

As solicitações são enviadas ao servidor chamando o GetResponse método ou seus equivalentes assíncronos, os BeginGetResponse métodos e EndGetResponse . Quando a operação solicitada é concluída, um FtpWebResponse objeto é retornado. O FtpWebResponse objeto fornece o status da operação e todos os dados baixados do servidor.

Você pode definir um valor de tempo limite para leitura ou gravação no servidor usando a ReadWriteTimeout propriedade . Se o período de tempo limite for excedido, o método de chamada lançará um WebException com definido como WebExceptionStatusTimeout.

Ao baixar um arquivo de um servidor FTP, se o comando tiver sido bem-sucedido, o conteúdo do arquivo solicitado estará disponível no fluxo do objeto de resposta. Você pode acessar esse fluxo chamando o GetResponseStream método . Para obter mais informações, consulte FtpWebResponse.

Se a Proxy propriedade estiver definida, diretamente ou em um arquivo de configuração, as comunicações com o servidor FTP serão feitas por meio do proxy especificado. Se o proxy especificado for um proxy HTTP, somente os DownloadFilecomandos , ListDirectorye ListDirectoryDetails serão compatíveis.

Somente o conteúdo binário baixado é armazenado em cache; ou seja, o conteúdo recebido usando o DownloadFile comando com a UseBinary propriedade definida como true.

Vários FtpWebRequests reutilizam conexões existentes, se possível.

Para obter mais informações sobre o protocolo FTP, consulte RFC 959: File Transfer Protocol.

Propriedades

Nome	Description
AuthenticationLevel	Obtém ou define valores que indicam o nível de autenticação e representação usada para esta solicitação. (Herdado de WebRequest)
CachePolicy	Obtém ou define a política de cache para essa solicitação. (Herdado de WebRequest)
ClientCertificates	Obtém ou define os certificados usados para estabelecer uma conexão criptografada ao servidor FTP.
ConnectionGroupName	Obtém ou define o nome do grupo de conexão que contém o ponto de serviço usado para enviar a solicitação atual.
ContentLength	Obtém ou define um valor que é ignorado pela classe FtpWebRequest.
ContentOffset	Obtém ou define um deslocamento de bytes no arquivo que está sendo baixado por essa solicitação.
ContentType	Sempre gera um NotSupportedException.
Credentials	Obtém ou define as credenciais usadas para se comunicar com o servidor FTP.
DefaultCachePolicy	Define a política de cache padrão para todas as solicitações FTP.
EnableSsl	Obtém ou define um Boolean que especifica se uma conexão SSL deve ser usada.
Headers	Obtém um objeto WebHeaderCollection vazio.
ImpersonationLevel	Obtém ou define o nível de representação para a solicitação atual. (Herdado de WebRequest)
KeepAlive	Obtém ou define um valor Boolean que especifica se a conexão de controle com o servidor FTP é fechada depois que a solicitação é concluída.
Method	Obtém ou define o comando a ser enviado ao servidor FTP.
PreAuthenticate	Sempre gera um NotSupportedException.
Proxy	Obtém ou define o proxy usado para se comunicar com o servidor FTP.
ReadWriteTimeout	Obtém ou define um tempo limite durante a leitura ou gravação em um fluxo.
RenameTo	Obtém ou define o novo nome de um arquivo que está sendo renomeado.
RequestUri	Obtém o URI solicitado por essa instância.
ServicePoint	Obtém o objeto ServicePoint usado para conexão ao servidor FTP.
Timeout	Obtém ou define o número de milissegundos de espera de uma solicitação.
UseBinary	Obtém ou define um valor de Boolean que especifica o tipo de dados para as transferências de arquivos.
UseDefaultCredentials	Sempre gera um NotSupportedException.
UsePassive	Obtém ou define o comportamento do processo de transferência de dados de um aplicativo cliente.

Métodos

Nome	Description
Abort()	Encerra uma operação FTP assíncrona.
BeginGetRequestStream(AsyncCallback, Object)	Começa assincronamente abrindo o fluxo de conteúdo de uma solicitação para gravação.
BeginGetResponse(AsyncCallback, Object)	Começa a enviar uma solicitação e receber uma resposta de um servidor FTP de maneira assíncrona.
EndGetRequestStream(IAsyncResult)	Encerra uma operação assíncrona pendente iniciada com BeginGetRequestStream(AsyncCallback, Object).
EndGetResponse(IAsyncResult)	Encerra uma operação assíncrona pendente iniciada com BeginGetResponse(AsyncCallback, Object).
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLifetimeService()	Obsoleto. Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância. (Herdado de MarshalByRefObject)
GetObjectData(SerializationInfo, StreamingContext)	Obsoleto. Popula um SerializationInfo com os dados necessários para serializar o objeto de destino. (Herdado de WebRequest)
GetRequestStream()	Recupera o fluxo usado para carregar dados para um servidor FTP.
GetRequestStreamAsync()	Quando substituído em uma classe descendente, retorna um Stream para gravar dados no recurso da Internet como uma operação assíncrona. (Herdado de WebRequest)
GetResponse()	Retorna a resposta do servidor FTP.
GetResponseAsync()	Quando é substituído em uma classe descendente, retorna uma resposta a uma solicitação à Internet como uma operação assíncrona. (Herdado de WebRequest)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InitializeLifetimeService()	Obsoleto. Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Implantações explícitas de interface

Nome	Description
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Obsoleto. Quando substituído em uma classe descendente, popula uma instância SerializationInfo com os dados necessários para serializar o WebRequest. (Herdado de WebRequest)

Confira também

• FtpWebResponse
• FtpStatusCode
• WebRequestMethods.Ftp
• WebRequest
• WebResponse
• WebClient