[ASP.NET C#] Upload FTP

[ruttoloruttolo]

Ciao a tutti.
Ho un problema con una mini applicazione di Upload via FTP da integrare ad un sistema già esistente.
Il problema consiste nel non avere un feedback di termine upload su file di grossa dimensione. Questo comporta che la pagina di upload resta in standby e chi s'è visto s'è visto.
Il problema non accade invece con file piccoli.
Di seguito l'estrazione dell'ultima versione della funzione di upload che sto realizzando.

public void UploadFile()
        {
            object w = new object();
            try
            {
                string nameFile = FTP_FileUpload.FileName;
                bool okUpload = false;
                if (!Ftp_ExistFile(FTP_FileUpload.FileName))
                {
                    okUpload = true;
                }
                else
                {
                    if (nameFile == FileEsistente)
                    {
                        okUpload = true;
                    }
                    else
                    {
                        throw new Exception("ATTENZIONE!
Il file " + FTP_FileUpload.FileName + " è già presente nella directory " + SubDir + "
Rinominare il file e ripetere l'operazione oppure selezionare il file dalla directory attraverso la funzionalità di ricerca.");
                    }

                }

                if (okUpload)
                {

                    #region Upload del File

                    //Apro una connessione
                    FtpWebRequest ftp = (FtpWebRequest)WebRequest.Create(FTP_Server + SubDir + "/" + nameFile);
                    ftp.UsePassive = true;
                    ftp.ReadWriteTimeout = 10000000;
                    ftp.Timeout = 10000000; // Any big number
                    //ftp.KeepAlive = true;

                    //Aggiungo le credenziali
                    ftp.Credentials = new NetworkCredential(FTP_User, FTP_PWD);

                    //Indico il comando di uplaod
                    ftp.Method = WebRequestMethods.Ftp.UploadFile;
                    byte[] arrayFile = new byte[FTP_FileUpload.PostedFile.ContentLength];
                    Stream read = FTP_FileUpload.PostedFile.InputStream;

                    //Riempio l'array
                    read.Read(arrayFile, 0, FTP_FileUpload.PostedFile.ContentLength);
                    w = ftp.GetRequestStream();

                    //Scrivo il contenuto dell'array
                    ((Stream)w).Write(arrayFile, 0, arrayFile.Length);
                    //((Stream)w).Close();

                    #endregion

                    #region Verifica Stato Upload

                    int FileDimension = 0;
                    while (FTP_FileUpload.FileBytes.Length > FileDimension)
                    {
                        FtpWebRequest _FtpRequest = (FtpWebRequest)WebRequest.Create(FTP_Server + SubDir + "/" + nameFile);
                        _FtpRequest.Credentials = new NetworkCredential(FTP_User, FTP_PWD);

                        //Richiesta ListDirectory
                        _FtpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;

                        //Inoltro richiesta e attesa risposta
                        FtpWebResponse _FtpResponse = (FtpWebResponse)(_FtpRequest.GetResponse());

                        //La risposta è uno stream
                        StreamReader sr = new StreamReader(_FtpResponse.GetResponseStream(), System.Text.Encoding.ASCII);

                        string file = sr.ReadToEnd();

                        FileDimension = Convert.ToInt32(file.Split(' ')[file.Split(' ').Length - 5]);
                    }
                    #endregion

                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally 
            {
                ((Stream)w).Close();
                //((Stream)w).Dispose();
            }
            
            return;

        } 

Grazie in anticipo.
Sergio

P.S.
La "Verifica Stato Upload" è stata aggiunta per vedere tramite debug l'effettivo upload del file. Probabilmente verrà successivamente integrata per comunicare l'avanzamento del processo.

[ruttoloruttolo]

Il problema non l'ho risolto, l'ho aggirato.
Ho sfruttato il controllo della dimensione per stabilire quando il file è stato completato, e quando le dimensioni dei file (locale - remoto) coincide killo il processo FTP.
Potete anche notare che ho killato tutti i processi FTP quando "non servono +" in modo da non avere processi appesi inutilmente (cosa quasi inutile ma meglio essere sicuri dati i problemi che ho)

Di seguito il codice.


CodeBehind della pagina

    public partial class Page_UploadFTP : System.Web.UI.Page
    {

        _UploadFTP UP_FTP = new _UploadFTP();
        Thread thr = null;
        string nomeCampo;
    
        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                UP_FTP.FTP_Server = "ftp://xxxxxxxx";
                UP_FTP.FTP_User = "xxxxxxxxx";
                UP_FTP.FTP_PWD = "xxxxxxxxx";

                UP_FTP.FileEsistente = Request.QueryString.GetValues("fileesistente")[0];
                UP_FTP.SubDir = Request.QueryString.GetValues("uploadsubdir")[0];
                UP_FTP.ArrVersioni = Request.QueryString.GetValues("arrversioni")[0];
                UP_FTP.FTP_FileUpload = FileUpload1;
                nomeCampo = Request.QueryString.GetValues("nomeCampo")[0];
            }
            catch(Exception ex)
            {
                Response.Redirect("@UploadFile.aspx?uploadSubdir=&arrVersioni=&nomeCampo=Immagine&fileEsistente=prova.txt");
            }

        }

        protected void btnUpload_Click(object sender, EventArgs e)
        {
            string result ="";
            try
            {
                thr = new Thread(new ThreadStart(VerificaUpload));
                thr.Start();
                Upload();
            }
            catch (Exception ex)
            {
                thr.Abort();

                result = ex.Message;
            }

            finally
            {
                if (result.ToLower().Contains("abort") || result=="")
                    result="Upload OK";
                else
                    if (result.ToLower().Contains("(501)"))
                    {
                        result = "C'è stato un problema di connessione al server FTP.";
                        lnkRiprova.Visible = true;
                    }
                    else
                        lnkRiprova.Visible = false;

                lbl_Error.Text = result;
                lbl_Error.Visible = true;
            }
        }

        public void Upload()
        {
            UP_FTP.UploadFile();
        }

        public void VerificaUpload()
        {
            long FileDimension = 0;
            while (FileUpload1.FileBytes.Length > FileDimension)
            {
                try
                {
                    FileDimension = UP_FTP.VerificaUpload();
                }
                catch (Exception ex)
                {
                }
            }

            UP_FTP.Abort();
        }

    } 

Classe _UploadFTP

    public class _UploadFTP
    {
        protected string _FTP_Server = "";
        protected string _FTP_User = "";
        protected string _FTP_PWD = "";

        protected FileUpload _FileUpload;

        protected string _SubDir = "";
        protected string _ArrVersioni = "";
        protected string _FileEsistente = "";
        FtpWebRequest ftp = null;

        public void Abort()
        {
            if(ftp!=null)
                ftp.Abort();
        }

        public void UploadFile()
        {
            object w = new object();
            try
            {
                string nameFile = FTP_FileUpload.FileName;
                bool okUpload = false;
                if (!Ftp_ExistFile(FTP_FileUpload.FileName))
                {
                    okUpload = true;
                }
                else
                {
                    if (nameFile == FileEsistente)
                    {
                        okUpload = true;
                    }
                    else
                    {
                        throw new Exception("ATTENZIONE!
Il file " + FTP_FileUpload.FileName + " è già presente nella directory " + SubDir + "
Rinominare il file e ripetere l'operazione oppure selezionare il file dalla directory attraverso la funzionalità di ricerca.");
                    }

                }

                if (okUpload)
                {

                    #region Upload del File

                    //Apro una connessione
                    ftp = (FtpWebRequest)WebRequest.Create(FTP_Server + SubDir + "/" + nameFile);
                    ftp.UsePassive = true;
                    ftp.UseBinary = true;
                    //ftp.KeepAlive = false;
                    ftp.ReadWriteTimeout = 10000000; // In millisecondi
                    ftp.Timeout = 10000000; // In millisecondi
                    
                    //Aggiungo le credenziali
                    ftp.Credentials = new NetworkCredential(FTP_User, FTP_PWD);

                    //Indico il comando di uplaod
                    ftp.Method = WebRequestMethods.Ftp.UploadFile;
                    byte[] arrayFile = new byte[FTP_FileUpload.PostedFile.ContentLength];
                    Stream read = FTP_FileUpload.PostedFile.InputStream;

                    //Riempio l'array
                    read.Read(arrayFile, 0, FTP_FileUpload.PostedFile.ContentLength);
                    w = ftp.GetRequestStream();

                    //Scrivo il contenuto dell'array
                    ((Stream)w).Write(arrayFile, 0, arrayFile.Length);
                    //((Stream)w).Close();

                    #endregion

                    ((Stream)w).Close();
                }

            }
            catch (Exception ex)
            {
                try
                {
                    ((Stream)w).Close();
                    
                }
                catch (Exception ex1)
                {
                }
                
                this.Abort();

                throw ex;
            }
            
            //return;

        }

        public long VerificaUpload()
        {
            #region Verifica Stato Upload

            FtpWebRequest _FtpRequest = (FtpWebRequest)WebRequest.Create(FTP_Server + SubDir + "/" + FTP_FileUpload.FileName);
            _FtpRequest.Credentials = new NetworkCredential(FTP_User, FTP_PWD);

            //Richiesta ListDirectory
            _FtpRequest.Method = WebRequestMethods.Ftp.GetFileSize;

            //Inoltro richiesta e attesa risposta
            FtpWebResponse _FtpResponse = (FtpWebResponse)(_FtpRequest.GetResponse());

            _FtpRequest.Abort();
            return _FtpResponse.ContentLength;
        
            #endregion
        }

        private Boolean Ftp_ExistFile(string NomeFile)
        {
            FtpWebRequest _FtpRequest = null;

            try
            {

                #region Verifica Esistenza SubDir

                //Connessione
                _FtpRequest = (FtpWebRequest)WebRequest.Create(FTP_Server + SubDir);
                _FtpRequest.Credentials = new NetworkCredential(FTP_User, FTP_PWD);

                //Richiesta ListDirectory
                _FtpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;

                //Inoltro richiesta e attesa risposta
                FtpWebResponse _FtpResponse = (FtpWebResponse)_FtpRequest.GetResponse();

                //La risposta è uno stream
                StreamReader sr = new StreamReader(_FtpResponse.GetResponseStream(), System.Text.Encoding.ASCII);

                string file = sr.ReadToEnd();

                if (file.Length == 0)
                    throw new Exception("ATTENZIONE!
La Directory da usare per effettuare l'Upload risulta inesistente.
Rinominare la Directory e quindi riprovare.");

                #endregion

                else
                {

                    #region Verifica Esistenza File

                    //Connessione
                    _FtpRequest = (FtpWebRequest)WebRequest.Create(FTP_Server + SubDir + "/" + NomeFile);
                    _FtpRequest.Credentials = new NetworkCredential(FTP_User, FTP_PWD);

                    //Richiesta ListDirectory
                    _FtpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;

                    //Inoltro richiesta e attesa risposta
                    _FtpResponse = (FtpWebResponse)_FtpRequest.GetResponse();

                    //La risposta è uno stream
                    sr = new StreamReader(_FtpResponse.GetResponseStream(), System.Text.Encoding.ASCII);

                    file = sr.ReadToEnd();

                    if (file.Length > 0)
                        return true;
                    else
                        return false;

                    #endregion

                }
            }
            catch (WebException ex)
            {
                throw ex;
            }
            finally 
            {
                _FtpRequest.Abort();
            }

        }

        public string FTP_Server
        {
            get { return _FTP_Server; }
            set { _FTP_Server = value; }
        }
        public string FTP_User
        {
            get { return _FTP_User; }
            set { _FTP_User = value; }
        }
        public string FTP_PWD
        {
            get { return _FTP_PWD; }
            set { _FTP_PWD = value; }
        }
        public FileUpload FTP_FileUpload
        {
            get { return _FileUpload; }
            set { _FileUpload = value; }
        }
        public string SubDir
        {
            get { return _SubDir; }
            set { _SubDir = value; }
        }
        public string ArrVersioni
        {
            get { return _ArrVersioni; }
            set { _ArrVersioni = value; }
        }
        public string FileEsistente
        {
            get { return _FileEsistente; }
            set { _FileEsistente = value; }
        }
    }
}