FTP con C#

La siguiente es una clase que hice para subir, bajar, eliminar y renombrar archivos y carpetas en un servidor FTP con c#.

    /// <summary>
    /// Clase para hacer uso de un servidor FTP
    /// </summary>
    /// <date>2007-07-11</date>
    /// <author>Rodrigo Barros Pascual</author>
    public class ManejadorFTP
    {
        #region <<Propiedades>>

        private String _usuario;

        /// <summary>
        /// Usuario FTP
        /// </summary>
        public String Usuario
        {
            get { return _usuario; }
            set { _usuario = value; }
        }

        private String _contraseña;
        /// <summary>
        /// Contraseña de Usuario FTP
        /// </summary>
        public String Contraseña
        {
            get { return _contraseña; }
            set { _contraseña = value; }
        }

        private String _servidor;

        /// <summary>
        /// URL servidor FTP
        /// </summary>
        public String Servidor
        {
            get { return _servidor; }
            set { _servidor = value; }
        }

             

        #endregion

        /// <summary>
        /// Sube Documentos al servidor FTP
        /// </summary>
        /// <param name=pPathDocumento">Path del Documento</param>"
        /// <param name=pNombreDocumento">Nombre del Documento</param>"
        /// <param name=pPathServidor">Path en el servidor donde se guardará el documento</param>"
        public void SubirDocumento(string pPathDocumento, string pNombreDocumento, string pPathServidor)
        {
            try
            {
                WebClient request = new WebClient();
                request.Credentials = new NetworkCredential(Usuario, Contraseña);
                request.UploadFile(Servidor + pPathServidor + pNombreDocumento, pPathDocumento + "\\" + pNombreDocumento);
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar subir el documento al servidor.", ex);
            }
        }

        /// <summary>
        /// Sube archivos al servidor FTP
        /// </summary>
        /// <param name=pPathDocumento">Path del Documento</param>"
        /// <param name=pNombreDocumento">Nombre del Documento</param>"
        public void SubirDocumento(string pPathDocumento, string pNombreDocumento)
        {
            SubirDocumento(pPathDocumento, pNombreDocumento, String.Empty);
        }

        /// <summary>
        /// Baja Documentos del servidor FTP
        /// </summary>
        /// <param name=pPathServidor">Ruta del Documento en el servidor</param>"
        /// <param name=pNombreDocumento">Nombre y extensión del Documento</param>"
        /// <param name=pPathFisico">Ruta del documento en el sistema de archivos</param>"
        /// <param name=pNombreFisico">Nombre y extensión que se le asignará al documento en el sistema de archivos</param>"
        public void BajarDocumento(string pPathServidor, string pNombreDocumento, string pPathFisico, string pNombreFisico)
        {
            try
            {
                WebClient request = new WebClient();
                request.Credentials = new NetworkCredential(Usuario, Contraseña);
                request.DownloadFile(Servidor + pPathServidor + pNombreDocumento, pPathFisico + "\\" + pNombreFisico);
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar bajar el documento del servidor.", ex);
            }
        }

        /// <summary>
        /// Baja Documentos del servidor FTP
        /// </summary>
        /// <param name=pNombreDocumento">Nombre y extensión del Documento situado en el directorio raíz</param>"
        /// <param name=pPathFisico">Ruta del documento en el sistema de archivos</param>"
        /// <param name=pNombreFisico">Nombre y extensión que se le asignará al documento en el sistema de archivos</param>"
        public void BajarDocumento(string pNombreDocumento, string pPathFisico, string pNombreFisico)
        {
            BajarDocumento(String.Empty, pNombreDocumento, pPathFisico, pNombreFisico);
        }

        /// <summary>
        /// Crea directorios en el servidor FTP
        /// </summary>
        /// <param name=pPathDirectorio">Path del directorio</param>"
        /// <param name=pNombreDirectorio">Nombre del directorio</param>"
        public String CrearDirectorio(string pPathDirectorio, string pNombreDirectorio)
        {
            try
            {
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPathDirectorio + "/" + pNombreDirectorio);
                ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
                ftp.KeepAlive = false;
                ftp.Method = WebRequestMethods.Ftp.MakeDirectory;
                ftp.Proxy = null;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                return response.StatusDescription;
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar crear el directorio en el servidor.", ex);
            }
        }

        /// <summary>
        /// Crea directorios en el servidor FTP
        /// </summary>
        /// <param name=pNombreDirectorio">Nombre del directorio que se agregará al directorio raíz</param>"
        public String CrearDirectorio(string pNombreDirectorio)
        {
            return CrearDirectorio(String.Empty, pNombreDirectorio);
        }

        /// <summary>
        /// Elimina directorios en el servidor FTP
        /// </summary>
        /// <param name=pPathDirectorio">Path del directorio</param>"
        /// <param name=pNombreDirectorio">Nombre del directorio</param>"
        public String EliminarDirectorio(string pPathDirectorio, string pNombreDirectorio)
        {
            try
            {
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPathDirectorio + "/" + pNombreDirectorio);
                ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
                ftp.KeepAlive = false;
                ftp.Method = WebRequestMethods.Ftp.RemoveDirectory;
                ftp.Proxy = null;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                return response.StatusDescription;
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar eliminar el directorio del servidor.", ex);
            }
        }

        /// <summary>
        /// Elimina directorios en el servidor FTP
        /// </summary>
        /// <param name=pNombreDirectorio">Nombre del directorio que se eliminará del directorio raíz</param>"
        public String EliminarDirectorio(string pNombreDirectorio)
        {
            return EliminarDirectorio(String.Empty, pNombreDirectorio);
        }

        /// <summary>
        /// Renombra directorios en el servidor FTP
        /// </summary>
        /// <param name=pPathDirectorio">Path del directorio</param>"
        /// <param name=pNombreDirectorio">Nombre del directorio</param>"
        /// <param name=pNuevoNombreDirectorio">Nombre con el que se renombrará</param>"
        public String RenombrarDirectorio(string pPathDirectorio, string pNombreDirectorio, string pNuevoNombreDirectorio)
        {
            return Renombrar(pPathDirectorio, pNombreDirectorio, pNuevoNombreDirectorio);
        }

        /// <summary>
        /// Renombra directorios en el servidor FTP
        /// </summary>
        /// <param name=pNombreDirectorio">Nombre del directorio</param>"
        /// <param name=pNuevoNombreDirectorio">Nombre con el que se renombrará</param>"
        public String RenombrarDirectorio(string pNombreDirectorio, string pNuevoNombreDirectorio)
        {
            return Renombrar(String.Empty, pNombreDirectorio, pNuevoNombreDirectorio);
        }

        /// <summary>
        /// Renombra Documentos en el servidor FTP
        /// </summary>
        /// <param name=pPathDocumento">Path del Documento</param>"
        /// <param name=pNombreDocumento">Nombre del Documento</param>"
        /// <param name=pNuevoNombreDocumento">Nombre con el que se renombrará</param>"
        public String RenombrarDocumento(string pPathDocumento, string pNombreDocumento, string pNuevoNombreDocumento)
        {
            return Renombrar(pPathDocumento, pNombreDocumento, pNuevoNombreDocumento);
        }

        /// <summary>
        /// Renombra Documentos en el servidor FTP
        /// </summary>
        /// <param name=pNombreDocumento">Nombre del Documento</param>"
        /// <param name=pNuevoNombreDocumento">Nombre con el que se renombrará</param>"
        public String RenombrarDocumento(string pNombreDocumento, string pNuevoNombreDocumento)
        {
            return Renombrar(String.Empty, pNombreDocumento, pNuevoNombreDocumento);
        }

        /// <summary>
        /// Renombra en el servidor FTP
        /// </summary>
        /// <param name=pPath">Path del directorio o documento</param>"
        /// <param name=pNombre">Nombre del directorio o documento</param>"
        /// <param name=pNuevoNombre">Nombre con el que se renombrará</param>"
        private String Renombrar(string pPath, string pNombre, string pNuevoNombre)
        {
            try
            {
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPath + "/" + pNombre);
                ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
                ftp.KeepAlive = false;
                ftp.Method = WebRequestMethods.Ftp.Rename;
                ftp.RenameTo = pNuevoNombre;
                ftp.Proxy = null;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                return response.StatusDescription;
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar renombrar en el servidor.", ex);
            }
        }

        /// <summary>
        /// Elimina documentos en el servidor FTP
        /// </summary>
        /// <param name=pPathDirectorio">Path del documento</param>"
        /// <param name=pNombreDirectorio">Nombre del documento</param>"
        public String EliminarDocumento(string pPathDocumento, string pNombreDocumento)
        {
            try
            {
                FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPathDocumento + "/" + pNombreDocumento);
                ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
                ftp.KeepAlive = false;
                ftp.Method = WebRequestMethods.Ftp.DeleteFile;
                ftp.Proxy = null;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                return response.StatusDescription;
            }
            catch (Exception ex)
            {
                throw new Exception("Error al intentar eliminar el documento del servidor.", ex);
            }
        }

        /// <summary>
        /// Elimina documentos en el servidor FTP
        /// </summary>
        /// <param name=pNombreDirectorio">Nombre del documento</param>"
        public String EliminarDocumento(string pNombreDocumento)
        {
            return EliminarDocumento(String.Empty, pNombreDocumento);
        }

        /// <summary>
        /// Constructor por defecto.
        /// </summary>
        /// <param name=pUsuario">Usuario FTP</param>"
        /// <param name=pContraseña">Contraseña de usuario FTP</param>"
        /// <param name=pURLServidor">URL del servidor FTP</param>"
        public ManejadorFTP(String pUsuario, String pContraseña, String pURLServidor)
        {
            Usuario = pUsuario;
            Contraseña = pContraseña;
            Servidor = pURLServidor;
        }

    }

Espero que les sirva.