Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase FtpWebRequest

 

Publicado: octubre de 2016

Implementa un cliente de protocolo de transferencia de archivos (FTP).

Espacio de nombres:   System.Net
Ensamblado:  System (en System.dll)

System.Object
  System.MarshalByRefObject
    System.Net.WebRequest
      System.Net.FtpWebRequest

public sealed class FtpWebRequest : WebRequest

NombreDescripción
System_CAPS_pubpropertyAuthenticationLevel

Obtiene o establece valores que indican el nivel de autenticación y de suplantación utilizados para esta solicitud.(Heredado de WebRequest).

System_CAPS_pubpropertyCachePolicy

Obtiene o establece la directiva de caché para esta solicitud.(Heredado de WebRequest).

System_CAPS_pubpropertyClientCertificates

Obtiene o establece los certificados usados para establecer una conexión cifrada con el servidor FTP.

System_CAPS_pubpropertyConnectionGroupName

Obtiene o establece el nombre del grupo de conexiones que contiene el punto de servicio usado para enviar la solicitud actual.(Invalida WebRequest.ConnectionGroupName).

System_CAPS_pubpropertyContentLength

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Obtiene o establece un valor omitido por la clase FtpWebRequest.(Invalida WebRequest.ContentLength).

System_CAPS_pubpropertyContentOffset

Obtiene o establece un desplazamiento de bytes en el archivo que descargará esta solicitud.

System_CAPS_pubpropertyContentType

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Siempre inicia una NotSupportedException.(Invalida WebRequest.ContentType).

System_CAPS_pubpropertyCreatorInstance

Obsoleto. Cuando se reemplaza en una clase descendiente, obtiene el objeto generador derivado de la clase IWebRequestCreate usada para crear la instancia de WebRequest para efectuar la solicitud al URI especificado.(Heredado de WebRequest).

System_CAPS_pubpropertyCredentials

Obtiene o establece las credenciales usadas para la comunicación con el servidor FTP.(Invalida WebRequest.Credentials).

System_CAPS_pubpropertySystem_CAPS_staticDefaultCachePolicy

Define la directiva de caché predeterminada para todas las solicitudes FTP.

System_CAPS_pubpropertyEnableSsl

Obtiene o establece un valor Boolean que especifica que se debe usar una conexión SSL.

System_CAPS_pubpropertyHeaders

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Obtiene un objeto WebHeaderCollection vacío.(Invalida WebRequest.Headers).

System_CAPS_pubpropertyImpersonationLevel

Obtiene o establece el nivel de suplantación para la solicitud actual.(Heredado de WebRequest).

System_CAPS_pubpropertyKeepAlive

Obtiene o establece un valor Boolean que especifica si la conexión de control al servidor FTP se cierra después de que la solicitud se complete.

System_CAPS_pubpropertyMethod

Obtiene o establece el comando que se envía al servidor FTP.(Invalida WebRequest.Method).

System_CAPS_pubpropertyPreAuthenticate

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Siempre inicia una NotSupportedException.(Invalida WebRequest.PreAuthenticate).

System_CAPS_pubpropertyProxy

Obtiene o establece el servidor proxy que se usa para la comunicación con el servidor FTP.(Invalida WebRequest.Proxy).

System_CAPS_pubpropertyReadWriteTimeout

Obtiene o establece un tiempo de espera para una operación de lectura o escritura en una secuencia.

System_CAPS_pubpropertyRenameTo

Obtiene o establece el nuevo nombre de un archivo al que se cambia el nombre.

System_CAPS_pubpropertyRequestUri

Obtiene el identificador URI solicitado por esta instancia.(Invalida WebRequest.RequestUri).

System_CAPS_pubpropertyServicePoint

Obtiene el objeto ServicePoint usado para conectarse al servidor FTP.

System_CAPS_pubpropertyTimeout

Obtiene o establece el número de milisegundos de espera para una solicitud.(Invalida WebRequest.Timeout).

System_CAPS_pubpropertyUseBinary

Obtiene o establece un valor Boolean que especifica el tipo de datos para las transferencias de archivos.

System_CAPS_pubpropertyUseDefaultCredentials

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Siempre inicia una NotSupportedException.(Invalida WebRequest.UseDefaultCredentials).

System_CAPS_pubpropertyUsePassive

Obtiene o establece el comportamiento del proceso de transferencia de datos de una aplicación cliente.

NombreDescripción
System_CAPS_pubmethodAbort()

Finaliza una operación FTP asincrónica.(Invalida WebRequest.Abort()).

System_CAPS_pubmethodBeginGetRequestStream(AsyncCallback, Object)

Empieza a abrir para escritura de forma asincrónica la secuencia de contenido de una solicitud.(Invalida WebRequest.BeginGetRequestStream(AsyncCallback, Object)).

System_CAPS_pubmethodBeginGetResponse(AsyncCallback, Object)

Empieza enviando una solicitud y recibiendo de forma asincrónica una respuesta de un servidor FTP.(Invalida WebRequest.BeginGetResponse(AsyncCallback, Object)).

System_CAPS_pubmethodCreateObjRef(Type)

Crea un objeto que contiene toda la información relevante necesaria para generar a un proxy que se utiliza para comunicarse con un objeto remoto.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodEndGetRequestStream(IAsyncResult)

Finaliza una operación asincrónica pendiente iniciada con BeginGetRequestStream.(Invalida WebRequest.EndGetRequestStream(IAsyncResult)).

System_CAPS_pubmethodEndGetResponse(IAsyncResult)

Finaliza una operación asincrónica pendiente iniciada con BeginGetResponse.(Invalida WebRequest.EndGetResponse(IAsyncResult)).

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodGetRequestStream()

Recupera la secuencia usada para cargar datos a un servidor FTP.(Invalida WebRequest.GetRequestStream()).

System_CAPS_pubmethodGetRequestStreamAsync()

Cuando se invalida en una clase descendiente, devuelve un objeto Stream para escribir datos en el recurso de Internet como una operación asincrónica.(Heredado de WebRequest).

System_CAPS_pubmethodGetResponse()

Devuelve la respuesta del servidor FTP.(Invalida WebRequest.GetResponse()).

System_CAPS_pubmethodGetResponseAsync()

Cuando se invalida en una clase descendiente, devuelve una respuesta a una solicitud de Internet como una operación asincrónica.(Heredado de WebRequest).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodInitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethodISerializable.GetObjectData(SerializationInfo, StreamingContext)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Cuando se reemplaza en una clase descendiente, rellena una instancia de SerializationInfo con los datos necesarios para serializar el objeto WebRequest.(Heredado de WebRequest).

Para obtener una instancia de FtpWebRequest, utilice el Create método. También puede utilizar el WebClient clase para cargar y descargar información desde un servidor FTP. Con cualquiera de estos enfoques, cuando se especifica un recurso de red que utiliza el esquema FTP (por ejemplo, "ftp://contoso.com") la FtpWebRequest clase proporciona la capacidad para interactuar mediante programación con servidores FTP.

El URI puede ser relativa o absoluta. Si el URI tiene la forma "ftp://contoso.com/%2fpath" (% 2f es el carácter de escape '/'), el URI es absoluto y el directorio actual es /path. Si, sin embargo, el URI tiene la forma "ftp://contoso.com/path", en primer lugar .NET Framework inicia sesión en el servidor FTP (con el nombre de usuario y contraseña establecido por el Credentials propiedad), el directorio actual se establece en <UserLoginDirectory>/path.

Debe tener un nombre de usuario y contraseña para el servidor o el servidor debe permitir el inicio de sesión anónimo. Puede especificar las credenciales usadas para conectarse al servidor estableciendo la Credentials propiedad o se pueden incluir en la UserInfo parte del URI pasado a la Create (método). Si incluye UserInfo información en el URI del Credentials propiedad se establece en una nueva credencial de red con la información de nombre y la contraseña del usuario especificado.

System_CAPS_cautionPrecaución

A menos que el EnableSsl propiedad es true, todos los datos y comandos, incluida la información de nombre y la contraseña de usuario, se envían al servidor en texto no cifrado. Cualquier usuario que supervise el tráfico de red puede ver sus credenciales y utilizarlas para conectarse al servidor. Si se conecta a un servidor FTP que requiere credenciales y admite Secure Sockets Layer (SSL), debe establecer EnableSsl a true.

Debe tener WebPermission para tener acceso al recurso FTP; en caso contrario, un SecurityException excepción.

Especificar el comando FTP para enviar al servidor estableciendo la Method propiedad a un valor definido en el WebRequestMethods.Ftp estructura. Para transmitir datos de texto, cambie el UseBinary propiedad de su valor predeterminado (true) a false. Para obtener más información y restricciones, consulte Method.

Cuando se usa un FtpWebRequest objeto que se va a cargar un archivo en un servidor, debe escribir el contenido del archivo en la secuencia de solicitud que se obtiene al llamar a la GetRequestStream método o sus homólogos asincrónicos, el BeginGetRequestStream y EndGetRequestStream métodos. Debe escribir en la secuencia y cerrar la secuencia antes de enviar la solicitud.

Las solicitudes se envían al servidor mediante una llamada a la GetResponse método o sus homólogos asincrónicos, los BeginGetResponse y EndGetResponse métodos. Cuando se complete la operación solicitada, un FtpWebResponse devuelve el objeto. La FtpWebResponse objeto proporciona el estado de la operación y los datos que se descargan desde el servidor.

Puede establecer un valor de tiempo de espera para leer o escribir en el servidor mediante el ReadWriteTimeout propiedad. Si se supera el tiempo de espera, el método de llamada produce una WebException con WebExceptionStatus establecido en Timeout.

Al descargar un archivo desde un servidor FTP, si el comando es correcto, el contenido del archivo solicitado está disponible en la secuencia del objeto de respuesta. Puede tener acceso a esta secuencia mediante una llamada a la GetResponseStream (método). Para obtener más información, consulta FtpWebResponse.

Si el Proxy propiedad se establece, directamente o en un archivo de configuración, las comunicaciones con el servidor FTP se realizan a través del proxy especificado. Si el proxy especificado es un proxy HTTP, sólo el DownloadFile, ListDirectory, y ListDirectoryDetails se admiten los comandos.

Se almacena en caché de solo descarga contenido binario; es decir, el contenido recibido utilizando el DownloadFile comando con el UseBinary propiedad establecida en true.

Varios FtpWebRequests reutilizar las conexiones existentes, si es posible.

Para obtener más información acerca del protocolo FTP, vea RFC 959, "File Transfer Protocol," disponible en http://www.rfc-editor.org/.

En el ejemplo de código siguiente se muestra cómo eliminar un archivo desde un 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;
}

En el ejemplo de código siguiente se muestra cómo descargar un archivo desde un servidor FTP mediante el WebClient (clase).

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;
}

En el ejemplo de código siguiente se muestra cómo utilizar operaciones asincrónicas para cargar un archivo a un 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();
            }
        }
    }
}

WebPermission

for accessing the resource referenced by this request. Associated enumeration: F:System.Net.NetworkAccess.Connect.

.NET Framework
Disponible desde 2.0

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: