FtpWebRequest Classe

Definição

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 seguinte demonstra a eliminação de um ficheiro 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 seguinte demonstra como descarregar um ficheiro 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 seguinte demonstra a utilização de operações assíncronas para carregar um ficheiro para 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();
            }
        }
    }
}

Observações

Para obter uma instância de FtpWebRequest, use o Create método. Também pode usar a WebClient classe para carregar e descarregar informações de um servidor FTP. Usando qualquer uma destas abordagens, quando se especifica um recurso de rede que utiliza o esquema FTP (por exemplo, "ftp://contoso.com"), a FtpWebRequest classe oferece a capacidade de interagir programaticamente com servidores FTP.

O URI pode ser relativo ou absoluto. Se o URI for da forma "ftp://contoso.com/%2fpath" (%2f for um '/' escapado), então o URI é absoluto, e o diretório atual é /path. Se, no entanto, o URI for da forma "ftp://contoso.com/path", primeiro .NET Framework faz login no servidor FTP (usando o nome de utilizador e a palavra-passe definidos pela propriedade Credentials), então o diretório atual é definido para <UserLoginDirectory>/path.

Deve ter um nome de utilizador e palavra-passe válidos para o servidor, caso contrário o servidor deve permitir logon anónimo. Pode especificar as credenciais usadas para se ligar ao servidor definindo a Credentials propriedade ou incluí-las na UserInfo parte do URI passada ao Create método. Se incluir UserInfo informação no URI, a Credentials propriedade é definida para uma nova credencial de rede com o nome de utilizador e a palavra-passe especificados.

Tem de WebPermission aceder ao recurso FTP; caso contrário, é lançada uma SecurityException exceção.

Especifique o comando FTP a enviar ao servidor, definindo a Method propriedade para um valor definido na WebRequestMethods.Ftp estrutura. Para transmitir dados de texto, altere a UseBinary propriedade do seu valor predefinido (true) para false. Para detalhes e restrições, veja Method.

Ao usar um FtpWebRequest objeto para carregar um ficheiro para um servidor, deve escrever o conteúdo do ficheiro no fluxo de pedidos obtido ao chamar o GetRequestStream método ou os seus equivalentes assíncronos, os BeginGetRequestStream métodos and EndGetRequestStream . Tens de escrever no stream e fechá-lo antes de enviar o pedido.

Os pedidos são enviados ao servidor chamando o GetResponse método ou os seus equivalentes assíncronos, os BeginGetResponse métodos e.EndGetResponse Quando a operação solicitada termina, um FtpWebResponse objeto é devolvido. O FtpWebResponse objeto fornece o estado da operação e quaisquer dados descarregados do servidor.

Pode definir um valor de time-out para leitura ou escrita no servidor usando a ReadWriteTimeout propriedade. Se o período de time-out for ultrapassado, o método de chamada lança um WebException com WebExceptionStatus definido como Timeout.

Ao descarregar um ficheiro de um servidor FTP, se o comando foi bem-sucedido, o conteúdo do ficheiro solicitado está disponível no fluxo do objeto de resposta. Pode aceder a este fluxo chamando o GetResponseStream método. Para obter mais informações, veja FtpWebResponse.

Se a Proxy propriedade estiver definida, seja diretamente ou num ficheiro de configuração, as comunicações com o servidor FTP são feitas através do proxy especificado. Se o proxy especificado for um proxy HTTP, apenas os comandos DownloadFile, ListDirectory e ListDirectoryDetails são suportados.

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

Múltiplos FtpWebRequests reutilizam ligações existentes, se possível.

Para mais informações sobre o protocolo FTP, consulte RFC 959: Protocolo de Transferência de Ficheiros.

Ver também

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