C# Caricare tutta la directory tramite FTP

Quello che sto cercando di fare è di caricare un sito web tramite FTP in C# (C Sharp). Quindi ho bisogno di caricare tutti i file e le cartelle all’interno di una cartella, mantenendo la sua struttura. Io sto usando questa FTP classe: http://www.codeproject.com/Tips/443588/Simple-Csharp-FTP-Class per l’effettivo caricamento.

Sono giunto alla conclusione che ho bisogno di scrivere un metodo ricorsivo che passa attraverso ogni sotto-directory della directory principale e caricamento di tutti i file e le cartelle in esso. Questo dovrebbe fare una copia della mia cartella FTP. Problema… non ho idea di come scrivere un metodo del genere. Ho scritto di metodi ricorsivi prima, ma io sono nuovo del FTP parte.

Questo è ciò che ho finora:

private void recursiveDirectory(string directoryPath)
    {
        string[] filePaths = null;
        string[] subDirectories = null;

        filePaths = Directory.GetFiles(directoryPath, "*.*");
        subDirectories = Directory.GetDirectories(directoryPath);

        if (filePaths != null && subDirectories != null)
        {
            foreach (string directory in subDirectories)
            {
                ftpClient.createDirectory(directory);
            }
            foreach (string file in filePaths)
            {
                ftpClient.upload(Path.GetDirectoryName(directoryPath), file);
            }
        }
    }

Ma la sua ben lontano dall’essere finito e non so come continuare. Sono sicuro che più di me ha bisogno di sapere questo! Grazie in anticipo 🙂

Ohh… e sarebbe bello se riferito il suo corso troppo 🙂 (sto usando una barra di avanzamento)

MODIFICA:
Potrebbe essere stato chiaro… Come faccio a caricare una directory, compresi tutti i sotto-cartelle e file con FTP?

  • E la domanda è?
  • Consente di risolvere un semplice problema di prima. Scrivere un metodo che in loop attraverso ogni Cartella all’interno della cartella principale e creare il sito web in questione. Una volta fatto questo dovrebbe essere abbastanza facile da caricare ogni file in ognuna di queste cartelle. Non hai fatto abbastanza per noi per aiutare voi. Io non posso credere che avete il coraggio di fare richieste…..
  • Per creare una barra di avanzamento è necessario per ottenere tutti i file che devono essere caricati. Vorrei memorizzare i percorsi dei file in un Elenco. Loop attraverso i percorsi dei file di upload al server FTP. Dopo ogni caricamento di aggiornare lo stato di avanzamento. Una più accurata bar potrebbe essere ottenuto mediante la memorizzazione, la dimensione del file con il percorso del file. Poi come ogni file viene caricato incrementare il progresso dalla dimensione del file. Se avete bisogno posso aggiungere un esempio di quest’ultimo.
InformationsquelleAutor hsson | 2012-11-09

 

4 Replies
  1. 16

    Problema Risolto! 🙂

    Bene così sono riuscito a scrivere il metodo myslef. Se qualcuno ha bisogno sentitevi liberi di copiare:

    private void recursiveDirectory(string dirPath, string uploadPath)
        {
            string[] files = Directory.GetFiles(dirPath, "*.*");
            string[] subDirs = Directory.GetDirectories(dirPath);
    
            foreach (string file in files)
            {
                ftpClient.upload(uploadPath + "/" + Path.GetFileName(file), file);
            }
    
            foreach (string subDir in subDirs)
            {
                ftpClient.createDirectory(uploadPath + "/" + Path.GetFileName(subDir));
                recursiveDirectory(subDir, uploadPath + "/" + Path.GetFileName(subDir));
            }
        }

    Funziona molto bene 🙂

    • Lavoro, se si sarebbe detto che hai usato e libreria esterna per fare il codice, che comprendono un sacco di altro codice non fatto da voi.
    • Ha fatto in questione. Ma sì mi piacerebbe che la ridondanza di troppo, piuttosto che dover andare a caccia per il link.
    • Questo finisce per creare tutti i file e directory da remoto, ma tutti i file hanno una dimensione di file di 0B. ???
    • Strano. Non ho idea di come funziona la classe per chiunque. Sono stato in grado di risolvere i loro upload() metodo modificando il FileMode valore Open: FileStream localFileStream = new FileStream(localFile, FileMode.Open);
  2. 1

    Ho scritto una classe riutilizzabile per caricare tutta la directory di un ftp site su windows server,
    il programma, inoltre, consente di rinominare la vecchia versione di quella cartella (io la uso per caricare il mio windows programma di servizio per il server).
    forse alcuni hanno bisogno di questo:

    class MyFtpClient
    {
        protected string FtpUser { get; set; }
        protected string FtpPass { get; set; }
        protected string FtpServerUrl { get; set; }
        protected string DirPathToUpload { get; set; }
        protected string BaseDirectory { get; set; }
    
        public MyFtpClient(string ftpuser, string ftppass, string ftpserverurl, string dirpathtoupload)
        {
            this.FtpPass = ftppass;
            this.FtpUser = ftpuser;
            this.FtpServerUrl = ftpserverurl;
            this.DirPathToUpload = dirpathtoupload;
            var spllitedpath = dirpathtoupload.Split('\\').ToArray();
            //last index must be the "base" directory on the server
            this.BaseDirectory = spllitedpath[spllitedpath.Length - 1];
        }
    
    
        public void UploadDirectory()
        {
            //rename the old folder version (if exist)
            RenameDir(BaseDirectory);
            //create a parent folder on server
            CreateDir(BaseDirectory);
            //upload the files in the most external directory of the path
            UploadAllFolderFiles(DirPathToUpload, BaseDirectory);
            //loop trough all files in subdirectories
    
    
    
            foreach (string dirPath in Directory.GetDirectories(DirPathToUpload, "*",
            SearchOption.AllDirectories))
            {
                //create the folder
                CreateDir(dirPath.Substring(dirPath.IndexOf(BaseDirectory), dirPath.Length - dirPath.IndexOf(BaseDirectory)));
    
                Console.WriteLine(dirPath.Substring(dirPath.IndexOf(BaseDirectory), dirPath.Length - dirPath.IndexOf(BaseDirectory)));
                UploadAllFolderFiles(dirPath, dirPath.Substring(dirPath.IndexOf(BaseDirectory), dirPath.Length - dirPath.IndexOf(BaseDirectory))
            }
        }
    
        private void UploadAllFolderFiles(string localpath, string remotepath)
        {
            string[] files = Directory.GetFiles(localpath);
            //get only the filenames and concat to remote path
            foreach (string file in files)
            {
                //full remote path
                var fullremotepath = remotepath + "\\" + Path.GetFileName(file);
                //local path
                var fulllocalpath = Path.GetFullPath(file);
                //upload to server
                Upload(fulllocalpath, fullremotepath);
            }
    
        }
    
        public bool CreateDir(string dirname)
        {
            try
            {
                WebRequest request = WebRequest.Create("ftp://" + FtpServerUrl + "/" + dirname);
                request.Method = WebRequestMethods.Ftp.MakeDirectory;
                request.Proxy = new WebProxy();
                request.Credentials = new NetworkCredential(FtpUser, FtpPass);
                using (var resp = (FtpWebResponse)request.GetResponse())
                {
                    if (resp.StatusCode == FtpStatusCode.PathnameCreated)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
    
            catch
            {
                return false;
            }
        }
    
        public void Upload(string filepath, string targetpath)
        {
    
            using (WebClient client = new WebClient())
            {
                client.Credentials = new NetworkCredential(FtpUser, FtpPass);
                client.Proxy = null;
                var fixedpath = targetpath.Replace(@"\", "/");
                client.UploadFile("ftp://" + FtpServerUrl + "/" + fixedpath, WebRequestMethods.Ftp.UploadFile, filepath);
            }
        }
    
        public bool RenameDir(string dirname)
        {
            var path = "ftp://" + FtpServerUrl + "/" + dirname;
            string serverUri = path;
    
            try
            {
                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(serverUri);
                request.Method = WebRequestMethods.Ftp.Rename;
                request.Proxy = null;
                request.Credentials = new NetworkCredential(FtpUser, FtpPass);
                //change the name of the old folder the old folder
                request.RenameTo = DateTime.Now.ToString("yyyyMMddHHmmss"); 
                FtpWebResponse response = (FtpWebResponse)request.GetResponse();
    
                using (var resp = (FtpWebResponse)request.GetResponse())
                {
                    if (resp.StatusCode == FtpStatusCode.FileActionOK)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            catch
            {
                return false;
            }
        }
    }

    Creare un’istanza di tale classe:

    static void Main(string[] args)
    {
        MyFtpClientftp = new MyFtpClient(ftpuser, ftppass, ftpServerUrl, @"C:\Users\xxxxxxxxxxx");
        ftp.UploadDirectory();
        Console.WriteLine("DONE");
        Console.ReadLine();
    }
    • Bravo!! Questa è la soluzione migliore che ho trovato finora. È manca solo la cartella di destinazione per renderlo ancora migliore.
  3. 0

    A meno che si sta facendo questo per divertimento o per il miglioramento di sé, utilizzare un modulo commerciale. Posso consigliare uno da Chilkat, ma sono sicuro che ci sono altri.

    Nota: sono abbastanza sicuro che questo non risposta il problema indicato, Quello che sto cercando di fare è di caricare un sito web tramite FTP in C# (C Sharp).

Lascia un commento